(command.CommandList
  children: [
    (command.ShFunction
      name_tok: <_rpm_installed_packages>
      name: _rpm_installed_packages
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.If
              if_kw: <Id.KW_If if>
              arms: [
                (IfArm
                  keyword: <Id.KW_If if>
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              left: <Id.KW_DLeftBracket '[['>
                              expr: 
                                (bool_expr.LogicalAnd
                                  left: 
                                    (bool_expr.Unary
                                      op_id: Id.BoolUnary_r
                                      child: {<'/var/log/rpmpkgs'>}
                                    )
                                  right: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_nt
                                      left: {<'/var/log/rpmpkgs'>}
                                      right: {<'/var/lib/rpm/Packages'>}
                                    )
                                )
                              right: <Id.Lit_DRightBracket ']]'>
                              redirects: []
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  then_kw: <Id.KW_Then then>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'COMPREPLY='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'COMPREPLY='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'COMPREPLY='> name:COMPREPLY)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (ShArrayLiteral
                                left: <Id.Op_LParen _>
                                words: [
                                  {
                                    (CommandSub
                                      left_token: <Id.Left_DollarParen '$('>
                                      child: 
                                        (command.Simple
                                          blame_tok: <compgen>
                                          more_env: []
                                          words: [
                                            {<compgen>}
                                            {<-W>}
                                            {
                                              (DQ 
                                                (CommandSub
                                                  left_token: <Id.Left_DollarParen '$('>
                                                  child: 
                                                    (command.Simple
                                                      blame_tok: <sed>
                                                      more_env: []
                                                      words: [
                                                        {<sed>}
                                                        {<-ne>}
                                                        {
                                                          (SQ 
                                                            <
's|^\\([^[:space:]]\\{1,\\}\\)-[^[:space:]-]\\{1,\\}-[^[:space:]-]\\{1,\\}\\.rpm$|\\1|p'
                                                            >
                                                          )
                                                        }
                                                        {<'/var/log/rpmpkgs'>}
                                                      ]
                                                      redirects: []
                                                      do_fork: T
                                                    )
                                                  right: <Id.Eof_RParen _>
                                                )
                                              )
                                            }
                                            {<-->}
                                            {(DQ ($ Id.VSub_DollarName cur))}
                                          ]
                                          redirects: []
                                          do_fork: T
                                        )
                                      right: <Id.Eof_RParen _>
                                    )
                                  }
                                ]
                                right: <Id.Right_ShArrayLiteral _>
                              )
                            }
                        )
                      ]
                      redirects: []
                    )
                  ]
                  spids: [15 36]
                )
                (IfArm
                  keyword: <Id.KW_Elif elif>
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.Simple
                              blame_tok: <type>
                              more_env: []
                              words: [{<type>} {<rpmqpack>}]
                              redirects: [
                                (Redir
                                  op: <Id.Redir_AndGreat '&>'>
                                  loc: (redir_loc.Fd fd:1)
                                  arg: {<'/dev/null'>}
                                )
                              ]
                              do_fork: T
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  then_kw: <Id.KW_Then then>
                  action: [
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'COMPREPLY='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'COMPREPLY='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'COMPREPLY='> name:COMPREPLY)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (ShArrayLiteral
                                left: <Id.Op_LParen _>
                                words: [
                                  {
                                    (CommandSub
                                      left_token: <Id.Left_DollarParen '$('>
                                      child: 
                                        (command.Simple
                                          blame_tok: <compgen>
                                          more_env: []
                                          words: [
                                            {<compgen>}
                                            {<-W>}
                                            {(SQ <'$( rpmqpack )'>)}
                                            {<-->}
                                            {(DQ ($ Id.VSub_DollarName cur))}
                                          ]
                                          redirects: []
                                          do_fork: T
                                        )
                                      right: <Id.Eof_RParen _>
                                    )
                                  }
                                ]
                                right: <Id.Right_ShArrayLiteral _>
                              )
                            }
                        )
                      ]
                      redirects: []
                    )
                  ]
                  spids: [83 94]
                )
              ]
              else_kw: <Id.KW_Else else>
              else_action: [
                (command.ShAssignment
                  left: <Id.Lit_VarLike 'COMPREPLY='>
                  pairs: [
                    (AssignPair
                      left: <Id.Lit_VarLike 'COMPREPLY='>
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'COMPREPLY='> name:COMPREPLY)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (ShArrayLiteral
                            left: <Id.Op_LParen _>
                            words: [
                              {
                                (CommandSub
                                  left_token: <Id.Left_DollarParen '$('>
                                  child: 
                                    (command.Simple
                                      blame_tok: <Id.Left_DollarBrace '${'>
                                      more_env: []
                                      words: [
                                        {
                                          (BracedVarSub
                                            left: <Id.Left_DollarBrace '${'>
                                            token: <Id.VSub_Number 1>
                                            var_name: 1
                                            suffix_op: 
                                              (suffix_op.Unary
                                                op: <Id.VTest_ColonHyphen _>
                                                arg_word: {<rpm>}
                                              )
                                            right: <Id.Right_DollarBrace '}'>
                                          )
                                        }
                                        {<-qa>}
                                        {<--nodigest>}
                                        {<--nosignature>}
                                        {<--queryformat> <Id.Lit_Equals '='> (SQ <'%{NAME} '>)}
                                        {(DQ ($ Id.VSub_DollarName cur) <'*'>)}
                                      ]
                                      redirects: [
                                        (Redir
                                          op: <Id.Redir_Great '2>'>
                                          loc: (redir_loc.Fd fd:2)
                                          arg: {<'/dev/null'>}
                                        )
                                      ]
                                      do_fork: T
                                    )
                                  right: <Id.Eof_RParen _>
                                )
                              }
                            ]
                            right: <Id.Right_ShArrayLiteral _>
                          )
                        }
                    )
                  ]
                  redirects: []
                )
              ]
              fi_kw: <Id.KW_Fi fi>
              redirects: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <_rpm_groups>
      name: _rpm_groups
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              blame_tok: <local>
              more_env: []
              words: [
                {<local>}
                {<Id.Lit_VarLike 'IFS='> 
                  (SingleQuoted
                    left: <Id.Left_DollarSingleQuote '$\''>
                    tokens: [<Id.Char_OneChar '\\n'>]
                    right: <Id.Right_SingleQuote '\''>
                  )
                }
              ]
              redirects: []
              do_fork: T
            )
            (command.ShAssignment
              left: <Id.Lit_VarLike 'COMPREPLY='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'COMPREPLY='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'COMPREPLY='> name:COMPREPLY)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (ShArrayLiteral
                        left: <Id.Op_LParen _>
                        words: [
                          {
                            (CommandSub
                              left_token: <Id.Left_DollarParen '$('>
                              child: 
                                (command.Simple
                                  blame_tok: <compgen>
                                  more_env: []
                                  words: [
                                    {<compgen>}
                                    {<-W>}
                                    {
                                      (DQ 
                                        (CommandSub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.Simple
                                              blame_tok: <Id.Left_DollarBrace '${'>
                                              more_env: []
                                              words: [
                                                {
                                                  (BracedVarSub
                                                    left: <Id.Left_DollarBrace '${'>
                                                    token: <Id.VSub_Number 1>
                                                    var_name: 1
                                                    suffix_op: 
                                                      (suffix_op.Unary
                                                        op: <Id.VTest_ColonHyphen _>
                                                        arg_word: {<rpm>}
                                                      )
                                                    right: <Id.Right_DollarBrace '}'>
                                                  )
                                                }
                                                {<-qa>}
                                                {<--nodigest>}
                                                {<--nosignature>}
                                                {<--queryformat> <Id.Lit_Equals '='> 
                                                  (SQ <'%{GROUP}\\n'>)
                                                }
                                              ]
                                              redirects: [
                                                (Redir
                                                  op: <Id.Redir_Great '2>'>
                                                  loc: (redir_loc.Fd fd:2)
                                                  arg: {<'/dev/null'>}
                                                )
                                              ]
                                              do_fork: T
                                            )
                                          right: <Id.Eof_RParen _>
                                        )
                                      )
                                    }
                                    {<-->}
                                    {(DQ ($ Id.VSub_DollarName cur))}
                                  ]
                                  redirects: []
                                  do_fork: T
                                )
                              right: <Id.Eof_RParen _>
                            )
                          }
                        ]
                        right: <Id.Right_ShArrayLiteral _>
                      )
                    }
                )
              ]
              redirects: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <_rpm_macros>
      name: _rpm_macros
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ShAssignment
              left: <Id.Lit_VarLike 'COMPREPLY='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'COMPREPLY='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'COMPREPLY='> name:COMPREPLY)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (ShArrayLiteral
                        left: <Id.Op_LParen _>
                        words: [
                          {
                            (CommandSub
                              left_token: <Id.Left_DollarParen '$('>
                              child: 
                                (command.Simple
                                  blame_tok: <compgen>
                                  more_env: []
                                  words: [
                                    {<compgen>}
                                    {<-W>}
                                    {
                                      (DQ 
                                        (CommandSub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.Pipeline
                                              children: [
                                                (command.Simple
                                                  blame_tok: <Id.Left_DollarBrace '${'>
                                                  more_env: []
                                                  words: [
                                                    {
                                                      (BracedVarSub
                                                        left: <Id.Left_DollarBrace '${'>
                                                        token: <Id.VSub_Number 1>
                                                        var_name: 1
                                                        suffix_op: 
                                                          (suffix_op.Unary
                                                            op: <Id.VTest_ColonHyphen _>
                                                            arg_word: {<rpm>}
                                                          )
                                                        right: <Id.Right_DollarBrace '}'>
                                                      )
                                                    }
                                                    {<--showrc>}
                                                  ]
                                                  redirects: []
                                                  do_fork: T
                                                )
                                                (command.Simple
                                                  blame_tok: <sed>
                                                  more_env: []
                                                  words: [
                                                    {<sed>}
                                                    {<-ne>}
                                                    {
                                                      (SQ 
                                                        <
's/^-\\{0,1\\}[0-9]\\{1,\\}[:=][[:space:]]\\{1,\\}\\([^[:space:](]\\{3,\\}\\).*/%\\1/p'
                                                        >
                                                      )
                                                    }
                                                  ]
                                                  redirects: []
                                                  do_fork: T
                                                )
                                              ]
                                              ops: [<Id.Op_Pipe _>]
                                            )
                                          right: <Id.Eof_RParen _>
                                        )
                                      )
                                    }
                                    {<-->}
                                    {(DQ ($ Id.VSub_DollarName cur))}
                                  ]
                                  redirects: []
                                  do_fork: T
                                )
                              right: <Id.Eof_RParen _>
                            )
                          }
                        ]
                        right: <Id.Right_ShArrayLiteral _>
                      )
                    }
                )
              ]
              redirects: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name_tok: <_rpm_buildarchs>
      name: _rpm_buildarchs
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ShAssignment
              left: <Id.Lit_VarLike 'COMPREPLY='>
              pairs: [
                (AssignPair
                  left: <Id.Lit_VarLike 'COMPREPLY='>
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'COMPREPLY='> name:COMPREPLY)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (ShArrayLiteral
                        left: <Id.Op_LParen _>
                        words: [
                          {
                            (CommandSub
                              left_token: <Id.Left_DollarParen '$('>
                              child: 
                                (command.Simple
                                  blame_tok: <compgen>
                                  more_env: []
                                  words: [
                                    {<compgen>}
                                    {<-W>}
                                    {
                                      (DQ 
                                        (CommandSub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.Pipeline
                                              children: [
                                                (command.Simple
                                                  blame_tok: <Id.Left_DollarBrace '${'>
                                                  more_env: []
                                                  words: [
                                                    {
                                                      (BracedVarSub
                                                        left: <Id.Left_DollarBrace '${'>
                                                        token: <Id.VSub_Number 1>
                                                        var_name: 1
                                                        suffix_op: 
                                                          (suffix_op.Unary
                                                            op: <Id.VTest_ColonHyphen _>
                                                            arg_word: {<rpm>}
                                                          )
                                                        right: <Id.Right_DollarBrace '}'>
                                                      )
                                                    }
                                                    {<--showrc>}
                                                  ]
                                                  redirects: []
                                                  do_fork: T
                                                )
                                                (command.Simple
                                                  blame_tok: <sed>
                                                  more_env: []
                                                  words: [
                                                    {<sed>}
                                                    {<-ne>}
                                                    {
                                                      (SQ 
                                                        <
's/^\\s*compatible\\s\\s*build\\s\\s*archs\\s*:\\s*\\(.*\\)/\\1/ p'
                                                        >
                                                      )
                                                    }
                                                  ]
                                                  redirects: []
                                                  do_fork: T
                                                )
                                              ]
                                              ops: [<Id.Op_Pipe _>]
                                            )
                                          right: <Id.Eof_RParen _>
                                        )
                                      )
                                    }
                                    {<-->}
                                    {(DQ ($ Id.VSub_DollarName cur))}
                                  ]
                                  redirects: []
                                  do_fork: T
                                )
                              right: <Id.Eof_RParen _>
                            )
                          }
                        ]
                        right: <Id.Right_ShArrayLiteral _>
                      )
                    }
                )
              ]
              redirects: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.AndOr
      children: [
        (command.ShFunction
          name_tok: <_rpm>
          name: _rpm
          body: 
            (BraceGroup
              left: <Id.Lit_LBrace '{'>
              children: [
                (command.Simple
                  blame_tok: <local>
                  more_env: []
                  words: [{<local>} {<cur>} {<prev>} {<words>} {<cword>} {<split>}]
                  redirects: []
                  do_fork: T
                )
                (command.AndOr
                  children: [
                    (command.Simple
                      blame_tok: <_init_completion>
                      more_env: []
                      words: [{<_init_completion>} {<-s>}]
                      redirects: []
                      do_fork: T
                    )
                    (command.ControlFlow keyword:<Id.ControlFlow_Return return>)
                  ]
                  ops: [<Id.Op_DPipe _>]
                )
                (command.If
                  if_kw: <Id.KW_If if>
                  arms: [
                    (IfArm
                      keyword: <Id.KW_If if>
                      cond: 
                        (condition.Shell
                          commands: [
                            (command.Sentence
                              child: 
                                (command.DBracket
                                  left: <Id.KW_DLeftBracket '[['>
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_eq
                                      left: {($ Id.VSub_DollarName cword)}
                                      right: {<1>}
                                    )
                                  right: <Id.Lit_DRightBracket ']]'>
                                  redirects: []
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                      then_kw: <Id.KW_Then then>
                      action: [
                        (command.Case
                          case_kw: <Id.KW_Case case>
                          to_match: (case_arg.Word w:{($ Id.VSub_DollarName cur)})
                          arms_start: <Id.KW_In in>
                          arms: [
                            (CaseArm
                              left: <-->
                              pattern: (pat.Words words:[{<--> <Id.Lit_Star '*'>}])
                              middle: <Id.Right_CasePat _>
                              action: [
                                (command.ShAssignment
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  pairs: [
                                    (AssignPair
                                      left: <Id.Lit_VarLike 'COMPREPLY='>
                                      lhs: 
                                        (sh_lhs_expr.Name
                                          left: <Id.Lit_VarLike 'COMPREPLY='>
                                          name: COMPREPLY
                                        )
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (ShArrayLiteral
                                            left: <Id.Op_LParen _>
                                            words: [
                                              {
                                                (CommandSub
                                                  left_token: <Id.Left_DollarParen '$('>
                                                  child: 
                                                    (command.Simple
                                                      blame_tok: <compgen>
                                                      more_env: []
                                                      words: [
                                                        {<compgen>}
                                                        {<-W>}
                                                        {
                                                          (SQ <'--help --version --initdb\n'> 
                                                            <
'                    --checksig --addsign --delsign --rebuilddb --showrc\n'
                                                            > <'                    --setperms --setugids --eval --install --upgrade --query\n'> 
                                                            <
'                    --freshen --erase --verify --querytags --import'
                                                            >
                                                          )
                                                        }
                                                        {<-->}
                                                        {(DQ ($ Id.VSub_DollarName cur))}
                                                      ]
                                                      redirects: []
                                                      do_fork: T
                                                    )
                                                  right: <Id.Eof_RParen _>
                                                )
                                              }
                                            ]
                                            right: <Id.Right_ShArrayLiteral _>
                                          )
                                        }
                                    )
                                  ]
                                  redirects: []
                                )
                              ]
                              right: <Id.Op_DSemi _>
                            )
                            (CaseArm
                              left: <Id.Lit_Star '*'>
                              pattern: (pat.Words words:[{<Id.Lit_Star '*'>}])
                              middle: <Id.Right_CasePat _>
                              action: [
                                (command.ShAssignment
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  pairs: [
                                    (AssignPair
                                      left: <Id.Lit_VarLike 'COMPREPLY='>
                                      lhs: 
                                        (sh_lhs_expr.Name
                                          left: <Id.Lit_VarLike 'COMPREPLY='>
                                          name: COMPREPLY
                                        )
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (ShArrayLiteral
                                            left: <Id.Op_LParen _>
                                            words: [
                                              {
                                                (CommandSub
                                                  left_token: <Id.Left_DollarParen '$('>
                                                  child: 
                                                    (command.Simple
                                                      blame_tok: <compgen>
                                                      more_env: []
                                                      words: [
                                                        {<compgen>}
                                                        {<-W>}
                                                        {(SQ <'-e -E -F -i -q -t -U -V'>)}
                                                        {<-->}
                                                        {(DQ ($ Id.VSub_DollarName cur))}
                                                      ]
                                                      redirects: []
                                                      do_fork: T
                                                    )
                                                  right: <Id.Eof_RParen _>
                                                )
                                              }
                                            ]
                                            right: <Id.Right_ShArrayLiteral _>
                                          )
                                        }
                                    )
                                  ]
                                  redirects: []
                                )
                              ]
                              right: <Id.Op_DSemi _>
                            )
                          ]
                          arms_end: <Id.KW_Esac esac>
                          redirects: []
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [391 404]
                    )
                  ]
                  else_action: []
                  fi_kw: <Id.KW_Fi fi>
                  redirects: []
                )
                (command.Case
                  case_kw: <Id.KW_Case case>
                  to_match: (case_arg.Word w:{($ Id.VSub_DollarName prev)})
                  arms_start: <Id.KW_In in>
                  arms: [
                    (CaseArm
                      left: <--dbpath>
                      pattern: 
                        (pat.Words
                          words: [
                            {<--dbpath>}
                            {<--excludepath>}
                            {<--prefix>}
                            {<--relocate>}
                            {<--root>}
                            {<-r>}
                          ]
                        )
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.Simple
                          blame_tok: <_filedir>
                          more_env: []
                          words: [{<_filedir>} {<-d>}]
                          redirects: []
                          do_fork: T
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <--eval>
                      pattern: (pat.Words words:[{<--eval>} {<-E>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.Simple
                          blame_tok: <_rpm_macros>
                          more_env: []
                          words: [{<_rpm_macros>} {($ Id.VSub_Number 1)}]
                          redirects: []
                          do_fork: T
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <--pipe>
                      pattern: (pat.Words words:[{<--pipe>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.Simple
                          blame_tok: <compopt>
                          more_env: []
                          words: [{<compopt>} {<-o>} {<filenames>}]
                          redirects: []
                          do_fork: T
                        )
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'COMPREPLY='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'COMPREPLY='>
                              lhs: 
                                (sh_lhs_expr.Name
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  name: COMPREPLY
                                )
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (ShArrayLiteral
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (CommandSub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.Simple
                                              blame_tok: <compgen>
                                              more_env: []
                                              words: [
                                                {<compgen>}
                                                {<-c>}
                                                {<-->}
                                                {(DQ ($ Id.VSub_DollarName cur))}
                                              ]
                                              redirects: []
                                              do_fork: T
                                            )
                                          right: <Id.Eof_RParen _>
                                        )
                                      }
                                    ]
                                    right: <Id.Right_ShArrayLiteral _>
                                  )
                                }
                            )
                          ]
                          redirects: []
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <--rcfile>
                      pattern: (pat.Words words:[{<--rcfile>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.Simple
                          blame_tok: <_filedir>
                          more_env: []
                          words: [{<_filedir>}]
                          redirects: []
                          do_fork: T
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <--specfile>
                      pattern: (pat.Words words:[{<--specfile>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.Simple
                          blame_tok: <_filedir>
                          more_env: []
                          words: [{<_filedir>} {<spec>}]
                          redirects: []
                          do_fork: T
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <--whatenchances>
                      pattern: 
                        (pat.Words
                          words: [
                            {<--whatenchances>}
                            {<--whatprovides>}
                            {<--whatrecommends>}
                            {<--whatrequires>}
                            {<--whatsuggests>}
                            {<--whatsupplements>}
                          ]
                        )
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.If
                          if_kw: <Id.KW_If if>
                          arms: [
                            (IfArm
                              keyword: <Id.KW_If if>
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.Sentence
                                      child: 
                                        (command.DBracket
                                          left: <Id.KW_DLeftBracket '[['>
                                          expr: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobDEqual
                                              left: {(DQ ($ Id.VSub_DollarName cur))}
                                              right: {<Id.Lit_Other '*'> <'/'> <Id.Lit_Other '*'>}
                                            )
                                          right: <Id.Lit_DRightBracket ']]'>
                                          redirects: []
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                )
                              then_kw: <Id.KW_Then then>
                              action: [
                                (command.Simple
                                  blame_tok: <_filedir>
                                  more_env: []
                                  words: [{<_filedir>}]
                                  redirects: []
                                  do_fork: T
                                )
                              ]
                              spids: [644 661]
                            )
                          ]
                          else_kw: <Id.KW_Else else>
                          else_action: [
                            (command.Simple
                              blame_tok: <local>
                              more_env: []
                              words: [
                                {<local>}
                                {<Id.Lit_VarLike 'IFS='> 
                                  (SingleQuoted
                                    left: <Id.Left_DollarSingleQuote '$\''>
                                    tokens: [<Id.Char_OneChar '\\n'>]
                                    right: <Id.Right_SingleQuote '\''>
                                  )
                                }
                                {<fmt>}
                              ]
                              redirects: []
                              do_fork: T
                            )
                            (command.Case
                              case_kw: <Id.KW_Case case>
                              to_match: (case_arg.Word w:{($ Id.VSub_DollarName prev)})
                              arms_start: <Id.KW_In in>
                              arms: [
                                (CaseArm
                                  left: <Id.Lit_Star '*'>
                                  pattern: (pat.Words words:[{<Id.Lit_Star '*'> <enhances>}])
                                  middle: <Id.Right_CasePat _>
                                  action: [
                                    (command.ShAssignment
                                      left: <Id.Lit_VarLike 'fmt='>
                                      pairs: [
                                        (AssignPair
                                          left: <Id.Lit_VarLike 'fmt='>
                                          lhs: 
                                            (sh_lhs_expr.Name
                                              left: <Id.Lit_VarLike 'fmt='>
                                              name: fmt
                                            )
                                          op: assign_op.Equal
                                          rhs: {<ENHANCENAME>}
                                        )
                                      ]
                                      redirects: []
                                    )
                                  ]
                                  right: <Id.Op_DSemi _>
                                )
                                (CaseArm
                                  left: <Id.Lit_Star '*'>
                                  pattern: (pat.Words words:[{<Id.Lit_Star '*'> <provides>}])
                                  middle: <Id.Right_CasePat _>
                                  action: [
                                    (command.ShAssignment
                                      left: <Id.Lit_VarLike 'fmt='>
                                      pairs: [
                                        (AssignPair
                                          left: <Id.Lit_VarLike 'fmt='>
                                          lhs: 
                                            (sh_lhs_expr.Name
                                              left: <Id.Lit_VarLike 'fmt='>
                                              name: fmt
                                            )
                                          op: assign_op.Equal
                                          rhs: {<PROVIDENAME>}
                                        )
                                      ]
                                      redirects: []
                                    )
                                  ]
                                  right: <Id.Op_DSemi _>
                                )
                                (CaseArm
                                  left: <Id.Lit_Star '*'>
                                  pattern: (pat.Words words:[{<Id.Lit_Star '*'> <recommends>}])
                                  middle: <Id.Right_CasePat _>
                                  action: [
                                    (command.ShAssignment
                                      left: <Id.Lit_VarLike 'fmt='>
                                      pairs: [
                                        (AssignPair
                                          left: <Id.Lit_VarLike 'fmt='>
                                          lhs: 
                                            (sh_lhs_expr.Name
                                              left: <Id.Lit_VarLike 'fmt='>
                                              name: fmt
                                            )
                                          op: assign_op.Equal
                                          rhs: {<RECOMMENDNAME>}
                                        )
                                      ]
                                      redirects: []
                                    )
                                  ]
                                  right: <Id.Op_DSemi _>
                                )
                                (CaseArm
                                  left: <Id.Lit_Star '*'>
                                  pattern: (pat.Words words:[{<Id.Lit_Star '*'> <requires>}])
                                  middle: <Id.Right_CasePat _>
                                  action: [
                                    (command.ShAssignment
                                      left: <Id.Lit_VarLike 'fmt='>
                                      pairs: [
                                        (AssignPair
                                          left: <Id.Lit_VarLike 'fmt='>
                                          lhs: 
                                            (sh_lhs_expr.Name
                                              left: <Id.Lit_VarLike 'fmt='>
                                              name: fmt
                                            )
                                          op: assign_op.Equal
                                          rhs: {<REQUIRENAME>}
                                        )
                                      ]
                                      redirects: []
                                    )
                                  ]
                                  right: <Id.Op_DSemi _>
                                )
                                (CaseArm
                                  left: <Id.Lit_Star '*'>
                                  pattern: (pat.Words words:[{<Id.Lit_Star '*'> <suggests>}])
                                  middle: <Id.Right_CasePat _>
                                  action: [
                                    (command.ShAssignment
                                      left: <Id.Lit_VarLike 'fmt='>
                                      pairs: [
                                        (AssignPair
                                          left: <Id.Lit_VarLike 'fmt='>
                                          lhs: 
                                            (sh_lhs_expr.Name
                                              left: <Id.Lit_VarLike 'fmt='>
                                              name: fmt
                                            )
                                          op: assign_op.Equal
                                          rhs: {<SUGGESTNAME>}
                                        )
                                      ]
                                      redirects: []
                                    )
                                  ]
                                  right: <Id.Op_DSemi _>
                                )
                                (CaseArm
                                  left: <Id.Lit_Star '*'>
                                  pattern: (pat.Words words:[{<Id.Lit_Star '*'> <supplements>}])
                                  middle: <Id.Right_CasePat _>
                                  action: [
                                    (command.ShAssignment
                                      left: <Id.Lit_VarLike 'fmt='>
                                      pairs: [
                                        (AssignPair
                                          left: <Id.Lit_VarLike 'fmt='>
                                          lhs: 
                                            (sh_lhs_expr.Name
                                              left: <Id.Lit_VarLike 'fmt='>
                                              name: fmt
                                            )
                                          op: assign_op.Equal
                                          rhs: {<SUPPLEMENTNAME>}
                                        )
                                      ]
                                      redirects: []
                                    )
                                  ]
                                  right: <Id.Op_DSemi _>
                                )
                              ]
                              arms_end: <Id.KW_Esac esac>
                              redirects: []
                            )
                            (command.ShAssignment
                              left: <Id.Lit_VarLike 'COMPREPLY='>
                              pairs: [
                                (AssignPair
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  lhs: 
                                    (sh_lhs_expr.Name
                                      left: <Id.Lit_VarLike 'COMPREPLY='>
                                      name: COMPREPLY
                                    )
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (ShArrayLiteral
                                        left: <Id.Op_LParen _>
                                        words: [
                                          {
                                            (CommandSub
                                              left_token: <Id.Left_DollarParen '$('>
                                              child: 
                                                (command.Simple
                                                  blame_tok: <compgen>
                                                  more_env: []
                                                  words: [
                                                    {<compgen>}
                                                    {<-W>}
                                                    {
                                                      (DQ 
                                                        (CommandSub
                                                          left_token: <Id.Left_DollarParen '$('>
                                                          child: 
                                                            (command.Pipeline
                                                              children: [
                                                                (command.Simple
                                                                  blame_tok: <Id.VSub_Number '$1'>
                                                                  more_env: []
                                                                  words: [
                                                                    {($ Id.VSub_Number 1)}
                                                                    {<-qa>}
                                                                    {<--nodigest>}
                                                                    {<--nosignature>}
                                                                    {<--queryformat> 
                                                                      <Id.Lit_Equals '='> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'> ch:'"') <Id.Lit_Other '%'> 
                                                                      <Id.Lit_LBrace '{'> ($ Id.VSub_DollarName fmt) <Id.Lit_RBrace '}'> 
                                                                      (word_part.EscapedLiteral
                                                                        token: 
                                                                          <Id.Lit_EscapedChar '\\\\'>
                                                                        ch: '\\'
                                                                      ) <n> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'> ch:'"')
                                                                    }
                                                                  ]
                                                                  redirects: [
                                                                    (Redir
                                                                      op: <Id.Redir_Great '2>'>
                                                                      loc: (redir_loc.Fd fd:2)
                                                                      arg: {<'/dev/null'>}
                                                                    )
                                                                  ]
                                                                  do_fork: T
                                                                )
                                                                (command.Simple
                                                                  blame_tok: <command>
                                                                  more_env: []
                                                                  words: [
                                                                    {<command>}
                                                                    {<grep>}
                                                                    {<-vF>}
                                                                    {(SQ <'(none)'>)}
                                                                  ]
                                                                  redirects: []
                                                                  do_fork: T
                                                                )
                                                              ]
                                                              ops: [<Id.Op_Pipe _>]
                                                            )
                                                          right: <Id.Eof_RParen _>
                                                        )
                                                      )
                                                    }
                                                    {<-->}
                                                    {(DQ ($ Id.VSub_DollarName cur))}
                                                  ]
                                                  redirects: []
                                                  do_fork: T
                                                )
                                              right: <Id.Eof_RParen _>
                                            )
                                          }
                                        ]
                                        right: <Id.Right_ShArrayLiteral _>
                                      )
                                    }
                                )
                              ]
                              redirects: []
                            )
                          ]
                          fi_kw: <Id.KW_Fi fi>
                          redirects: []
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <--define>
                      pattern: 
                        (pat.Words
                          words: [{<--define>} {<-D>} {<--fileid>} {<--hdrid>} {<--pkgid>}]
                        )
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                  ]
                  arms_end: <Id.KW_Esac esac>
                  redirects: []
                )
                (command.AndOr
                  children: [
                    (command.Simple
                      blame_tok: <Id.VSub_DollarName '$split'>
                      more_env: []
                      words: [{($ Id.VSub_DollarName split)}]
                      redirects: []
                      do_fork: T
                    )
                    (command.ControlFlow
                      keyword: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  ops: [<Id.Op_DAmp _>]
                )
                (command.Simple
                  blame_tok: <local>
                  more_env: []
                  words: [
                    {<local>}
                    {<Id.Lit_VarLike 'opts='> 
                      (DQ <'--define= --eval= --macros= --nodigest --nosignature --rcfile=\n'> 
                        <'        --quiet --pipe --verbose'>
                      )
                    }
                  ]
                  redirects: []
                  do_fork: T
                )
                (command.Case
                  case_kw: <Id.KW_Case case>
                  to_match: 
                    (case_arg.Word
                      w: 
                        {
                          (BracedVarSub
                            left: <Id.Left_DollarBrace '${'>
                            token: <Id.VSub_Name words>
                            var_name: words
                            bracket_op: (bracket_op.ArrayIndex expr:{<Id.Lit_Digits 1>})
                            right: <Id.Right_DollarBrace '}'>
                          )
                        }
                    )
                  arms_start: <Id.KW_In in>
                  arms: [
                    (CaseArm
                      left: <->
                      pattern: 
                        (pat.Words
                          words: [
                            {<-> <Id.Lit_LBracket '['> <iFU> <Id.Lit_RBracket ']'> <Id.Lit_Star '*'>}
                            {<--install>}
                            {<--freshen>}
                            {<--upgrade>}
                          ]
                        )
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.If
                          if_kw: <Id.KW_If if>
                          arms: [
                            (IfArm
                              keyword: <Id.KW_If if>
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.Sentence
                                      child: 
                                        (command.DBracket
                                          left: <Id.KW_DLeftBracket '[['>
                                          expr: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobDEqual
                                              left: {(DQ ($ Id.VSub_DollarName cur))}
                                              right: {<-> <Id.Lit_Other '*'>}
                                            )
                                          right: <Id.Lit_DRightBracket ']]'>
                                          redirects: []
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                )
                              then_kw: <Id.KW_Then then>
                              action: [
                                (command.ShAssignment
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  pairs: [
                                    (AssignPair
                                      left: <Id.Lit_VarLike 'COMPREPLY='>
                                      lhs: 
                                        (sh_lhs_expr.Name
                                          left: <Id.Lit_VarLike 'COMPREPLY='>
                                          name: COMPREPLY
                                        )
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (ShArrayLiteral
                                            left: <Id.Op_LParen _>
                                            words: [
                                              {
                                                (CommandSub
                                                  left_token: <Id.Left_DollarParen '$('>
                                                  child: 
                                                    (command.Simple
                                                      blame_tok: <compgen>
                                                      more_env: []
                                                      words: [
                                                        {<compgen>}
                                                        {<-W>}
                                                        {
                                                          (DQ ($ Id.VSub_DollarName opts) 
                                                            <' --percent --force --test\n'> <'                --replacepkgs --replacefiles --root --excludedocs --includedocs\n'> 
                                                            <
'                --noscripts --ignorearch --dbpath --prefix= --ignoreos --nodeps\n'
                                                            > <'                --allfiles --ftpproxy --ftpport --justdb --httpproxy --httpport\n'> 
                                                            <
'                --noorder --relocate= --badreloc --notriggers --excludepath=\n'
                                                            > <'                --ignoresize --oldpackage --queryformat --repackage\n'> 
                                                            <'                --nosuggests'>
                                                          )
                                                        }
                                                        {<-->}
                                                        {(DQ ($ Id.VSub_DollarName cur))}
                                                      ]
                                                      redirects: []
                                                      do_fork: T
                                                    )
                                                  right: <Id.Eof_RParen _>
                                                )
                                              }
                                            ]
                                            right: <Id.Right_ShArrayLiteral _>
                                          )
                                        }
                                    )
                                  ]
                                  redirects: []
                                )
                              ]
                              spids: [906 922]
                            )
                          ]
                          else_kw: <Id.KW_Else else>
                          else_action: [
                            (command.Simple
                              blame_tok: <_filedir>
                              more_env: []
                              words: [{<_filedir>} {(SQ <'[rs]pm'>)}]
                              redirects: []
                              do_fork: T
                            )
                          ]
                          fi_kw: <Id.KW_Fi fi>
                          redirects: []
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-e>
                      pattern: (pat.Words words:[{<-e>} {<--erase>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.If
                          if_kw: <Id.KW_If if>
                          arms: [
                            (IfArm
                              keyword: <Id.KW_If if>
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.Sentence
                                      child: 
                                        (command.DBracket
                                          left: <Id.KW_DLeftBracket '[['>
                                          expr: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobDEqual
                                              left: {(DQ ($ Id.VSub_DollarName cur))}
                                              right: {<-> <Id.Lit_Other '*'>}
                                            )
                                          right: <Id.Lit_DRightBracket ']]'>
                                          redirects: []
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                )
                              then_kw: <Id.KW_Then then>
                              action: [
                                (command.ShAssignment
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  pairs: [
                                    (AssignPair
                                      left: <Id.Lit_VarLike 'COMPREPLY='>
                                      lhs: 
                                        (sh_lhs_expr.Name
                                          left: <Id.Lit_VarLike 'COMPREPLY='>
                                          name: COMPREPLY
                                        )
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (ShArrayLiteral
                                            left: <Id.Op_LParen _>
                                            words: [
                                              {
                                                (CommandSub
                                                  left_token: <Id.Left_DollarParen '$('>
                                                  child: 
                                                    (command.Simple
                                                      blame_tok: <compgen>
                                                      more_env: []
                                                      words: [
                                                        {<compgen>}
                                                        {<-W>}
                                                        {
                                                          (DQ ($ Id.VSub_DollarName opts) 
                                                            <' --allmatches --noscripts\n'> <'                    --notriggers --nodeps --test --repackage'>
                                                          )
                                                        }
                                                        {<-->}
                                                        {(DQ ($ Id.VSub_DollarName cur))}
                                                      ]
                                                      redirects: []
                                                      do_fork: T
                                                    )
                                                  right: <Id.Eof_RParen _>
                                                )
                                              }
                                            ]
                                            right: <Id.Right_ShArrayLiteral _>
                                          )
                                        }
                                    )
                                  ]
                                  redirects: []
                                )
                              ]
                              spids: [978 994]
                            )
                          ]
                          else_kw: <Id.KW_Else else>
                          else_action: [
                            (command.Simple
                              blame_tok: <_rpm_installed_packages>
                              more_env: []
                              words: [{<_rpm_installed_packages>} {($ Id.VSub_Number 1)}]
                              redirects: []
                              do_fork: T
                            )
                          ]
                          fi_kw: <Id.KW_Fi fi>
                          redirects: []
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-q>
                      pattern: (pat.Words words:[{<-q> <Id.Lit_Star '*'>} {<--query>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'opts+='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'opts+='>
                              lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'opts+='> name:opts)
                              op: assign_op.PlusEqual
                              rhs: 
                                {
                                  (DQ <' --changelog --configfiles --conflicts --docfiles --dump\n'> 
                                    <
'                --enhances --filesbypkg --filecaps --fileclass --filecolor\n'
                                    > <'                --fileprovide --filerequire --filesbypkg --info --list\n'> 
                                    <
'                --obsoletes --pipe --provides --queryformat= --requires\n'
                                    > <'                --scripts --suggests --triggers --xml --recommends\n'> 
                                    <'                --supplements'>
                                  )
                                }
                            )
                          ]
                          redirects: []
                        )
                        (command.If
                          if_kw: <Id.KW_If if>
                          arms: [
                            (IfArm
                              keyword: <Id.KW_If if>
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.Sentence
                                      child: 
                                        (command.DBracket
                                          left: <Id.KW_DLeftBracket '[['>
                                          expr: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobDEqual
                                              left: 
                                                {
                                                  (BracedVarSub
                                                    left: <Id.Left_DollarBrace '${'>
                                                    token: <Id.VSub_Name words>
                                                    var_name: words
                                                    bracket_op: 
                                                      (bracket_op.WholeArray
                                                        op_id: Id.Lit_At
                                                      )
                                                    right: <Id.Right_DollarBrace '}'>
                                                  )
                                                }
                                              right: 
                                                {<Id.Lit_Other '*'> 
                                                  (word_part.EscapedLiteral
                                                    token: <Id.Lit_EscapedChar '\\ '>
                                                    ch: ' '
                                                  ) <-> 
                                                  (word_part.ExtGlob
                                                    op: <Id.ExtGlob_At '@('>
                                                    arms: [
                                                      {
                                                        (word_part.ExtGlob
                                                          op: <Id.ExtGlob_Star '*('>
                                                          arms: [{<'[^ -]'>}]
                                                          right: <Id.Right_ExtGlob _>
                                                        ) <f>
                                                      }
                                                      {<'-file '>}
                                                    ]
                                                    right: <Id.Right_ExtGlob _>
                                                  ) <Id.Lit_Other '*'>
                                                }
                                            )
                                          right: <Id.Lit_DRightBracket ']]'>
                                          redirects: []
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                )
                              then_kw: <Id.KW_Then then>
                              action: [
                                (command.If
                                  if_kw: <Id.KW_If if>
                                  arms: [
                                    (IfArm
                                      keyword: <Id.KW_If if>
                                      cond: 
                                        (condition.Shell
                                          commands: [
                                            (command.Sentence
                                              child: 
                                                (command.DBracket
                                                  left: <Id.KW_DLeftBracket '[['>
                                                  expr: 
                                                    (bool_expr.Binary
                                                      op_id: Id.BoolBinary_GlobDEqual
                                                      left: {(DQ ($ Id.VSub_DollarName cur))}
                                                      right: {<-> <Id.Lit_Other '*'>}
                                                    )
                                                  right: <Id.Lit_DRightBracket ']]'>
                                                  redirects: []
                                                )
                                              terminator: <Id.Op_Semi _>
                                            )
                                          ]
                                        )
                                      then_kw: <Id.KW_Then then>
                                      action: [
                                        (command.ShAssignment
                                          left: <Id.Lit_VarLike 'COMPREPLY='>
                                          pairs: [
                                            (AssignPair
                                              left: <Id.Lit_VarLike 'COMPREPLY='>
                                              lhs: 
                                                (sh_lhs_expr.Name
                                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                                  name: COMPREPLY
                                                )
                                              op: assign_op.Equal
                                              rhs: 
                                                {
                                                  (ShArrayLiteral
                                                    left: <Id.Op_LParen _>
                                                    words: [
                                                      {
                                                        (CommandSub
                                                          left_token: <Id.Left_DollarParen '$('>
                                                          child: 
                                                            (command.Simple
                                                              blame_tok: <compgen>
                                                              more_env: []
                                                              words: [
                                                                {<compgen>}
                                                                {<-W>}
                                                                {
                                                                  (DQ ($ Id.VSub_DollarName opts) 
                                                                    <' --dbpath --fscontext\n'> <'                        --last --root --state'>
                                                                  )
                                                                }
                                                                {<-->}
                                                                {(DQ ($ Id.VSub_DollarName cur))}
                                                              ]
                                                              redirects: []
                                                              do_fork: T
                                                            )
                                                          right: <Id.Eof_RParen _>
                                                        )
                                                      }
                                                    ]
                                                    right: <Id.Right_ShArrayLiteral _>
                                                  )
                                                }
                                            )
                                          ]
                                          redirects: []
                                        )
                                      ]
                                      spids: [1096 1112]
                                    )
                                  ]
                                  else_kw: <Id.KW_Else else>
                                  else_action: [
                                    (command.Simple
                                      blame_tok: <_filedir>
                                      more_env: []
                                      words: [{<_filedir>}]
                                      redirects: []
                                      do_fork: T
                                    )
                                  ]
                                  fi_kw: <Id.KW_Fi fi>
                                  redirects: []
                                )
                              ]
                              spids: [1060 1089]
                            )
                            (IfArm
                              keyword: <Id.KW_Elif elif>
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.Sentence
                                      child: 
                                        (command.DBracket
                                          left: <Id.KW_DLeftBracket '[['>
                                          expr: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobDEqual
                                              left: 
                                                {
                                                  (BracedVarSub
                                                    left: <Id.Left_DollarBrace '${'>
                                                    token: <Id.VSub_Name words>
                                                    var_name: words
                                                    bracket_op: 
                                                      (bracket_op.WholeArray
                                                        op_id: Id.Lit_At
                                                      )
                                                    right: <Id.Right_DollarBrace '}'>
                                                  )
                                                }
                                              right: 
                                                {<Id.Lit_Other '*'> 
                                                  (word_part.EscapedLiteral
                                                    token: <Id.Lit_EscapedChar '\\ '>
                                                    ch: ' '
                                                  ) <-> 
                                                  (word_part.ExtGlob
                                                    op: <Id.ExtGlob_At '@('>
                                                    arms: [
                                                      {
                                                        (word_part.ExtGlob
                                                          op: <Id.ExtGlob_Star '*('>
                                                          arms: [{<'[^ -]'>}]
                                                          right: <Id.Right_ExtGlob _>
                                                        ) <g>
                                                      }
                                                      {<'-group '>}
                                                    ]
                                                    right: <Id.Right_ExtGlob _>
                                                  ) <Id.Lit_Other '*'>
                                                }
                                            )
                                          right: <Id.Lit_DRightBracket ']]'>
                                          redirects: []
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                )
                              then_kw: <Id.KW_Then then>
                              action: [
                                (command.Simple
                                  blame_tok: <_rpm_groups>
                                  more_env: []
                                  words: [{<_rpm_groups>} {($ Id.VSub_Number 1)}]
                                  redirects: []
                                  do_fork: T
                                )
                              ]
                              spids: [1150 1179]
                            )
                            (IfArm
                              keyword: <Id.KW_Elif elif>
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.Sentence
                                      child: 
                                        (command.DBracket
                                          left: <Id.KW_DLeftBracket '[['>
                                          expr: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobDEqual
                                              left: 
                                                {
                                                  (BracedVarSub
                                                    left: <Id.Left_DollarBrace '${'>
                                                    token: <Id.VSub_Name words>
                                                    var_name: words
                                                    bracket_op: 
                                                      (bracket_op.WholeArray
                                                        op_id: Id.Lit_At
                                                      )
                                                    right: <Id.Right_DollarBrace '}'>
                                                  )
                                                }
                                              right: 
                                                {<Id.Lit_Other '*'> 
                                                  (word_part.EscapedLiteral
                                                    token: <Id.Lit_EscapedChar '\\ '>
                                                    ch: ' '
                                                  ) <-> 
                                                  (word_part.ExtGlob
                                                    op: <Id.ExtGlob_At '@('>
                                                    arms: [
                                                      {
                                                        (word_part.ExtGlob
                                                          op: <Id.ExtGlob_Star '*('>
                                                          arms: [{<'[^ -]'>}]
                                                          right: <Id.Right_ExtGlob _>
                                                        ) <p>
                                                      }
                                                      {<'-package '>}
                                                    ]
                                                    right: <Id.Right_ExtGlob _>
                                                  ) <Id.Lit_Other '*'>
                                                }
                                            )
                                          right: <Id.Lit_DRightBracket ']]'>
                                          redirects: []
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                )
                              then_kw: <Id.KW_Then then>
                              action: [
                                (command.If
                                  if_kw: <Id.KW_If if>
                                  arms: [
                                    (IfArm
                                      keyword: <Id.KW_If if>
                                      cond: 
                                        (condition.Shell
                                          commands: [
                                            (command.Sentence
                                              child: 
                                                (command.DBracket
                                                  left: <Id.KW_DLeftBracket '[['>
                                                  expr: 
                                                    (bool_expr.Binary
                                                      op_id: Id.BoolBinary_GlobDEqual
                                                      left: {(DQ ($ Id.VSub_DollarName cur))}
                                                      right: {<-> <Id.Lit_Other '*'>}
                                                    )
                                                  right: <Id.Lit_DRightBracket ']]'>
                                                  redirects: []
                                                )
                                              terminator: <Id.Op_Semi _>
                                            )
                                          ]
                                        )
                                      then_kw: <Id.KW_Then then>
                                      action: [
                                        (command.ShAssignment
                                          left: <Id.Lit_VarLike 'COMPREPLY='>
                                          pairs: [
                                            (AssignPair
                                              left: <Id.Lit_VarLike 'COMPREPLY='>
                                              lhs: 
                                                (sh_lhs_expr.Name
                                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                                  name: COMPREPLY
                                                )
                                              op: assign_op.Equal
                                              rhs: 
                                                {
                                                  (ShArrayLiteral
                                                    left: <Id.Op_LParen _>
                                                    words: [
                                                      {
                                                        (CommandSub
                                                          left_token: <Id.Left_DollarParen '$('>
                                                          child: 
                                                            (command.Simple
                                                              blame_tok: <compgen>
                                                              more_env: []
                                                              words: [
                                                                {<compgen>}
                                                                {<-W>}
                                                                {
                                                                  (DQ ($ Id.VSub_DollarName opts) 
                                                                    <' --ftpport --ftpproxy\n'> <'                        --httpport --httpproxy --nomanifest'>
                                                                  )
                                                                }
                                                                {<-->}
                                                                {(DQ ($ Id.VSub_DollarName cur))}
                                                              ]
                                                              redirects: []
                                                              do_fork: T
                                                            )
                                                          right: <Id.Eof_RParen _>
                                                        )
                                                      }
                                                    ]
                                                    right: <Id.Right_ShArrayLiteral _>
                                                  )
                                                }
                                            )
                                          ]
                                          redirects: []
                                        )
                                      ]
                                      spids: [1227 1243]
                                    )
                                  ]
                                  else_kw: <Id.KW_Else else>
                                  else_action: [
                                    (command.Simple
                                      blame_tok: <_filedir>
                                      more_env: []
                                      words: [{<_filedir>} {(SQ <'[rs]pm'>)}]
                                      redirects: []
                                      do_fork: T
                                    )
                                  ]
                                  fi_kw: <Id.KW_Fi fi>
                                  redirects: []
                                )
                              ]
                              spids: [1191 1220]
                            )
                          ]
                          else_kw: <Id.KW_Else else>
                          else_action: [
                            (command.If
                              if_kw: <Id.KW_If if>
                              arms: [
                                (IfArm
                                  keyword: <Id.KW_If if>
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (command.DBracket
                                              left: <Id.KW_DLeftBracket '[['>
                                              expr: 
                                                (bool_expr.Binary
                                                  op_id: Id.BoolBinary_GlobDEqual
                                                  left: {(DQ ($ Id.VSub_DollarName cur))}
                                                  right: {<-> <Id.Lit_Other '*'>}
                                                )
                                              right: <Id.Lit_DRightBracket ']]'>
                                              redirects: []
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  then_kw: <Id.KW_Then then>
                                  action: [
                                    (command.ShAssignment
                                      left: <Id.Lit_VarLike 'COMPREPLY='>
                                      pairs: [
                                        (AssignPair
                                          left: <Id.Lit_VarLike 'COMPREPLY='>
                                          lhs: 
                                            (sh_lhs_expr.Name
                                              left: <Id.Lit_VarLike 'COMPREPLY='>
                                              name: COMPREPLY
                                            )
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (ShArrayLiteral
                                                left: <Id.Op_LParen _>
                                                words: [
                                                  {
                                                    (CommandSub
                                                      left_token: <Id.Left_DollarParen '$('>
                                                      child: 
                                                        (command.Simple
                                                          blame_tok: <compgen>
                                                          more_env: []
                                                          words: [
                                                            {<compgen>}
                                                            {<-W>}
                                                            {
                                                              (DQ ($ Id.VSub_DollarName opts) 
                                                                <' --all --file --fileid\n'> <'                        --dbpath --fscontext --ftswalk --group --hdrid --last\n'> 
                                                                <
'                        --package --pkgid --root= --specfile --state\n'
                                                                > <'                        --triggeredby --whatenhances --whatprovides\n'> 
                                                                <
'                        --whatrecommends --whatrequires --whatsuggests\n'
                                                                > <'                        --whatsupplements'>
                                                              )
                                                            }
                                                            {<-->}
                                                            {(DQ ($ Id.VSub_DollarName cur))}
                                                          ]
                                                          redirects: []
                                                          do_fork: T
                                                        )
                                                      right: <Id.Eof_RParen _>
                                                    )
                                                  }
                                                ]
                                                right: <Id.Right_ShArrayLiteral _>
                                              )
                                            }
                                        )
                                      ]
                                      redirects: []
                                    )
                                  ]
                                  spids: [1292 1308]
                                )
                                (IfArm
                                  keyword: <Id.KW_Elif elif>
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (command.DBracket
                                              left: <Id.KW_DLeftBracket '[['>
                                              expr: 
                                                (bool_expr.Binary
                                                  op_id: Id.BoolBinary_GlobNEqual
                                                  left: 
                                                    {
                                                      (BracedVarSub
                                                        left: <Id.Left_DollarBrace '${'>
                                                        token: <Id.VSub_Name words>
                                                        var_name: words
                                                        bracket_op: 
                                                          (bracket_op.WholeArray
                                                            op_id: Id.Lit_At
                                                          )
                                                        right: <Id.Right_DollarBrace '}'>
                                                      )
                                                    }
                                                  right: 
                                                    {<Id.Lit_Other '*'> 
                                                      (word_part.EscapedLiteral
                                                        token: <Id.Lit_EscapedChar '\\ '>
                                                        ch: ' '
                                                      ) <-> 
                                                      (word_part.ExtGlob
                                                        op: <Id.ExtGlob_At '@('>
                                                        arms: [
                                                          {
                                                            (word_part.ExtGlob
                                                              op: <Id.ExtGlob_Star '*('>
                                                              arms: [{<'[^ -]'>}]
                                                              right: <Id.Right_ExtGlob _>
                                                            ) <a>
                                                          }
                                                          {<'-all '>}
                                                        ]
                                                        right: <Id.Right_ExtGlob _>
                                                      ) <Id.Lit_Other '*'>
                                                    }
                                                )
                                              right: <Id.Lit_DRightBracket ']]'>
                                              redirects: []
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  then_kw: <Id.KW_Then then>
                                  action: [
                                    (command.Simple
                                      blame_tok: <_rpm_installed_packages>
                                      more_env: []
                                      words: [{<_rpm_installed_packages>} {($ Id.VSub_Number 1)}]
                                      redirects: []
                                      do_fork: T
                                    )
                                  ]
                                  spids: [1343 1372]
                                )
                              ]
                              else_action: []
                              fi_kw: <Id.KW_Fi fi>
                              redirects: []
                            )
                          ]
                          fi_kw: <Id.KW_Fi fi>
                          redirects: []
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <-K>
                      pattern: (pat.Words words:[{<-K> <Id.Lit_Star '*'>} {<--checksig>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.If
                          if_kw: <Id.KW_If if>
                          arms: [
                            (IfArm
                              keyword: <Id.KW_If if>
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.Sentence
                                      child: 
                                        (command.DBracket
                                          left: <Id.KW_DLeftBracket '[['>
                                          expr: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobDEqual
                                              left: {(DQ ($ Id.VSub_DollarName cur))}
                                              right: {<-> <Id.Lit_Other '*'>}
                                            )
                                          right: <Id.Lit_DRightBracket ']]'>
                                          redirects: []
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                )
                              then_kw: <Id.KW_Then then>
                              action: [
                                (command.ShAssignment
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  pairs: [
                                    (AssignPair
                                      left: <Id.Lit_VarLike 'COMPREPLY='>
                                      lhs: 
                                        (sh_lhs_expr.Name
                                          left: <Id.Lit_VarLike 'COMPREPLY='>
                                          name: COMPREPLY
                                        )
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (ShArrayLiteral
                                            left: <Id.Op_LParen _>
                                            words: [
                                              {
                                                (CommandSub
                                                  left_token: <Id.Left_DollarParen '$('>
                                                  child: 
                                                    (command.Simple
                                                      blame_tok: <compgen>
                                                      more_env: []
                                                      words: [
                                                        {<compgen>}
                                                        {<-W>}
                                                        {
                                                          (DQ ($ Id.VSub_DollarName opts) 
                                                            <' --nopgp --nogpg --nomd5'>
                                                          )
                                                        }
                                                        {<-->}
                                                        {(DQ ($ Id.VSub_DollarName cur))}
                                                      ]
                                                      redirects: []
                                                      do_fork: T
                                                    )
                                                  right: <Id.Eof_RParen _>
                                                )
                                              }
                                            ]
                                            right: <Id.Right_ShArrayLiteral _>
                                          )
                                        }
                                    )
                                  ]
                                  redirects: []
                                )
                              ]
                              spids: [1396 1412]
                            )
                          ]
                          else_kw: <Id.KW_Else else>
                          else_action: [
                            (command.Simple
                              blame_tok: <_filedir>
                              more_env: []
                              words: [{<_filedir>} {(SQ <'[rs]pm'>)}]
                              redirects: []
                              do_fork: T
                            )
                          ]
                          fi_kw: <Id.KW_Fi fi>
                          redirects: []
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <->
                      pattern: 
                        (pat.Words
                          words: [
                            {<-> <Id.Lit_LBracket '['> <Vy> <Id.Lit_RBracket ']'> <Id.Lit_Star '*'>}
                            {<--verify>}
                          ]
                        )
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.If
                          if_kw: <Id.KW_If if>
                          arms: [
                            (IfArm
                              keyword: <Id.KW_If if>
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.Sentence
                                      child: 
                                        (command.DBracket
                                          left: <Id.KW_DLeftBracket '[['>
                                          expr: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobDEqual
                                              left: {(DQ ($ Id.VSub_DollarName cur))}
                                              right: {<-> <Id.Lit_Other '*'>}
                                            )
                                          right: <Id.Lit_DRightBracket ']]'>
                                          redirects: []
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                )
                              then_kw: <Id.KW_Then then>
                              action: [
                                (command.ShAssignment
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  pairs: [
                                    (AssignPair
                                      left: <Id.Lit_VarLike 'COMPREPLY='>
                                      lhs: 
                                        (sh_lhs_expr.Name
                                          left: <Id.Lit_VarLike 'COMPREPLY='>
                                          name: COMPREPLY
                                        )
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (ShArrayLiteral
                                            left: <Id.Op_LParen _>
                                            words: [
                                              {
                                                (CommandSub
                                                  left_token: <Id.Left_DollarParen '$('>
                                                  child: 
                                                    (command.Simple
                                                      blame_tok: <compgen>
                                                      more_env: []
                                                      words: [
                                                        {<compgen>}
                                                        {<-W>}
                                                        {
                                                          (DQ ($ Id.VSub_DollarName opts) 
                                                            <' --root= --dbpath --nodeps\n'> <'                    --nogroup --nolinkto --nomode --nomtime --nordev --nouser\n'> 
                                                            <
'                    --nofiles --noscripts --nomd5 --querytags --specfile\n'
                                                            > <'                    --whatenhances --whatprovides --whatrecommends\n'> 
                                                            <
'                    --whatrequires --whatsuggests --whatsupplements'
                                                            >
                                                          )
                                                        }
                                                        {<-->}
                                                        {(DQ ($ Id.VSub_DollarName cur))}
                                                      ]
                                                      redirects: []
                                                      do_fork: T
                                                    )
                                                  right: <Id.Eof_RParen _>
                                                )
                                              }
                                            ]
                                            right: <Id.Right_ShArrayLiteral _>
                                          )
                                        }
                                    )
                                  ]
                                  redirects: []
                                )
                              ]
                              spids: [1468 1484]
                            )
                            (IfArm
                              keyword: <Id.KW_Elif elif>
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.Sentence
                                      child: 
                                        (command.DBracket
                                          left: <Id.KW_DLeftBracket '[['>
                                          expr: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobDEqual
                                              left: 
                                                {
                                                  (BracedVarSub
                                                    left: <Id.Left_DollarBrace '${'>
                                                    token: <Id.VSub_Name words>
                                                    var_name: words
                                                    bracket_op: 
                                                      (bracket_op.WholeArray
                                                        op_id: Id.Lit_At
                                                      )
                                                    right: <Id.Right_DollarBrace '}'>
                                                  )
                                                }
                                              right: 
                                                {<Id.Lit_Other '*'> 
                                                  (word_part.EscapedLiteral
                                                    token: <Id.Lit_EscapedChar '\\ '>
                                                    ch: ' '
                                                  ) <-> 
                                                  (word_part.ExtGlob
                                                    op: <Id.ExtGlob_At '@('>
                                                    arms: [
                                                      {
                                                        (word_part.ExtGlob
                                                          op: <Id.ExtGlob_Star '*('>
                                                          arms: [{<'[^ -]'>}]
                                                          right: <Id.Right_ExtGlob _>
                                                        ) <f>
                                                      }
                                                      {<'-file '>}
                                                    ]
                                                    right: <Id.Right_ExtGlob _>
                                                  ) <Id.Lit_Other '*'>
                                                }
                                            )
                                          right: <Id.Lit_DRightBracket ']]'>
                                          redirects: []
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                )
                              then_kw: <Id.KW_Then then>
                              action: [
                                (command.Simple
                                  blame_tok: <_filedir>
                                  more_env: []
                                  words: [{<_filedir>}]
                                  redirects: []
                                  do_fork: T
                                )
                              ]
                              spids: [1522 1551]
                            )
                            (IfArm
                              keyword: <Id.KW_Elif elif>
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.Sentence
                                      child: 
                                        (command.DBracket
                                          left: <Id.KW_DLeftBracket '[['>
                                          expr: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobDEqual
                                              left: 
                                                {
                                                  (BracedVarSub
                                                    left: <Id.Left_DollarBrace '${'>
                                                    token: <Id.VSub_Name words>
                                                    var_name: words
                                                    bracket_op: 
                                                      (bracket_op.WholeArray
                                                        op_id: Id.Lit_At
                                                      )
                                                    right: <Id.Right_DollarBrace '}'>
                                                  )
                                                }
                                              right: 
                                                {<Id.Lit_Other '*'> 
                                                  (word_part.EscapedLiteral
                                                    token: <Id.Lit_EscapedChar '\\ '>
                                                    ch: ' '
                                                  ) <-> 
                                                  (word_part.ExtGlob
                                                    op: <Id.ExtGlob_At '@('>
                                                    arms: [
                                                      {
                                                        (word_part.ExtGlob
                                                          op: <Id.ExtGlob_Star '*('>
                                                          arms: [{<'[^ -]'>}]
                                                          right: <Id.Right_ExtGlob _>
                                                        ) <g>
                                                      }
                                                      {<'-group '>}
                                                    ]
                                                    right: <Id.Right_ExtGlob _>
                                                  ) <Id.Lit_Other '*'>
                                                }
                                            )
                                          right: <Id.Lit_DRightBracket ']]'>
                                          redirects: []
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                )
                              then_kw: <Id.KW_Then then>
                              action: [
                                (command.Simple
                                  blame_tok: <_rpm_groups>
                                  more_env: []
                                  words: [{<_rpm_groups>} {($ Id.VSub_Number 1)}]
                                  redirects: []
                                  do_fork: T
                                )
                              ]
                              spids: [1557 1586]
                            )
                            (IfArm
                              keyword: <Id.KW_Elif elif>
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.Sentence
                                      child: 
                                        (command.DBracket
                                          left: <Id.KW_DLeftBracket '[['>
                                          expr: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobDEqual
                                              left: 
                                                {
                                                  (BracedVarSub
                                                    left: <Id.Left_DollarBrace '${'>
                                                    token: <Id.VSub_Name words>
                                                    var_name: words
                                                    bracket_op: 
                                                      (bracket_op.WholeArray
                                                        op_id: Id.Lit_At
                                                      )
                                                    right: <Id.Right_DollarBrace '}'>
                                                  )
                                                }
                                              right: 
                                                {<Id.Lit_Other '*'> 
                                                  (word_part.EscapedLiteral
                                                    token: <Id.Lit_EscapedChar '\\ '>
                                                    ch: ' '
                                                  ) <-> 
                                                  (word_part.ExtGlob
                                                    op: <Id.ExtGlob_At '@('>
                                                    arms: [
                                                      {
                                                        (word_part.ExtGlob
                                                          op: <Id.ExtGlob_Star '*('>
                                                          arms: [{<'[^ -]'>}]
                                                          right: <Id.Right_ExtGlob _>
                                                        ) <p>
                                                      }
                                                      {<'-package '>}
                                                    ]
                                                    right: <Id.Right_ExtGlob _>
                                                  ) <Id.Lit_Other '*'>
                                                }
                                            )
                                          right: <Id.Lit_DRightBracket ']]'>
                                          redirects: []
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                )
                              then_kw: <Id.KW_Then then>
                              action: [
                                (command.Simple
                                  blame_tok: <_filedir>
                                  more_env: []
                                  words: [{<_filedir>} {(SQ <'[rs]pm'>)}]
                                  redirects: []
                                  do_fork: T
                                )
                              ]
                              spids: [1594 1623]
                            )
                          ]
                          else_kw: <Id.KW_Else else>
                          else_action: [
                            (command.Simple
                              blame_tok: <_rpm_installed_packages>
                              more_env: []
                              words: [{<_rpm_installed_packages>} {($ Id.VSub_Number 1)}]
                              redirects: []
                              do_fork: T
                            )
                          ]
                          fi_kw: <Id.KW_Fi fi>
                          redirects: []
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <--resign>
                      pattern: (pat.Words words:[{<--resign>} {<--addsign>} {<--delsign>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.Simple
                          blame_tok: <_filedir>
                          more_env: []
                          words: [{<_filedir>} {(SQ <'[rs]pm'>)}]
                          redirects: []
                          do_fork: T
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <--setperms>
                      pattern: (pat.Words words:[{<--setperms>} {<--setgids>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.Simple
                          blame_tok: <_rpm_installed_packages>
                          more_env: []
                          words: [{<_rpm_installed_packages>} {($ Id.VSub_Number 1)}]
                          redirects: []
                          do_fork: T
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <--import>
                      pattern: (pat.Words words:[{<--import>} {<--dbpath>} {<--root>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.If
                          if_kw: <Id.KW_If if>
                          arms: [
                            (IfArm
                              keyword: <Id.KW_If if>
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.Sentence
                                      child: 
                                        (command.DBracket
                                          left: <Id.KW_DLeftBracket '[['>
                                          expr: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobDEqual
                                              left: {(DQ ($ Id.VSub_DollarName cur))}
                                              right: {<-> <Id.Lit_Other '*'>}
                                            )
                                          right: <Id.Lit_DRightBracket ']]'>
                                          redirects: []
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                )
                              then_kw: <Id.KW_Then then>
                              action: [
                                (command.ShAssignment
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  pairs: [
                                    (AssignPair
                                      left: <Id.Lit_VarLike 'COMPREPLY='>
                                      lhs: 
                                        (sh_lhs_expr.Name
                                          left: <Id.Lit_VarLike 'COMPREPLY='>
                                          name: COMPREPLY
                                        )
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (ShArrayLiteral
                                            left: <Id.Op_LParen _>
                                            words: [
                                              {
                                                (CommandSub
                                                  left_token: <Id.Left_DollarParen '$('>
                                                  child: 
                                                    (command.Simple
                                                      blame_tok: <compgen>
                                                      more_env: []
                                                      words: [
                                                        {<compgen>}
                                                        {<-W>}
                                                        {(SQ <'--import --dbpath --root='>)}
                                                        {<-->}
                                                        {(DQ ($ Id.VSub_DollarName cur))}
                                                      ]
                                                      redirects: []
                                                      do_fork: T
                                                    )
                                                  right: <Id.Eof_RParen _>
                                                )
                                              }
                                            ]
                                            right: <Id.Right_ShArrayLiteral _>
                                          )
                                        }
                                    )
                                  ]
                                  redirects: []
                                )
                              ]
                              spids: [1687 1703]
                            )
                          ]
                          else_kw: <Id.KW_Else else>
                          else_action: [
                            (command.Simple
                              blame_tok: <_filedir>
                              more_env: []
                              words: [{<_filedir>}]
                              redirects: []
                              do_fork: T
                            )
                          ]
                          fi_kw: <Id.KW_Fi fi>
                          redirects: []
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                  ]
                  arms_end: <Id.KW_Esac esac>
                  redirects: []
                )
                (command.AndOr
                  children: [
                    (command.DBracket
                      left: <Id.KW_DLeftBracket '[['>
                      expr: 
                        (bool_expr.Binary
                          op_id: Id.BoolBinary_GlobDEqual
                          left: {($ Id.VSub_DollarName COMPREPLY)}
                          right: {<Id.Lit_Other '*'> <Id.BoolBinary_GlobEqual '='>}
                        )
                      right: <Id.Lit_DRightBracket ']]'>
                      redirects: []
                    )
                    (command.Simple
                      blame_tok: <compopt>
                      more_env: []
                      words: [{<compopt>} {<-o>} {<nospace>}]
                      redirects: []
                      do_fork: T
                    )
                  ]
                  ops: [<Id.Op_DAmp _>]
                )
                (command.ControlFlow
                  keyword: <Id.ControlFlow_Return return>
                  arg_word: {<0>}
                )
              ]
              redirects: []
              right: <Id.Lit_RBrace '}'>
            )
        )
        (command.Simple
          blame_tok: <complete>
          more_env: []
          words: [{<complete>} {<-F>} {<_rpm>} {<rpm>}]
          redirects: []
          do_fork: T
        )
      ]
      ops: [<Id.Op_DAmp _>]
    )
    (command.AndOr
      children: [
        (command.ShFunction
          name_tok: <_rpmbuild>
          name: _rpmbuild
          body: 
            (BraceGroup
              left: <Id.Lit_LBrace '{'>
              children: [
                (command.Simple
                  blame_tok: <local>
                  more_env: []
                  words: [{<local>} {<cur>} {<prev>} {<words>} {<cword>} {<split>}]
                  redirects: []
                  do_fork: T
                )
                (command.AndOr
                  children: [
                    (command.Simple
                      blame_tok: <_init_completion>
                      more_env: []
                      words: [{<_init_completion>} {<-s>}]
                      redirects: []
                      do_fork: T
                    )
                    (command.ControlFlow keyword:<Id.ControlFlow_Return return>)
                  ]
                  ops: [<Id.Op_DPipe _>]
                )
                (command.Simple
                  blame_tok: <local>
                  more_env: []
                  words: [
                    {<local>}
                    {<Id.Lit_VarLike 'rpm='> 
                      (DQ 
                        (BracedVarSub
                          left: <Id.Left_DollarBrace '${'>
                          token: <Id.VSub_Number 1>
                          var_name: 1
                          suffix_op: 
                            (suffix_op.Unary
                              op: <Id.VOp1_Percent '%'>
                              arg_word: {<build> <Id.Lit_Other '*'>}
                            )
                          right: <Id.Right_DollarBrace '}'>
                        )
                      )
                    }
                  ]
                  redirects: []
                  do_fork: T
                )
                (command.AndOr
                  children: [
                    (command.DBracket
                      left: <Id.KW_DLeftBracket '[['>
                      expr: 
                        (bool_expr.Binary
                          op_id: Id.BoolBinary_GlobDEqual
                          left: {($ Id.VSub_DollarName rpm)}
                          right: {($ Id.VSub_Number 1)}
                        )
                      right: <Id.Lit_DRightBracket ']]'>
                      redirects: []
                    )
                    (command.Pipeline
                      negated: <Id.KW_Bang '!'>
                      children: [
                        (command.Simple
                          blame_tok: <type>
                          more_env: []
                          words: [{<type>} {($ Id.VSub_DollarName rpm)}]
                          redirects: [
                            (Redir
                              op: <Id.Redir_AndGreat '&>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<'/dev/null'>}
                            )
                          ]
                          do_fork: T
                        )
                      ]
                      ops: []
                    )
                    (command.ShAssignment
                      left: <Id.Lit_VarLike 'rpm='>
                      pairs: [
                        (AssignPair
                          left: <Id.Lit_VarLike 'rpm='>
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'rpm='> name:rpm)
                          op: assign_op.Equal
                          rhs: (rhs_word__Empty)
                        )
                      ]
                      redirects: []
                    )
                  ]
                  ops: [<Id.Op_DPipe _> <Id.Op_DAmp _>]
                )
                (command.Case
                  case_kw: <Id.KW_Case case>
                  to_match: (case_arg.Word w:{($ Id.VSub_DollarName prev)})
                  arms_start: <Id.KW_In in>
                  arms: [
                    (CaseArm
                      left: <--buildroot>
                      pattern: (pat.Words words:[{<--buildroot>} {<--root>} {<-r>} {<--dbpath>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.Simple
                          blame_tok: <_filedir>
                          more_env: []
                          words: [{<_filedir>} {<-d>}]
                          redirects: []
                          do_fork: T
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <--target>
                      pattern: (pat.Words words:[{<--target>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.Simple
                          blame_tok: <_rpm_buildarchs>
                          more_env: []
                          words: [{<_rpm_buildarchs>}]
                          redirects: []
                          do_fork: T
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <--eval>
                      pattern: (pat.Words words:[{<--eval>} {<-E>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.Simple
                          blame_tok: <_rpm_macros>
                          more_env: []
                          words: [{<_rpm_macros>} {($ Id.VSub_DollarName rpm)}]
                          redirects: []
                          do_fork: T
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <--macros>
                      pattern: (pat.Words words:[{<--macros>} {<--rcfile>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.Simple
                          blame_tok: <_filedir>
                          more_env: []
                          words: [{<_filedir>}]
                          redirects: []
                          do_fork: T
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <--buildpolicy>
                      pattern: (pat.Words words:[{<--buildpolicy>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.Simple
                          blame_tok: <local>
                          more_env: []
                          words: [
                            {<local>}
                            {<Id.Lit_VarLike 'cfgdir='> 
                              (CommandSub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (command.Simple
                                    blame_tok: <Id.VSub_DollarName '$rpm'>
                                    more_env: []
                                    words: [
                                      {($ Id.VSub_DollarName rpm)}
                                      {<--eval>}
                                      {(SQ <'%{_rpmconfigdir}'>)}
                                    ]
                                    redirects: [
                                      (Redir
                                        op: <Id.Redir_Great '2>'>
                                        loc: (redir_loc.Fd fd:2)
                                        arg: {<'/dev/null'>}
                                      )
                                    ]
                                    do_fork: T
                                  )
                                right: <Id.Eof_RParen _>
                              )
                            }
                          ]
                          redirects: []
                          do_fork: T
                        )
                        (command.If
                          if_kw: <Id.KW_If if>
                          arms: [
                            (IfArm
                              keyword: <Id.KW_If if>
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.Sentence
                                      child: 
                                        (command.DBracket
                                          left: <Id.KW_DLeftBracket '[['>
                                          expr: (bool_expr.WordTest w:{($ Id.VSub_DollarName cfgdir)})
                                          right: <Id.Lit_DRightBracket ']]'>
                                          redirects: []
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                )
                              then_kw: <Id.KW_Then then>
                              action: [
                                (command.ShAssignment
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  pairs: [
                                    (AssignPair
                                      left: <Id.Lit_VarLike 'COMPREPLY='>
                                      lhs: 
                                        (sh_lhs_expr.Name
                                          left: <Id.Lit_VarLike 'COMPREPLY='>
                                          name: COMPREPLY
                                        )
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (ShArrayLiteral
                                            left: <Id.Op_LParen _>
                                            words: [
                                              {
                                                (CommandSub
                                                  left_token: <Id.Left_DollarParen '$('>
                                                  child: 
                                                    (command.Simple
                                                      blame_tok: <compgen>
                                                      more_env: []
                                                      words: [
                                                        {<compgen>}
                                                        {<-W>}
                                                        {
                                                          (DQ 
                                                            (CommandSub
                                                              left_token: <Id.Left_DollarParen '$('>
                                                              child: 
                                                                (command.Pipeline
                                                                  children: [
                                                                    (command.Simple
                                                                      blame_tok: <command>
                                                                      more_env: []
                                                                      words: [
                                                                        {<command>}
                                                                        {<ls>}
                                                                        {
                                                                          ($ Id.VSub_DollarName 
cfgdir
                                                                          )
                                                                        }
                                                                      ]
                                                                      redirects: [
                                                                        (Redir
                                                                          op: <Id.Redir_Great '2>'>
                                                                          loc: (redir_loc.Fd fd:2)
                                                                          arg: {<'/dev/null'>}
                                                                        )
                                                                      ]
                                                                      do_fork: T
                                                                    )
                                                                    (command.Simple
                                                                      blame_tok: <sed>
                                                                      more_env: []
                                                                      words: [
                                                                        {<sed>}
                                                                        {<-ne>}
                                                                        {(SQ <'s/^brp-//p'>)}
                                                                      ]
                                                                      redirects: []
                                                                      do_fork: T
                                                                    )
                                                                  ]
                                                                  ops: [<Id.Op_Pipe _>]
                                                                )
                                                              right: <Id.Eof_RParen _>
                                                            )
                                                          )
                                                        }
                                                        {<-->}
                                                        {(DQ ($ Id.VSub_DollarName cur))}
                                                      ]
                                                      redirects: []
                                                      do_fork: T
                                                    )
                                                  right: <Id.Eof_RParen _>
                                                )
                                              }
                                            ]
                                            right: <Id.Right_ShArrayLiteral _>
                                          )
                                        }
                                    )
                                  ]
                                  redirects: []
                                )
                              ]
                              spids: [1959 1968]
                            )
                          ]
                          else_action: []
                          fi_kw: <Id.KW_Fi fi>
                          redirects: []
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                    (CaseArm
                      left: <--define>
                      pattern: (pat.Words words:[{<--define>} {<-D>} {<--with>} {<--without>}])
                      middle: <Id.Right_CasePat _>
                      action: [
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      right: <Id.Op_DSemi _>
                    )
                  ]
                  arms_end: <Id.KW_Esac esac>
                  redirects: []
                )
                (command.AndOr
                  children: [
                    (command.Simple
                      blame_tok: <Id.VSub_DollarName '$split'>
                      more_env: []
                      words: [{($ Id.VSub_DollarName split)}]
                      redirects: []
                      do_fork: T
                    )
                    (command.ControlFlow
                      keyword: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  ops: [<Id.Op_DAmp _>]
                )
                (command.If
                  if_kw: <Id.KW_If if>
                  arms: [
                    (IfArm
                      keyword: <Id.KW_If if>
                      cond: 
                        (condition.Shell
                          commands: [
                            (command.Sentence
                              child: 
                                (command.DBracket
                                  left: <Id.KW_DLeftBracket '[['>
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_GlobDEqual
                                      left: {($ Id.VSub_DollarName cur)}
                                      right: {<-> <Id.Lit_Other '*'>}
                                    )
                                  right: <Id.Lit_DRightBracket ']]'>
                                  redirects: []
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                      then_kw: <Id.KW_Then then>
                      action: [
                        (command.ShAssignment
                          left: <Id.Lit_VarLike 'COMPREPLY='>
                          pairs: [
                            (AssignPair
                              left: <Id.Lit_VarLike 'COMPREPLY='>
                              lhs: 
                                (sh_lhs_expr.Name
                                  left: <Id.Lit_VarLike 'COMPREPLY='>
                                  name: COMPREPLY
                                )
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (ShArrayLiteral
                                    left: <Id.Op_LParen _>
                                    words: [
                                      {
                                        (CommandSub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.Simple
                                              blame_tok: <compgen>
                                              more_env: []
                                              words: [
                                                {<compgen>}
                                                {<-W>}
                                                {
                                                  (DQ 
                                                    (CommandSub
                                                      left_token: <Id.Left_DollarParen '$('>
                                                      child: 
                                                        (command.Simple
                                                          blame_tok: <_parse_help>
                                                          more_env: []
                                                          words: [
                                                            {<_parse_help>}
                                                            {(DQ ($ Id.VSub_Number 1))}
                                                          ]
                                                          redirects: []
                                                          do_fork: T
                                                        )
                                                      right: <Id.Eof_RParen _>
                                                    )
                                                  )
                                                }
                                                {<-->}
                                                {(DQ ($ Id.VSub_DollarName cur))}
                                              ]
                                              redirects: []
                                              do_fork: T
                                            )
                                          right: <Id.Eof_RParen _>
                                        )
                                      }
                                    ]
                                    right: <Id.Right_ShArrayLiteral _>
                                  )
                                }
                            )
                          ]
                          redirects: []
                        )
                        (command.AndOr
                          children: [
                            (command.DBracket
                              left: <Id.KW_DLeftBracket '[['>
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: {($ Id.VSub_DollarName COMPREPLY)}
                                  right: {<Id.Lit_Other '*'> <Id.BoolBinary_GlobEqual '='>}
                                )
                              right: <Id.Lit_DRightBracket ']]'>
                              redirects: []
                            )
                            (command.Simple
                              blame_tok: <compopt>
                              more_env: []
                              words: [{<compopt>} {<-o>} {<nospace>}]
                              redirects: []
                              do_fork: T
                            )
                          ]
                          ops: [<Id.Op_DAmp _>]
                        )
                        (command.ControlFlow
                          keyword: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                      spids: [2056 2070]
                    )
                  ]
                  else_action: []
                  fi_kw: <Id.KW_Fi fi>
                  redirects: []
                )
                (command.Simple
                  blame_tok: <local>
                  more_env: []
                  words: [{<local>} {<word>} {<ext>}]
                  redirects: []
                  do_fork: T
                )
                (command.ForEach
                  keyword: <Id.KW_For for>
                  iter_names: [word]
                  iterable: 
                    (for_iter.Words
                      words: [
                        {
                          (BracedVarSub
                            left: <Id.Left_DollarBrace '${'>
                            token: <Id.VSub_Name words>
                            var_name: words
                            bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                            right: <Id.Right_DollarBrace '}'>
                          )
                        }
                      ]
                    )
                  semi_tok: <Id.Op_Semi _>
                  body: 
                    (command.DoGroup
                      left: <Id.KW_Do do>
                      children: [
                        (command.Case
                          case_kw: <Id.KW_Case case>
                          to_match: (case_arg.Word w:{($ Id.VSub_DollarName word)})
                          arms_start: <Id.KW_In in>
                          arms: [
                            (CaseArm
                              left: <-b>
                              pattern: 
                                (pat.Words
                                  words: [{<-b> <Id.Lit_QMark '?'>} {<--clean>} {<--nobuild>}]
                                )
                              middle: <Id.Right_CasePat _>
                              action: [
                                (command.ShAssignment
                                  left: <Id.Lit_VarLike 'ext='>
                                  pairs: [
                                    (AssignPair
                                      left: <Id.Lit_VarLike 'ext='>
                                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'ext='> name:ext)
                                      op: assign_op.Equal
                                      rhs: {<spec>}
                                    )
                                  ]
                                  redirects: []
                                )
                                (command.ControlFlow
                                  keyword: <Id.ControlFlow_Break break>
                                )
                              ]
                              right: <Id.Op_DSemi _>
                            )
                            (CaseArm
                              left: <-t>
                              pattern: (pat.Words words:[{<-t> <Id.Lit_QMark '?'>} {<--tarbuild>}])
                              middle: <Id.Right_CasePat _>
                              action: [
                                (command.ShAssignment
                                  left: <Id.Lit_VarLike 'ext='>
                                  pairs: [
                                    (AssignPair
                                      left: <Id.Lit_VarLike 'ext='>
                                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'ext='> name:ext)
                                      op: assign_op.Equal
                                      rhs: {(SQ <'@(t?(ar.)@([gx]z|bz?(2))|tar?(.@(lzma|Z)))'>)}
                                    )
                                  ]
                                  redirects: []
                                )
                                (command.ControlFlow
                                  keyword: <Id.ControlFlow_Break break>
                                )
                              ]
                              right: <Id.Op_DSemi _>
                            )
                            (CaseArm
                              left: <--rebuild>
                              pattern: (pat.Words words:[{<--rebuild>} {<--recompile>}])
                              middle: <Id.Right_CasePat _>
                              action: [
                                (command.ShAssignment
                                  left: <Id.Lit_VarLike 'ext='>
                                  pairs: [
                                    (AssignPair
                                      left: <Id.Lit_VarLike 'ext='>
                                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'ext='> name:ext)
                                      op: assign_op.Equal
                                      rhs: {(SQ <'@(?(no)src.r|s)pm'>)}
                                    )
                                  ]
                                  redirects: []
                                )
                                (command.ControlFlow
                                  keyword: <Id.ControlFlow_Break break>
                                )
                              ]
                              right: <Id.Op_DSemi _>
                            )
                          ]
                          arms_end: <Id.KW_Esac esac>
                          redirects: []
                        )
                      ]
                      right: <Id.KW_Done done>
                    )
                  redirects: []
                )
                (command.AndOr
                  children: [
                    (command.DBracket
                      left: <Id.KW_DLeftBracket '[['>
                      expr: (bool_expr.Unary op_id:Id.BoolUnary_n child:{($ Id.VSub_DollarName ext)})
                      right: <Id.Lit_DRightBracket ']]'>
                      redirects: []
                    )
                    (command.Simple
                      blame_tok: <_filedir>
                      more_env: []
                      words: [{<_filedir>} {($ Id.VSub_DollarName ext)}]
                      redirects: []
                      do_fork: T
                    )
                  ]
                  ops: [<Id.Op_DAmp _>]
                )
              ]
              redirects: []
              right: <Id.Lit_RBrace '}'>
            )
        )
        (command.Simple
          blame_tok: <complete>
          more_env: []
          words: [{<complete>} {<-F>} {<_rpmbuild>} {<rpmbuild>} {<rpmbuild-md5>}]
          redirects: []
          do_fork: T
        )
      ]
      ops: [<Id.Op_DAmp _>]
    )
  ]
)