(command.CommandList
  children: [
    (command.AndOr
      ops: [Op_DPipe]
      children: [
        (C {(source)} {(DQ (${ VSub_Name PORTAGE_BIN_PATH) (/eapi.sh))})
        (command.ControlFlow token:<ControlFlow_Exit exit> arg_word:{(1)})
      ]
    )
    (C {(shopt)} {(-s)} {(expand_aliases)})
    (C {(alias)} {(Lit_VarLike 'save_IFS=') (SQ <'[ "${IFS:-unset}" != "unset" ] && old_IFS="${IFS}"'>)})
    (C {(alias)} 
      {(Lit_VarLike 'restore_IFS=') 
        (SQ 
          <
'if [ "${old_IFS:-unset}" != "unset" ]; then IFS="${old_IFS}"; unset old_IFS; else unset IFS; fi'
          >
        )
      }
    )
    (command.ShFunction
      name: assert
      body: 
        (command.BraceGroup
          children: [
            (C {(local)} {(x)} 
              {(Lit_VarLike 'pipestatus=') 
                (braced_var_sub
                  token: <VSub_Name PIPESTATUS>
                  bracket_op: (bracket_op.WholeArray op_id:Arith_Star)
                )
              }
            )
            (command.ForEach
              iter_name: x
              iter_words: [{($ VSub_DollarName '$pipestatus')}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: BoolBinary_eq
                              left: {($ VSub_DollarName '$x')}
                              right: {(0)}
                            )
                        )
                        (C {(die)} {(DQ ($ VSub_At '$@'))})
                      ]
                    )
                  ]
                )
            )
          ]
        )
    )
    (command.ShFunction
      name: __assert_sigpipe_ok
      body: 
        (command.BraceGroup
          children: [
            (C {(local)} {(x)} 
              {(Lit_VarLike 'pipestatus=') 
                (braced_var_sub
                  token: <VSub_Name PIPESTATUS>
                  bracket_op: (bracket_op.WholeArray op_id:Arith_Star)
                )
              }
            )
            (command.ForEach
              iter_name: x
              iter_words: [{($ VSub_DollarName '$pipestatus')}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.DBracket
                              expr: 
                                (bool_expr.LogicalAnd
                                  left: 
                                    (bool_expr.Binary
                                      op_id: BoolBinary_ne
                                      left: {($ VSub_DollarName '$x')}
                                      right: {(0)}
                                    )
                                  right: 
                                    (bool_expr.Binary
                                      op_id: BoolBinary_ne
                                      left: {($ VSub_DollarName '$x')}
                                      right: 
                                        {
                                          (braced_var_sub
                                            token: <VSub_Name PORTAGE_SIGPIPE_STATUS>
                                            suffix_op: 
                                              (suffix_op.Unary
                                                op_id: VTest_ColonHyphen
                                                arg_word: {(141)}
                                              )
                                          )
                                        }
                                    )
                                )
                            )
                          ]
                          action: [
                            (C {(__helpers_die)} {(DQ ($ VSub_At '$@'))})
                            (command.ControlFlow
                              token: <ControlFlow_Return return>
                              arg_word: {(1)}
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: BoolBinary_ne
                              left: {($ VSub_DollarName '$x')}
                              right: {(0)}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(__helpers_die)} {(DQ ($ VSub_At '$@'))})
                    (command.ControlFlow
                      token: <ControlFlow_Return return>
                      arg_word: {(1)}
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (C {(shopt)} {(-s)} {(extdebug)})
    (command.ShFunction
      name: __dump_trace
      body: 
        (command.BraceGroup
          children: [
            (C {(local)} {(Lit_VarLike 'funcname=') (DQ )} {(Lit_VarLike 'sourcefile=') (DQ )} 
              {(Lit_VarLike 'lineno=') (DQ )} {(Lit_VarLike 's=') (DQ (yes))} {(n)} {(p)}
            )
            (C {(declare)} {(-i)} 
              {(Lit_VarLike 'strip=') 
                (braced_var_sub
                  token: <VSub_Number 1>
                  suffix_op: (suffix_op.Unary op_id:VTest_ColonHyphen arg_word:{(1)})
                )
              }
            )
            (C {(local)} {(Lit_VarLike 'filespacing=') ($ VSub_Number '$2')} 
              {(Lit_VarLike 'linespacing=') ($ VSub_Number '$3')}
            )
            (command.DParen
              child: 
                (arith_expr.BinaryAssign
                  op_id: Arith_Equal
                  left: (sh_lhs_expr.Name name:n)
                  right: 
                    (arith_expr.Binary
                      op_id: Arith_Minus
                      left: 
                        (arith_expr.ArithWord
                          w: 
                            {
                              (braced_var_sub
                                token: <VSub_Name FUNCNAME>
                                prefix_op: VSub_Pound
                                bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                              )
                            }
                        )
                      right: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                    )
                )
            )
            (command.DParen
              child: 
                (arith_expr.BinaryAssign
                  op_id: Arith_Equal
                  left: (sh_lhs_expr.Name name:p)
                  right: 
                    (arith_expr.ArithWord
                      w: 
                        {
                          (braced_var_sub
                            token: <VSub_Name BASH_ARGV>
                            prefix_op: VSub_Pound
                            bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                          )
                        }
                    )
                )
            )
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [
                (command.Sentence
                  child: 
                    (command.DParen
                      child: 
                        (arith_expr.Binary
                          op_id: Arith_Great
                          left: (arith_expr.VarRef token:<Lit_ArithVarLike n>)
                          right: (arith_expr.ArithWord w:{(Lit_Digits 0)})
                        )
                    )
                  terminator: <Op_Semi ';'>
                )
              ]
              body: 
                (command.DoGroup
                  children: [
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(Lit_LBracket '[')} 
                          {
                            (DQ 
                              (braced_var_sub
                                token: <VSub_Name FUNCNAME>
                                bracket_op: 
                                  (bracket_op.ArrayIndex
                                    expr: (arith_expr.ArithWord w:{(${ VSub_Name n)})
                                  )
                              )
                            )
                          } {(Lit_Equals '=') (Lit_Equals '=')} {(DQ (__qa_call))} {(Lit_RBracket ']')}
                        )
                        (command.ControlFlow token:<ControlFlow_Break break>)
                      ]
                    )
                    (command.DParen
                      child: 
                        (arith_expr.BinaryAssign
                          op_id: Arith_MinusEqual
                          left: (sh_lhs_expr.Name name:p)
                          right: 
                            (arith_expr.ArithWord
                              w: 
                                {
                                  (braced_var_sub
                                    token: <VSub_Name BASH_ARGC>
                                    bracket_op: 
                                      (bracket_op.ArrayIndex
                                        expr: (arith_expr.ArithWord w:{(${ VSub_Name n)})
                                      )
                                  )
                                }
                            )
                        )
                    )
                    (command.DParen
                      child: 
                        (arith_expr.UnaryAssign
                          op_id: Node_PostDMinus
                          child: (sh_lhs_expr.Name name:n)
                        )
                    )
                  ]
                )
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.DParen
                          child: 
                            (arith_expr.Binary
                              op_id: Arith_DEqual
                              left: (arith_expr.VarRef token:<Lit_ArithVarLike n>)
                              right: (arith_expr.ArithWord w:{(Lit_Digits 0)})
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.DParen
                      child: 
                        (arith_expr.BinaryAssign
                          op_id: Arith_Equal
                          left: (sh_lhs_expr.Name name:n)
                          right: 
                            (arith_expr.Binary
                              op_id: Arith_Minus
                              left: 
                                (arith_expr.ArithWord
                                  w: 
                                    {
                                      (braced_var_sub
                                        token: <VSub_Name FUNCNAME>
                                        prefix_op: VSub_Pound
                                        bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                                      )
                                    }
                                )
                              right: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                            )
                        )
                    )
                    (command.DParen
                      child: 
                        (arith_expr.BinaryAssign
                          op_id: Arith_Equal
                          left: (sh_lhs_expr.Name name:p)
                          right: 
                            (arith_expr.ArithWord
                              w: 
                                {
                                  (braced_var_sub
                                    token: <VSub_Name BASH_ARGV>
                                    prefix_op: VSub_Pound
                                    bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                                  )
                                }
                            )
                        )
                    )
                  ]
                )
              ]
            )
            (C {(eerror)} {(DQ ('Call stack:'))})
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [
                (command.Sentence
                  child: 
                    (command.DParen
                      child: 
                        (arith_expr.Binary
                          op_id: Arith_Great
                          left: (arith_expr.VarRef token:<Lit_ArithVarLike n>)
                          right: (arith_expr.ArithWord w:{(${ VSub_Name strip)})
                        )
                    )
                  terminator: <Op_Semi ';'>
                )
              ]
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:funcname)
                          op: Equal
                          rhs: 
                            {
                              (braced_var_sub
                                token: <VSub_Name FUNCNAME>
                                bracket_op: 
                                  (bracket_op.ArrayIndex
                                    expr: 
                                      (arith_expr.Binary
                                        op_id: Arith_Minus
                                        left: (arith_expr.ArithWord w:{(${ VSub_Name n)})
                                        right: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                                      )
                                  )
                              )
                            }
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:sourcefile)
                          op: Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Left_DollarParen '$('>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(basename)} 
                                        {
                                          (DQ 
                                            (braced_var_sub
                                              token: <VSub_Name BASH_SOURCE>
                                              bracket_op: 
                                                (bracket_op.ArrayIndex
                                                  expr: (arith_expr.ArithWord w:{(${ VSub_Name n)})
                                                )
                                            )
                                          )
                                        }
                                      )
                                    ]
                                  )
                              )
                            }
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:lineno)
                          op: Equal
                          rhs: 
                            {
                              (braced_var_sub
                                token: <VSub_Name BASH_LINENO>
                                bracket_op: 
                                  (bracket_op.ArrayIndex
                                    expr: 
                                      (arith_expr.Binary
                                        op_id: Arith_Minus
                                        left: (arith_expr.ArithWord w:{(${ VSub_Name n)})
                                        right: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                                      )
                                  )
                              )
                            }
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:args) op:Equal rhs:(word.Empty))]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Unary
                                      op_id: BoolUnary_n
                                      child: 
                                        {
                                          (DQ 
                                            (braced_var_sub
                                              token: <VSub_Name BASH_ARGV>
                                              bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                                            )
                                          )
                                        }
                                    )
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ForExpr
                              init: 
                                (arith_expr.BinaryAssign
                                  op_id: Arith_Equal
                                  left: (sh_lhs_expr.Name name:j)
                                  right: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                                )
                              cond: 
                                (arith_expr.Binary
                                  op_id: Arith_LessEqual
                                  left: (arith_expr.VarRef token:<Lit_ArithVarLike j>)
                                  right: 
                                    (arith_expr.ArithWord
                                      w: 
                                        {
                                          (braced_var_sub
                                            token: <VSub_Name BASH_ARGC>
                                            bracket_op: 
                                              (bracket_op.ArrayIndex
                                                expr: 
                                                  (arith_expr.Binary
                                                    op_id: Arith_Minus
                                                    left: (arith_expr.ArithWord w:{(${ VSub_Name n)})
                                                    right: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                                                  )
                                              )
                                          )
                                        }
                                    )
                                )
                              update: 
                                (arith_expr.UnaryAssign
                                  op_id: Arith_DPlus
                                  child: (sh_lhs_expr.Name name:j)
                                )
                              body: 
                                (command.DoGroup
                                  children: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:newarg)
                                          op: Equal
                                          rhs: 
                                            {
                                              (braced_var_sub
                                                token: <VSub_Name BASH_ARGV>
                                                bracket_op: 
                                                  (bracket_op.ArrayIndex
                                                    expr: 
                                                      (arith_expr.ArithWord
                                                        w: 
                                                          {
                                                            (word_part.ArithSub
                                                              anode: 
                                                                (arith_expr.Binary
                                                                  op_id: Arith_Minus
                                                                  left: 
                                                                    (arith_expr.Binary
                                                                      op_id: Arith_Minus
                                                                      left: 
                                                                        (arith_expr.VarRef
                                                                          token: <Lit_ArithVarLike p>
                                                                        )
                                                                      right: 
                                                                        (arith_expr.VarRef
                                                                          token: <Lit_ArithVarLike j>
                                                                        )
                                                                    )
                                                                  right: 
                                                                    (arith_expr.ArithWord
                                                                      w: {(Lit_Digits 1)}
                                                                    )
                                                                )
                                                            )
                                                          }
                                                      )
                                                  )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:args)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (braced_var_sub
                                                  token: <VSub_Name args>
                                                  suffix_op: 
                                                    (suffix_op.Unary
                                                      op_id: VTest_ColonPlus
                                                      arg_word: {(${ VSub_Name args) (' ')}
                                                    )
                                                ) ("'") (${ VSub_Name newarg) ("'")
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                            )
                            (command.DParen
                              child: 
                                (arith_expr.BinaryAssign
                                  op_id: Arith_MinusEqual
                                  left: (sh_lhs_expr.Name name:p)
                                  right: 
                                    (arith_expr.ArithWord
                                      w: 
                                        {
                                          (braced_var_sub
                                            token: <VSub_Name BASH_ARGC>
                                            bracket_op: 
                                              (bracket_op.ArrayIndex
                                                expr: 
                                                  (arith_expr.Binary
                                                    op_id: Arith_Minus
                                                    left: (arith_expr.ArithWord w:{(${ VSub_Name n)})
                                                    right: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                                                  )
                                              )
                                          )
                                        }
                                    )
                                )
                            )
                          ]
                        )
                      ]
                    )
                    (C {(eerror)} 
                      {
                        (DQ ('  ') 
                          (command_sub
                            left_token: <Left_DollarParen '$('>
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(printf)} {(DQ ('%') (${ VSub_Name filespacing) (s))} 
                                    {(DQ (${ VSub_Name sourcefile))}
                                  )
                                ]
                              )
                          ) (', line ') 
                          (command_sub
                            left_token: <Left_DollarParen '$('>
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(printf)} {(DQ ('%') (${ VSub_Name linespacing) (s))} 
                                    {(DQ (${ VSub_Name lineno))}
                                  )
                                ]
                              )
                          ) (':  Called ') (${ VSub_Name funcname) 
                          (braced_var_sub
                            token: <VSub_Name args>
                            suffix_op: 
                              (suffix_op.Unary
                                op_id: VTest_ColonPlus
                                arg_word: {(' ') (${ VSub_Name args)}
                              )
                          )
                        )
                      }
                    )
                    (command.DParen
                      child: 
                        (arith_expr.UnaryAssign
                          op_id: Node_PostDMinus
                          child: (sh_lhs_expr.Name name:n)
                        )
                    )
                  ]
                )
            )
          ]
        )
    )
    (command.ShFunction
      name: nonfatal
      body: 
        (command.BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: (command.Pipeline children:[(C {(___eapi_has_nonfatal)})] negated:T)
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(die)} {(DQ ($ VSub_DollarName '$FUNCNAME') ('() not supported in this EAPI'))})
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: BoolBinary_lt
                              left: {($ VSub_Pound '$#')}
                              right: {(1)}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [(C {(die)} {(DQ ($ VSub_DollarName '$FUNCNAME') ('(): Missing argument'))})]
                )
              ]
            )
            (command.Simple
              words: [{(DQ ($ VSub_At '$@'))}]
              more_env: [(env_pair name:PORTAGE_NONFATAL val:{(1)})]
            )
          ]
        )
    )
    (command.ShFunction
      name: __bashpid
      body: (command.BraceGroup children:[(C {(sh)} {(-c)} {(SQ <'echo ${PPID}'>)})])
    )
    (command.ShFunction
      name: __helpers_die
      body: 
        (command.BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.AndOr
                          ops: [Op_DAmp]
                          children: [
                            (C {(___eapi_helpers_can_die)})
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: BoolBinary_GlobNEqual
                                  left: {(${ VSub_Name PORTAGE_NONFATAL)}
                                  right: {(1)}
                                )
                            )
                          ]
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [(C {(die)} {(DQ ($ VSub_At '$@'))})]
                )
              ]
              else_action: [
                (command.Simple
                  words: [{(echo)} {(-e)} {(DQ ($ VSub_At '$@'))}]
                  redirects: [(redir.Redir op:<Redir_GreatAnd '>&'> fd:16777215 arg_word:{(2)})]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: die
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (command.DBracket
                  expr: (bool_expr.Unary op_id:BoolUnary_n child:{(${ VSub_Name _PORTAGE_ORIG_PATH)})
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:PATH)
                      op: Equal
                      rhs: {(${ VSub_Name _PORTAGE_ORIG_PATH)}
                    )
                  ]
                )
              ]
            )
            (C {(KW_Set set)} {(Lit_Other '+') (x)})
            (C {(local)} 
              {(Lit_VarLike 'IFS=') 
                (single_quoted
                  left: <Left_SingleQuoteC "$'">
                  tokens: [<Char_Literals ' '> <Char_OneChar '\\t'> <Char_OneChar '\\n'>]
                )
              }
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.AndOr
                          ops: [Op_DAmp]
                          children: [
                            (C {(___eapi_die_can_respect_nonfatal)})
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: BoolBinary_GlobDEqual
                                  left: {($ VSub_Number '$1')}
                                  right: {(BoolUnary_n -n)}
                                )
                            )
                          ]
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(shift)})
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: BoolBinary_GlobDEqual
                                      left: {(${ VSub_Name PORTAGE_NONFATAL)}
                                      right: {(1)}
                                    )
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.AndOr
                              ops: [Op_DAmp]
                              children: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: BoolBinary_gt
                                      left: {($ VSub_Pound '$#')}
                                      right: {(0)}
                                    )
                                )
                                (C {(eerror)} {(DQ ($ VSub_Star '$*'))})
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Return return>
                              arg_word: {(1)}
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (C {(KW_Set set)} {(Lit_Other '+') (e)})
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(Lit_LBracket '[')} {(-n)} {(DQ (${ VSub_Name QA_INTERCEPTORS))} 
                          {(Lit_RBracket ']')}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(unset)} {(-f)} {(${ VSub_Name QA_INTERCEPTORS)})
                    (C {(unset)} {(QA_INTERCEPTORS)})
                  ]
                )
              ]
            )
            (C {(local)} {(n)} {(Lit_VarLike 'filespacing=') (0)} {(Lit_VarLike 'linespacing=') (0)})
            (command.DParen
              child: 
                (arith_expr.BinaryAssign
                  op_id: Arith_Equal
                  left: (sh_lhs_expr.Name name:n)
                  right: 
                    (arith_expr.Binary
                      op_id: Arith_Minus
                      left: 
                        (arith_expr.ArithWord
                          w: 
                            {
                              (braced_var_sub
                                token: <VSub_Name FUNCNAME>
                                prefix_op: VSub_Pound
                                bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                              )
                            }
                        )
                      right: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                    )
                )
            )
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [
                (command.Sentence
                  child: 
                    (command.DParen
                      child: 
                        (arith_expr.Binary
                          op_id: Arith_Great
                          left: (arith_expr.VarRef token:<Lit_ArithVarLike n>)
                          right: (arith_expr.ArithWord w:{(Lit_Digits 0)})
                        )
                    )
                  terminator: <Op_Semi ';'>
                )
              ]
              body: 
                (command.DoGroup
                  children: [
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(Lit_LBracket '[')} 
                          {
                            (DQ 
                              (braced_var_sub
                                token: <VSub_Name FUNCNAME>
                                bracket_op: 
                                  (bracket_op.ArrayIndex
                                    expr: (arith_expr.ArithWord w:{(${ VSub_Name n)})
                                  )
                              )
                            )
                          } {(Lit_Equals '=') (Lit_Equals '=')} {(DQ (__qa_call))} {(Lit_RBracket ']')}
                        )
                        (command.ControlFlow token:<ControlFlow_Break break>)
                      ]
                    )
                    (command.DParen
                      child: 
                        (arith_expr.UnaryAssign
                          op_id: Node_PostDMinus
                          child: (sh_lhs_expr.Name name:n)
                        )
                    )
                  ]
                )
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (command.DParen
                  child: 
                    (arith_expr.Binary
                      op_id: Arith_DEqual
                      left: (arith_expr.VarRef token:<Lit_ArithVarLike n>)
                      right: (arith_expr.ArithWord w:{(Lit_Digits 0)})
                    )
                )
                (command.DParen
                  child: 
                    (arith_expr.BinaryAssign
                      op_id: Arith_Equal
                      left: (sh_lhs_expr.Name name:n)
                      right: 
                        (arith_expr.Binary
                          op_id: Arith_Minus
                          left: 
                            (arith_expr.ArithWord
                              w: 
                                {
                                  (braced_var_sub
                                    token: <VSub_Name FUNCNAME>
                                    prefix_op: VSub_Pound
                                    bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                                  )
                                }
                            )
                          right: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                        )
                    )
                )
              ]
            )
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [
                (command.Sentence
                  child: 
                    (command.DParen
                      child: 
                        (arith_expr.Binary
                          op_id: Arith_Great
                          left: (arith_expr.VarRef token:<Lit_ArithVarLike n>)
                          right: (arith_expr.ArithWord w:{(Lit_Digits 0)})
                        )
                    )
                  terminator: <Op_Semi ';'>
                )
              ]
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:sourcefile)
                          op: Equal
                          rhs: 
                            {
                              (braced_var_sub
                                token: <VSub_Name BASH_SOURCE>
                                bracket_op: 
                                  (bracket_op.ArrayIndex
                                    expr: (arith_expr.ArithWord w:{(${ VSub_Name n)})
                                  )
                              )
                            }
                        )
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:sourcefile)
                          op: Equal
                          rhs: 
                            {
                              (braced_var_sub
                                token: <VSub_Name sourcefile>
                                suffix_op: 
                                  (suffix_op.Unary
                                    op_id: VOp1_DPound
                                    arg_word: {('*') (Lit_Slash /)}
                                  )
                              )
                            }
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:lineno)
                          op: Equal
                          rhs: 
                            {
                              (braced_var_sub
                                token: <VSub_Name BASH_LINENO>
                                bracket_op: 
                                  (bracket_op.ArrayIndex
                                    expr: (arith_expr.ArithWord w:{(${ VSub_Name n)})
                                  )
                              )
                            }
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (command.DParen
                          child: 
                            (arith_expr.Binary
                              op_id: Arith_Less
                              left: (arith_expr.VarRef token:<Lit_ArithVarLike filespacing>)
                              right: 
                                (arith_expr.ArithWord
                                  w: 
                                    {
                                      (braced_var_sub
                                        token: <VSub_Name sourcefile>
                                        prefix_op: VSub_Pound
                                      )
                                    }
                                )
                            )
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:filespacing)
                              op: Equal
                              rhs: 
                                {(braced_var_sub token:<VSub_Name sourcefile> prefix_op:VSub_Pound)}
                            )
                          ]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (command.DParen
                          child: 
                            (arith_expr.Binary
                              op_id: Arith_Less
                              left: (arith_expr.VarRef token:<Lit_ArithVarLike linespacing>)
                              right: 
                                (arith_expr.ArithWord
                                  w: {(braced_var_sub token:<VSub_Name lineno> prefix_op:VSub_Pound)}
                                )
                            )
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:linespacing)
                              op: Equal
                              rhs: {(braced_var_sub token:<VSub_Name lineno> prefix_op:VSub_Pound)}
                            )
                          ]
                        )
                      ]
                    )
                    (command.DParen
                      child: 
                        (arith_expr.UnaryAssign
                          op_id: Node_PostDMinus
                          child: (sh_lhs_expr.Name name:n)
                        )
                    )
                  ]
                )
            )
            (C {(local)} {(Lit_VarLike 'phase_str=')})
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (command.DBracket
                  expr: (bool_expr.Unary op_id:BoolUnary_n child:{($ VSub_DollarName '$EBUILD_PHASE')})
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:phase_str)
                      op: Equal
                      rhs: {(DQ (' (') ($ VSub_DollarName '$EBUILD_PHASE') (' phase)'))}
                    )
                  ]
                )
              ]
            )
            (C {(eerror)} 
              {
                (DQ ('ERROR: ') (${ VSub_Name CATEGORY) (/) (${ VSub_Name PF) ('::') 
                  (${ VSub_Name PORTAGE_REPO_NAME) (' failed') (${ VSub_Name phase_str) (':')
                )
              }
            )
            (C {(eerror)} 
              {
                (DQ ('  ') 
                  (braced_var_sub
                    token: <VSub_Star '*'>
                    suffix_op: 
                      (suffix_op.Unary
                        op_id: VTest_ColonHyphen
                        arg_word: {('(no error message)')}
                      )
                  )
                )
              }
            )
            (C {(eerror)})
            (C {(local)} {(main_index)})
            (command.DParen
              child: 
                (arith_expr.BinaryAssign
                  op_id: Arith_Equal
                  left: (sh_lhs_expr.Name name:main_index)
                  right: 
                    (arith_expr.Binary
                      op_id: Arith_Minus
                      left: 
                        (arith_expr.ArithWord
                          w: 
                            {
                              (braced_var_sub
                                token: <VSub_Name BASH_SOURCE>
                                prefix_op: VSub_Pound
                                bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                              )
                            }
                        )
                      right: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                    )
                )
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(has)} 
                          {
                            (braced_var_sub
                              token: <VSub_Name BASH_SOURCE>
                              bracket_op: 
                                (bracket_op.ArrayIndex
                                  expr: (arith_expr.ArithWord w:{($ VSub_DollarName '$main_index')})
                                )
                              suffix_op: 
                                (suffix_op.Unary
                                  op_id: VOp1_DPound
                                  arg_word: {('*') (Lit_Slash /)}
                                )
                            )
                          } {(ebuild.sh)} {(misc-functions.sh)}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(__dump_trace)} {(2)} {(${ VSub_Name filespacing)} {(${ VSub_Name linespacing)})
                    (C {(eerror)} 
                      {
                        (DQ ('  ') 
                          (command_sub
                            left_token: <Left_DollarParen '$('>
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(printf)} {(DQ ('%') (${ VSub_Name filespacing) (s))} 
                                    {
                                      (DQ 
                                        (braced_var_sub
                                          token: <VSub_Name BASH_SOURCE>
                                          bracket_op: 
                                            (bracket_op.ArrayIndex
                                              expr: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                                            )
                                          suffix_op: 
                                            (suffix_op.Unary
                                              op_id: VOp1_DPound
                                              arg_word: {('*') (Lit_Slash /)}
                                            )
                                        )
                                      )
                                    }
                                  )
                                ]
                              )
                          ) (', line ') 
                          (command_sub
                            left_token: <Left_DollarParen '$('>
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(printf)} {(DQ ('%') (${ VSub_Name linespacing) (s))} 
                                    {
                                      (DQ 
                                        (braced_var_sub
                                          token: <VSub_Name BASH_LINENO>
                                          bracket_op: 
                                            (bracket_op.ArrayIndex
                                              expr: (arith_expr.ArithWord w:{(Lit_Digits 0)})
                                            )
                                        )
                                      )
                                    }
                                  )
                                ]
                              )
                          ) (':  Called die')
                        )
                      }
                    )
                    (C {(eerror)} {(DQ ('The specific snippet of code:'))})
                    (command.Pipeline
                      children: [
                        (C {(sed)} {(-n)} {(-e)} 
                          {
                            (DQ ('# When we get to the line that failed, append it to the\n') 
                              ('\t\t    # hold space, move the hold space to the pattern space,\n') ('\t\t    # then print out the pattern space and quit immediately\n') ('\t\t    ') 
                              (braced_var_sub
                                token: <VSub_Name BASH_LINENO>
                                bracket_op: 
                                  (bracket_op.ArrayIndex
                                    expr: (arith_expr.ArithWord w:{(Lit_Digits 0)})
                                  )
                              ) ('{H;g;p;q}')
                            )
                          } {(-e)} 
                          {
                            (SQ <'# If this line ends with a line continuation, append it\n'> 
                              <'\t\t    # to the hold space\n'> <'\t\t    /\\\\$/H'>
                            )
                          } {(-e)} 
                          {
                            (SQ <'# If this line does not end with a line continuation,\n'> 
                              <'\t\t    # erase the line and set the hold buffer to it (thus\n'> <'\t\t    # erasing the hold buffer in the process)\n'> <'\t\t    /[^\\]$/{s:^.*$::;h}'>
                            )
                          } 
                          {
                            (DQ 
                              (braced_var_sub
                                token: <VSub_Name BASH_SOURCE>
                                bracket_op: 
                                  (bracket_op.ArrayIndex
                                    expr: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                                  )
                              )
                            )
                          }
                        )
                        (C {(sed)} {(-e)} {(SQ <1d>)} {(-e)} {(SQ <'s:^:RETAIN-LEADING-SPACE:'>)})
                        (command.WhileUntil
                          keyword: <KW_While while>
                          cond: [
                            (command.Sentence
                              child: (C {(read)} {(-r)} {(n)})
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          body: 
                            (command.DoGroup
                              children: [
                                (command.Sentence
                                  child: 
                                    (C {(eerror)} 
                                      {
                                        (DQ ('  ') 
                                          (braced_var_sub
                                            token: <VSub_Name n>
                                            suffix_op: 
                                              (suffix_op.Unary
                                                op_id: VOp1_Pound
                                                arg_word: {(RETAIN-LEADING-SPACE)}
                                              )
                                          )
                                        )
                                      }
                                    )
                                  terminator: <Op_Semi ';'>
                                )
                              ]
                            )
                        )
                      ]
                      negated: F
                    )
                    (C {(eerror)})
                  ]
                )
              ]
            )
            (C {(eerror)} 
              {
                (DQ ('If you need support, post the output of ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\`'>) ("emerge --info '=") (${ VSub_Name CATEGORY) (/) (${ VSub_Name PF) ('::') (${ VSub_Name PORTAGE_REPO_NAME) 
                  ("'") (word_part.EscapedLiteral token:<Lit_EscapedChar '\\`'>) (',')
                )
              }
            )
            (C {(eerror)} 
              {
                (DQ ('the complete build log and the output of ') 
                  (word_part.EscapedLiteral token:<Lit_EscapedChar '\\`'>) ("emerge -pqv '=") (${ VSub_Name CATEGORY) (/) (${ VSub_Name PF) ('::') (${ VSub_Name PORTAGE_REPO_NAME) 
                  ("'") (word_part.EscapedLiteral token:<Lit_EscapedChar '\\`'>) (.)
                )
              }
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.AndOr
                          ops: [Op_DAmp]
                          children: [
                            (C {(has)} 
                              {
                                (braced_var_sub
                                  token: <VSub_Name BASH_SOURCE>
                                  bracket_op: 
                                    (bracket_op.ArrayIndex
                                      expr: 
                                        (arith_expr.ArithWord
                                          w: {($ VSub_DollarName '$main_index')}
                                        )
                                    )
                                  suffix_op: 
                                    (suffix_op.Unary
                                      op_id: VOp1_DPound
                                      arg_word: {('*') (Lit_Slash /)}
                                    )
                                )
                              } {(ebuild.sh)} {(misc-functions.sh)}
                            )
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: BoolBinary_GlobNEqual
                                  left: {(${ VSub_Name EBUILD_PHASE)}
                                  right: {(depend)}
                                )
                            )
                          ]
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(local)} {(x)})
                    (command.ForEach
                      iter_name: x
                      iter_words: [{($ VSub_DollarName '$EBUILD_DEATH_HOOKS')}]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.Simple
                              words: [{(${ VSub_Name x)} {(DQ ($ VSub_At '$@'))}]
                              redirects: [
                                (redir.Redir
                                  op: <Redir_GreatAnd '>&'>
                                  fd: 16777215
                                  arg_word: {(2)}
                                )
                                (redir.Redir
                                  op: <Redir_GreatAnd '1>&'>
                                  fd: 1
                                  arg_word: {(2)}
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (command.Simple
                      redirects: [
                        (redir.Redir
                          op: <Redir_Great '>'>
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_DollarName '$PORTAGE_BUILDDIR') (/.die_hooks))}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.Unary
                              op_id: BoolUnary_n
                              child: {(${ VSub_Name PORTAGE_LOG_FILE)}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(eerror)} 
                      {
                        (DQ ("The complete build log is located at '") (${ VSub_Name PORTAGE_LOG_FILE) 
                          ("'.")
                        )
                      }
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.AndOr
                                  ops: [Op_DAmp]
                                  children: [
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: BoolBinary_GlobNEqual
                                          left: {(${ VSub_Name PORTAGE_LOG_FILE)}
                                          right: {(${ VSub_Name T) (/) (Lit_Other '*')}
                                        )
                                    )
                                    (command.Pipeline
                                      children: [(C {(has)} {(fail-clean)} {(${ VSub_Name FEATURES)})]
                                      negated: T
                                    )
                                  ]
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {(local)} {(Lit_VarLike 'log_ext=') (log)})
                            (command.AndOr
                              ops: [Op_DAmp]
                              children: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: BoolBinary_GlobNEqual
                                      left: {(${ VSub_Name PORTAGE_LOG_FILE)}
                                      right: {(Lit_Other '*') (.log)}
                                    )
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:log_ext)
                                      op: PlusEqual
                                      rhs: 
                                        {(.) 
                                          (braced_var_sub
                                            token: <VSub_Name PORTAGE_LOG_FILE>
                                            suffix_op: 
                                              (suffix_op.Unary
                                                op_id: VOp1_DPound
                                                arg_word: {('*.')}
                                              )
                                          )
                                        }
                                    )
                                  ]
                                )
                              ]
                            )
                            (C {(eerror)} 
                              {
                                (DQ ("For convenience, a symlink to the build log is located at '") 
                                  (${ VSub_Name T) (/build.) (${ VSub_Name log_ext) ("'.")
                                )
                              }
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(Lit_LBracket '[')} {(-f)} {(DQ (${ VSub_Name T) (/environment))} 
                          {(Lit_RBracket ']')}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(eerror)} 
                      {
                        (DQ ("The ebuild environment file is located at '") (${ VSub_Name T) 
                          ("/environment'.")
                        )
                      }
                    )
                  ]
                )
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(Lit_LBracket '[')} {(-d)} {(DQ (${ VSub_Name T))} {(Lit_RBracket ']')})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.BraceGroup
                      children: [(C {(KW_Set set)}) (C {(export)})]
                      redirects: [
                        (redir.Redir
                          op: <Redir_Great '>'>
                          fd: 16777215
                          arg_word: {(DQ (${ VSub_Name T) (/die.env))}
                        )
                      ]
                    )
                    (C {(eerror)} 
                      {
                        (DQ ("The ebuild environment file is located at '") (${ VSub_Name T) 
                          ("/die.env'.")
                        )
                      }
                    )
                  ]
                )
              ]
            )
            (C {(eerror)} 
              {
                (DQ ("Working directory: '") 
                  (command_sub
                    left_token: <Left_DollarParen '$('>
                    command_list: (command.CommandList children:[(C {(pwd)})])
                  ) ("'")
                )
              }
            )
            (C {(eerror)} {(DQ ("S: '") (${ VSub_Name S) ("'"))})
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.Unary
                      op_id: BoolUnary_n
                      child: {($ VSub_DollarName '$PORTAGE_EBUILD_EXIT_FILE')}
                    )
                )
                (command.Simple
                  redirects: [
                    (redir.Redir
                      op: <Redir_Great '>'>
                      fd: 16777215
                      arg_word: {(DQ ($ VSub_DollarName '$PORTAGE_EBUILD_EXIT_FILE'))}
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.Unary
                      op_id: BoolUnary_n
                      child: {($ VSub_DollarName '$PORTAGE_IPC_DAEMON')}
                    )
                )
                (C {(DQ ($ VSub_DollarName '$PORTAGE_BIN_PATH')) (/ebuild-ipc)} 
                  {(ControlFlow_Exit exit)} {(1)}
                )
              ]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.Binary
                      op_id: BoolBinary_GlobDEqual
                      left: 
                        {
                          (braced_var_sub
                            token: <VSub_Name BASHPID>
                            suffix_op: 
                              (suffix_op.Unary
                                op_id: VTest_ColonHyphen
                                arg_word: 
                                  {
                                    (command_sub
                                      left_token: <Left_DollarParen '$('>
                                      command_list: 
                                        (command.CommandList
                                          children: [(C {(__bashpid)})]
                                        )
                                    )
                                  }
                              )
                          )
                        }
                      right: {(${ VSub_Name EBUILD_MASTER_PID)}
                    )
                )
                (C {(kill)} {(-s)} {(SIGTERM)} {(${ VSub_Name EBUILD_MASTER_PID)})
              ]
            )
            (command.ControlFlow token:<ControlFlow_Exit exit> arg_word:{(1)})
          ]
        )
    )
    (command.ShFunction
      name: __quiet_mode
      body: 
        (command.BraceGroup
          children: [
            (command.DBracket
              expr: 
                (bool_expr.Binary
                  op_id: BoolBinary_eq
                  left: {(${ VSub_Name PORTAGE_QUIET)}
                  right: {(1)}
                )
            )
          ]
        )
    )
    (command.ShFunction
      name: __vecho
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DPipe]
              children: [(C {(__quiet_mode)}) (C {(echo)} {(DQ ($ VSub_At '$@'))})]
            )
          ]
        )
    )
    (command.ShFunction
      name: __elog_base
      body: 
        (command.BraceGroup
          children: [
            (C {(local)} {(messagetype)})
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(Lit_LBracket '[')} {(-z)} {(DQ (${ VSub_Number 1))} {(-o)} {(-z)} 
                  {(DQ (${ VSub_Name T))} {(-o)} {(KW_Bang '!')} {(-d)} {(DQ (${ VSub_Name T) (/logging))} {(Lit_RBracket ']')}
                )
                (command.ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
            )
            (command.Case
              to_match: {(DQ (${ VSub_Number 1))}
              arms: [
                (case_arm
                  pat_list: [{(INFO)} {(WARN)} {(ERROR)} {(LOG)} {(QA)}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:messagetype)
                          op: Equal
                          rhs: {(DQ (${ VSub_Number 1))}
                        )
                      ]
                    )
                    (C {(shift)})
                  ]
                )
                (case_arm
                  pat_list: [{(Lit_Star '*')}]
                  action: [
                    (C {(__vecho)} {(-e)} 
                      {
                        (DQ (' ') (${ VSub_Name BAD) ('*') (${ VSub_Name NORMAL) 
                          (
' Invalid use of internal function __elog_base(), next message will not be logged'
                          )
                        )
                      }
                    )
                    (command.ControlFlow
                      token: <ControlFlow_Return return>
                      arg_word: {(1)}
                    )
                  ]
                )
              ]
            )
            (command.Pipeline
              children: [
                (C {(echo)} {(-e)} {(DQ ($ VSub_At '$@'))})
                (command.WhileUntil
                  keyword: <KW_While while>
                  cond: [(command.Sentence child:(C {(read)} {(-r)}) terminator:<Op_Semi ';'>)]
                  body: 
                    (command.DoGroup
                      children: [
                        (command.Simple
                          words: [
                            {(echo)}
                            {
                              (DQ ($ VSub_DollarName '$messagetype') (' ') ($ VSub_DollarName '$REPLY'))
                            }
                          ]
                          redirects: [
                            (redir.Redir
                              op: <Redir_DGreat '>>'>
                              fd: 16777215
                              arg_word: 
                                {
                                  (DQ (${ VSub_Name T) (/logging/) 
                                    (braced_var_sub
                                      token: <VSub_Name EBUILD_PHASE>
                                      suffix_op: 
                                        (suffix_op.Unary
                                          op_id: VTest_ColonHyphen
                                          arg_word: {(other)}
                                        )
                                    )
                                  )
                                }
                            )
                          ]
                        )
                      ]
                    )
                )
              ]
              negated: F
            )
            (command.ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
          ]
        )
    )
    (command.ShFunction
      name: eqawarn
      body: 
        (command.BraceGroup
          children: [
            (C {(__elog_base)} {(QA)} {(DQ ($ VSub_Star '$*'))})
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.LogicalAnd
                      left: 
                        (bool_expr.Binary
                          op_id: BoolBinary_GlobNEqual
                          left: {(${ VSub_Name RC_ENDCOL)}
                          right: {(DQ (yes))}
                        )
                      right: 
                        (bool_expr.Binary
                          op_id: BoolBinary_GlobDEqual
                          left: {(${ VSub_Name LAST_E_CMD)}
                          right: {(DQ (ebegin))}
                        )
                    )
                )
                (C {(echo)})
              ]
            )
            (command.Pipeline
              children: [
                (C {(echo)} {(-e)} {(DQ ($ VSub_At '$@'))})
                (command.WhileUntil
                  keyword: <KW_While while>
                  cond: [(command.Sentence child:(C {(read)} {(-r)}) terminator:<Op_Semi ';'>)]
                  body: 
                    (command.DoGroup
                      children: [
                        (command.Simple
                          words: [
                            {(__vecho)}
                            {
                              (DQ (' ') ($ VSub_DollarName '$WARN') ('*') ($ VSub_DollarName '$NORMAL') 
                                (' ') ($ VSub_DollarName '$REPLY')
                              )
                            }
                          ]
                          redirects: [(redir.Redir op:<Redir_GreatAnd '>&'> fd:16777215 arg_word:{(2)})]
                        )
                      ]
                    )
                )
              ]
              negated: F
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:LAST_E_CMD) op:Equal rhs:{(DQ (eqawarn))})]
            )
            (command.ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
          ]
        )
    )
    (command.ShFunction
      name: elog
      body: 
        (command.BraceGroup
          children: [
            (C {(__elog_base)} {(LOG)} {(DQ ($ VSub_Star '$*'))})
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.LogicalAnd
                      left: 
                        (bool_expr.Binary
                          op_id: BoolBinary_GlobNEqual
                          left: {(${ VSub_Name RC_ENDCOL)}
                          right: {(DQ (yes))}
                        )
                      right: 
                        (bool_expr.Binary
                          op_id: BoolBinary_GlobDEqual
                          left: {(${ VSub_Name LAST_E_CMD)}
                          right: {(DQ (ebegin))}
                        )
                    )
                )
                (C {(echo)})
              ]
            )
            (command.Pipeline
              children: [
                (C {(echo)} {(-e)} {(DQ ($ VSub_At '$@'))})
                (command.WhileUntil
                  keyword: <KW_While while>
                  cond: [(command.Sentence child:(C {(read)} {(-r)}) terminator:<Op_Semi ';'>)]
                  body: 
                    (command.DoGroup
                      children: [
                        (C {(echo)} 
                          {
                            (DQ (' ') ($ VSub_DollarName '$GOOD') ('*') ($ VSub_DollarName '$NORMAL') 
                              (' ') ($ VSub_DollarName '$REPLY')
                            )
                          }
                        )
                      ]
                    )
                )
              ]
              negated: F
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:LAST_E_CMD) op:Equal rhs:{(DQ (elog))})]
            )
            (command.ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
          ]
        )
    )
    (command.ShFunction
      name: einfo
      body: 
        (command.BraceGroup
          children: [
            (C {(__elog_base)} {(INFO)} {(DQ ($ VSub_Star '$*'))})
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.LogicalAnd
                      left: 
                        (bool_expr.Binary
                          op_id: BoolBinary_GlobNEqual
                          left: {(${ VSub_Name RC_ENDCOL)}
                          right: {(DQ (yes))}
                        )
                      right: 
                        (bool_expr.Binary
                          op_id: BoolBinary_GlobDEqual
                          left: {(${ VSub_Name LAST_E_CMD)}
                          right: {(DQ (ebegin))}
                        )
                    )
                )
                (C {(echo)})
              ]
            )
            (command.Pipeline
              children: [
                (C {(echo)} {(-e)} {(DQ ($ VSub_At '$@'))})
                (command.WhileUntil
                  keyword: <KW_While while>
                  cond: [(command.Sentence child:(C {(read)} {(-r)}) terminator:<Op_Semi ';'>)]
                  body: 
                    (command.DoGroup
                      children: [
                        (C {(echo)} 
                          {
                            (DQ (' ') ($ VSub_DollarName '$GOOD') ('*') ($ VSub_DollarName '$NORMAL') 
                              (' ') ($ VSub_DollarName '$REPLY')
                            )
                          }
                        )
                      ]
                    )
                )
              ]
              negated: F
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:LAST_E_CMD) op:Equal rhs:{(DQ (einfo))})]
            )
            (command.ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
          ]
        )
    )
    (command.ShFunction
      name: einfon
      body: 
        (command.BraceGroup
          children: [
            (C {(__elog_base)} {(INFO)} {(DQ ($ VSub_Star '$*'))})
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.LogicalAnd
                      left: 
                        (bool_expr.Binary
                          op_id: BoolBinary_GlobNEqual
                          left: {(${ VSub_Name RC_ENDCOL)}
                          right: {(DQ (yes))}
                        )
                      right: 
                        (bool_expr.Binary
                          op_id: BoolBinary_GlobDEqual
                          left: {(${ VSub_Name LAST_E_CMD)}
                          right: {(DQ (ebegin))}
                        )
                    )
                )
                (C {(echo)})
              ]
            )
            (C {(echo)} {(-ne)} 
              {(DQ (' ') (${ VSub_Name GOOD) ('*') (${ VSub_Name NORMAL) (' ') ($ VSub_Star '$*'))}
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:LAST_E_CMD) op:Equal rhs:{(DQ (einfon))})]
            )
            (command.ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
          ]
        )
    )
    (command.ShFunction
      name: ewarn
      body: 
        (command.BraceGroup
          children: [
            (C {(__elog_base)} {(WARN)} {(DQ ($ VSub_Star '$*'))})
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.LogicalAnd
                      left: 
                        (bool_expr.Binary
                          op_id: BoolBinary_GlobNEqual
                          left: {(${ VSub_Name RC_ENDCOL)}
                          right: {(DQ (yes))}
                        )
                      right: 
                        (bool_expr.Binary
                          op_id: BoolBinary_GlobDEqual
                          left: {(${ VSub_Name LAST_E_CMD)}
                          right: {(DQ (ebegin))}
                        )
                    )
                )
                (C {(echo)})
              ]
            )
            (command.Pipeline
              children: [
                (C {(echo)} {(-e)} {(DQ ($ VSub_At '$@'))})
                (command.WhileUntil
                  keyword: <KW_While while>
                  cond: [(command.Sentence child:(C {(read)} {(-r)}) terminator:<Op_Semi ';'>)]
                  body: 
                    (command.DoGroup
                      children: [
                        (command.Simple
                          words: [
                            {(echo)}
                            {
                              (DQ (' ') ($ VSub_DollarName '$WARN') ('*') ($ VSub_DollarName '$NORMAL') 
                                (' ') ($ VSub_DollarName '$RC_INDENTATION') ($ VSub_DollarName '$REPLY')
                              )
                            }
                          ]
                          redirects: [(redir.Redir op:<Redir_GreatAnd '>&'> fd:16777215 arg_word:{(2)})]
                        )
                      ]
                    )
                )
              ]
              negated: F
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:LAST_E_CMD) op:Equal rhs:{(DQ (ewarn))})]
            )
            (command.ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
          ]
        )
    )
    (command.ShFunction
      name: eerror
      body: 
        (command.BraceGroup
          children: [
            (C {(__elog_base)} {(ERROR)} {(DQ ($ VSub_Star '$*'))})
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.LogicalAnd
                      left: 
                        (bool_expr.Binary
                          op_id: BoolBinary_GlobNEqual
                          left: {(${ VSub_Name RC_ENDCOL)}
                          right: {(DQ (yes))}
                        )
                      right: 
                        (bool_expr.Binary
                          op_id: BoolBinary_GlobDEqual
                          left: {(${ VSub_Name LAST_E_CMD)}
                          right: {(DQ (ebegin))}
                        )
                    )
                )
                (C {(echo)})
              ]
            )
            (command.Pipeline
              children: [
                (C {(echo)} {(-e)} {(DQ ($ VSub_At '$@'))})
                (command.WhileUntil
                  keyword: <KW_While while>
                  cond: [(command.Sentence child:(C {(read)} {(-r)}) terminator:<Op_Semi ';'>)]
                  body: 
                    (command.DoGroup
                      children: [
                        (command.Simple
                          words: [
                            {(echo)}
                            {
                              (DQ (' ') ($ VSub_DollarName '$BAD') ('*') ($ VSub_DollarName '$NORMAL') 
                                (' ') ($ VSub_DollarName '$RC_INDENTATION') ($ VSub_DollarName '$REPLY')
                              )
                            }
                          ]
                          redirects: [(redir.Redir op:<Redir_GreatAnd '>&'> fd:16777215 arg_word:{(2)})]
                        )
                      ]
                    )
                )
              ]
              negated: F
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:LAST_E_CMD) op:Equal rhs:{(DQ (eerror))})]
            )
            (command.ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
          ]
        )
    )
    (command.ShFunction
      name: ebegin
      body: 
        (command.BraceGroup
          children: [
            (C {(local)} {(Lit_VarLike 'msg=') (DQ ($ VSub_Star '$*'))} {(dots)} 
              {(Lit_VarLike 'spaces=') 
                (braced_var_sub
                  token: <VSub_Name RC_DOT_PATTERN>
                  suffix_op: (suffix_op.PatSub pat:{('?')} replace:{(' ')} replace_mode:Lit_Slash)
                )
              }
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.Unary
                              op_id: BoolUnary_n
                              child: {(${ VSub_Name RC_DOT_PATTERN)}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:dots)
                          op: Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Left_DollarParen '$('>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(printf)} 
                                        {
                                          (DQ ('%') 
                                            (word_part.ArithSub
                                              anode: 
                                                (arith_expr.Binary
                                                  op_id: Arith_Minus
                                                  left: 
                                                    (arith_expr.Binary
                                                      op_id: Arith_Minus
                                                      left: 
                                                        (arith_expr.Binary
                                                          op_id: Arith_Minus
                                                          left: 
                                                            (arith_expr.Binary
                                                              op_id: Arith_Minus
                                                              left: 
                                                                (arith_expr.VarRef
                                                                  token: <Lit_ArithVarLike COLS>
                                                                )
                                                              right: 
                                                                (arith_expr.ArithWord
                                                                  w: {(Lit_Digits 3)}
                                                                )
                                                            )
                                                          right: 
                                                            (arith_expr.ArithWord
                                                              w: 
                                                                {
                                                                  (braced_var_sub
                                                                    token: <VSub_Name RC_INDENTATION>
                                                                    prefix_op: VSub_Pound
                                                                  )
                                                                }
                                                            )
                                                        )
                                                      right: 
                                                        (arith_expr.ArithWord
                                                          w: 
                                                            {
                                                              (braced_var_sub
                                                                token: <VSub_Name msg>
                                                                prefix_op: VSub_Pound
                                                              )
                                                            }
                                                        )
                                                    )
                                                  right: (arith_expr.ArithWord w:{(Lit_Digits 7)})
                                                )
                                            ) (s)
                                          )
                                        } {(SQ )}
                                      )
                                    ]
                                  )
                              )
                            }
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:dots)
                          op: Equal
                          rhs: 
                            {
                              (braced_var_sub
                                token: <VSub_Name dots>
                                suffix_op: 
                                  (suffix_op.PatSub
                                    pat: {(${ VSub_Name spaces)}
                                    replace: {(${ VSub_Name RC_DOT_PATTERN)}
                                    replace_mode: Lit_Slash
                                  )
                              )
                            }
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:msg)
                          op: Equal
                          rhs: {(DQ (${ VSub_Name msg) (${ VSub_Name dots))}
                        )
                      ]
                    )
                  ]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:msg)
                      op: Equal
                      rhs: {(DQ (${ VSub_Name msg) (' ...'))}
                    )
                  ]
                )
              ]
            )
            (C {(einfon)} {(DQ (${ VSub_Name msg))})
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.Binary
                      op_id: BoolBinary_GlobDEqual
                      left: {(${ VSub_Name RC_ENDCOL)}
                      right: {(DQ (yes))}
                    )
                )
                (C {(echo)})
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:LAST_E_LEN)
                  op: Equal
                  rhs: 
                    {
                      (word_part.ArithSub
                        anode: 
                          (arith_expr.Binary
                            op_id: Arith_Plus
                            left: 
                              (arith_expr.Binary
                                op_id: Arith_Plus
                                left: (arith_expr.ArithWord w:{(Lit_Digits 3)})
                                right: 
                                  (arith_expr.ArithWord
                                    w: 
                                      {
                                        (braced_var_sub
                                          token: <VSub_Name RC_INDENTATION>
                                          prefix_op: VSub_Pound
                                        )
                                      }
                                  )
                              )
                            right: 
                              (arith_expr.ArithWord
                                w: {(braced_var_sub token:<VSub_Name msg> prefix_op:VSub_Pound)}
                              )
                          )
                      )
                    }
                )
              ]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:LAST_E_CMD) op:Equal rhs:{(DQ (ebegin))})]
            )
            (command.ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
          ]
        )
    )
    (command.ShFunction
      name: __eend
      body: 
        (command.BraceGroup
          children: [
            (C {(local)} 
              {(Lit_VarLike 'retval=') 
                (braced_var_sub
                  token: <VSub_Number 1>
                  suffix_op: (suffix_op.Unary op_id:VTest_ColonHyphen arg_word:{(0)})
                )
              } 
              {(Lit_VarLike 'efunc=') 
                (braced_var_sub
                  token: <VSub_Number 2>
                  suffix_op: (suffix_op.Unary op_id:VTest_ColonHyphen arg_word:{(eerror)})
                )
              } {(msg)}
            )
            (C {(shift)} {(2)})
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: BoolBinary_GlobDEqual
                              left: {(${ VSub_Name retval)}
                              right: {(DQ (0))}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:msg)
                          op: Equal
                          rhs: 
                            {
                              (DQ (${ VSub_Name BRACKET) ('[ ') (${ VSub_Name GOOD) (ok) 
                                (${ VSub_Name BRACKET) (' ]') (${ VSub_Name NORMAL)
                              )
                            }
                        )
                      ]
                    )
                  ]
                )
              ]
              else_action: [
                (command.If
                  arms: [
                    (if_arm
                      cond: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: (bool_expr.Unary op_id:BoolUnary_n child:{($ VSub_Star '$*')})
                            )
                          terminator: <Op_Semi ';'>
                        )
                      ]
                      action: [(C {(${ VSub_Name efunc)} {(DQ ($ VSub_Star '$*'))})]
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:msg)
                      op: Equal
                      rhs: 
                        {
                          (DQ (${ VSub_Name BRACKET) ('[ ') (${ VSub_Name BAD) ('!!') 
                            (${ VSub_Name BRACKET) (' ]') (${ VSub_Name NORMAL)
                          )
                        }
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: BoolBinary_GlobDEqual
                              left: {(${ VSub_Name RC_ENDCOL)}
                              right: {(DQ (yes))}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [(C {(echo)} {(-e)} {(DQ (${ VSub_Name ENDCOL) (' ') (${ VSub_Name msg))})]
                )
              ]
              else_action: [
                (command.AndOr
                  ops: [Op_DPipe]
                  children: [
                    (command.DBracket
                      expr: 
                        (bool_expr.Binary
                          op_id: BoolBinary_GlobDEqual
                          left: {(${ VSub_Name LAST_E_CMD)}
                          right: {(ebegin)}
                        )
                    )
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:LAST_E_LEN) op:Equal rhs:{(0)})]
                    )
                  ]
                )
                (C {(printf)} 
                  {
                    (DQ ('%') 
                      (word_part.ArithSub
                        anode: 
                          (arith_expr.Binary
                            op_id: Arith_Minus
                            left: 
                              (arith_expr.Binary
                                op_id: Arith_Minus
                                left: (arith_expr.VarRef token:<Lit_ArithVarLike COLS>)
                                right: (arith_expr.VarRef token:<Lit_ArithVarLike LAST_E_LEN>)
                              )
                            right: (arith_expr.ArithWord w:{(Lit_Digits 7)})
                          )
                      ) ('s%b') (Lit_Other '\\') (n)
                    )
                  } {(SQ )} {(DQ (${ VSub_Name msg))}
                )
              ]
            )
            (command.ControlFlow
              token: <ControlFlow_Return return>
              arg_word: {(${ VSub_Name retval)}
            )
          ]
        )
    )
    (command.ShFunction
      name: eend
      body: 
        (command.BraceGroup
          children: [
            (C {(local)} 
              {(Lit_VarLike 'retval=') 
                (braced_var_sub
                  token: <VSub_Number 1>
                  suffix_op: (suffix_op.Unary op_id:VTest_ColonHyphen arg_word:{(0)})
                )
              }
            )
            (C {(shift)})
            (C {(__eend)} {(${ VSub_Name retval)} {(eerror)} {(DQ ($ VSub_Star '$*'))})
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:LAST_E_CMD) op:Equal rhs:{(DQ (eend))})]
            )
            (command.ControlFlow
              token: <ControlFlow_Return return>
              arg_word: {(${ VSub_Name retval)}
            )
          ]
        )
    )
    (command.ShFunction
      name: __unset_colors
      body: 
        (command.BraceGroup
          children: [
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:COLS) op:Equal rhs:{(80)})]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:ENDCOL) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:GOOD) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:WARN) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:BAD) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:NORMAL) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:HILITE) op:Equal rhs:(word.Empty))]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:BRACKET) op:Equal rhs:(word.Empty))]
            )
          ]
        )
    )
    (command.ShFunction
      name: __set_colors
      body: 
        (command.BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:COLS)
                  op: Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <VSub_Name COLUMNS>
                        suffix_op: (suffix_op.Unary op_id:VTest_ColonHyphen arg_word:{(0)})
                      )
                    }
                )
              ]
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.LogicalAnd
                      left: 
                        (bool_expr.Binary
                          op_id: BoolBinary_GlobDEqual
                          left: {($ VSub_DollarName '$COLS')}
                          right: {(0)}
                        )
                      right: 
                        (bool_expr.Binary
                          op_id: BoolBinary_GlobNEqual
                          left: {($ VSub_DollarName '$EBUILD_PHASE')}
                          right: {(depend)}
                        )
                    )
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:COLS)
                      op: Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Left_DollarParen '$('>
                            command_list: 
                              (command.CommandList
                                children: [
                                  (command.Sentence
                                    child: 
                                      (C {(KW_Set set)} {(--)} 
                                        {
                                          (command_sub
                                            left_token: <Left_DollarParen '$('>
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (command.AndOr
                                                    ops: [Op_DPipe]
                                                    children: [
                                                      (command.Subshell
                                                        command_list: 
                                                          (command.CommandList
                                                            children: [
                                                              (command.Simple
                                                                words: [{(stty)} {(size)}]
                                                                redirects: [
                                                                  (redir.Redir
                                                                    op: <Redir_Less '<'>
                                                                    fd: 16777215
                                                                    arg_word: {(/dev/tty)}
                                                                  )
                                                                ]
                                                              )
                                                            ]
                                                          )
                                                        redirects: [
                                                          (redir.Redir
                                                            op: <Redir_Great '2>'>
                                                            fd: 2
                                                            arg_word: {(/dev/null)}
                                                          )
                                                        ]
                                                      )
                                                      (C {(echo)} {(24)} {(80)})
                                                    ]
                                                  )
                                                ]
                                              )
                                          )
                                        }
                                      )
                                    terminator: <Op_Semi ';'>
                                  )
                                  (C {(echo)} {($ VSub_Number '$2')})
                                ]
                              )
                          )
                        }
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (command.DParen
                  child: 
                    (arith_expr.Binary
                      op_id: Arith_Great
                      left: (arith_expr.VarRef token:<Lit_ArithVarLike COLS>)
                      right: (arith_expr.ArithWord w:{(Lit_Digits 0)})
                    )
                )
                (command.DParen
                  child: 
                    (arith_expr.BinaryAssign
                      op_id: Arith_Equal
                      left: (sh_lhs_expr.Name name:COLS)
                      right: (arith_expr.ArithWord w:{(Lit_Digits 80)})
                    )
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:ENDCOL)
                  op: Equal
                  rhs: 
                    {
                      (single_quoted
                        left: <Left_SingleQuoteC "$'">
                        tokens: [
                          <Char_OneChar '\\e'>
                          <Char_Literals '[A'>
                          <Char_OneChar '\\e'>
                          <Char_Literals '['>
                        ]
                      ) 
                      (word_part.ArithSub
                        anode: 
                          (arith_expr.Binary
                            op_id: Arith_Minus
                            left: (arith_expr.VarRef token:<Lit_ArithVarLike COLS>)
                            right: (arith_expr.ArithWord w:{(Lit_Digits 8)})
                          )
                      ) (SQ <C>)
                    }
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(Lit_LBracket '[')} {(-n)} {(DQ (${ VSub_Name PORTAGE_COLORMAP))} 
                          {(Lit_RBracket ']')}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [(C {(eval)} {(${ VSub_Name PORTAGE_COLORMAP)})]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:GOOD)
                      op: Equal
                      rhs: 
                        {
                          (single_quoted
                            left: <Left_SingleQuoteC "$'">
                            tokens: [<Char_OneChar '\\e'> <Char_Literals '[32;01m'>]
                          )
                        }
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:WARN)
                      op: Equal
                      rhs: 
                        {
                          (single_quoted
                            left: <Left_SingleQuoteC "$'">
                            tokens: [<Char_OneChar '\\e'> <Char_Literals '[33;01m'>]
                          )
                        }
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:BAD)
                      op: Equal
                      rhs: 
                        {
                          (single_quoted
                            left: <Left_SingleQuoteC "$'">
                            tokens: [<Char_OneChar '\\e'> <Char_Literals '[31;01m'>]
                          )
                        }
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:HILITE)
                      op: Equal
                      rhs: 
                        {
                          (single_quoted
                            left: <Left_SingleQuoteC "$'">
                            tokens: [<Char_OneChar '\\e'> <Char_Literals '[36;01m'>]
                          )
                        }
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:BRACKET)
                      op: Equal
                      rhs: 
                        {
                          (single_quoted
                            left: <Left_SingleQuoteC "$'">
                            tokens: [<Char_OneChar '\\e'> <Char_Literals '[34;01m'>]
                          )
                        }
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:NORMAL)
                      op: Equal
                      rhs: 
                        {
                          (single_quoted
                            left: <Left_SingleQuoteC "$'">
                            tokens: [<Char_OneChar '\\e'> <Char_Literals '[0m'>]
                          )
                        }
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:RC_ENDCOL) op:Equal rhs:{(DQ (yes))})]
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:RC_INDENTATION) op:Equal rhs:{(SQ )})]
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:RC_DEFAULT_INDENT) op:Equal rhs:{(2)})]
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:RC_DOT_PATTERN) op:Equal rhs:{(SQ )})]
    )
    (command.Case
      to_match: 
        {
          (DQ 
            (braced_var_sub
              token: <VSub_Name NOCOLOR>
              suffix_op: (suffix_op.Unary op_id:VTest_ColonHyphen arg_word:{(false)})
            )
          )
        }
      arms: [
        (case_arm pat_list:[{(yes)} {(true)}] action:[(C {(__unset_colors)})])
        (case_arm pat_list:[{(no)} {(false)}] action:[(C {(__set_colors)})])
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: 
                (command.DBracket
                  expr: (bool_expr.Unary op_id:BoolUnary_z child:{(${ VSub_Name USERLAND)})
                )
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (command.Case
              to_match: 
                {
                  (command_sub
                    left_token: <Left_DollarParen '$('>
                    command_list: (command.CommandList children:[(C {(uname)} {(-s)})])
                  )
                }
              arms: [
                (case_arm
                  pat_list: [{(Lit_Star '*') (BSD)} {(DragonFly)}]
                  action: [(C {(export)} {(Lit_VarLike 'USERLAND=') (DQ (BSD))})]
                )
                (case_arm
                  pat_list: [{(Lit_Star '*')}]
                  action: [(C {(export)} {(Lit_VarLike 'USERLAND=') (DQ (GNU))})]
                )
              ]
            )
          ]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: 
                (command.DBracket
                  expr: (bool_expr.Unary op_id:BoolUnary_z child:{(${ VSub_Name XARGS)})
                )
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (command.Case
              to_match: {(${ VSub_Name USERLAND)}
              arms: [
                (case_arm
                  pat_list: [{(BSD)}]
                  action: [(C {(export)} {(Lit_VarLike 'XARGS=') (DQ (xargs))})]
                )
                (case_arm
                  pat_list: [{(Lit_Star '*')}]
                  action: [(C {(export)} {(Lit_VarLike 'XARGS=') (DQ ('xargs -r'))})]
                )
              ]
            )
          ]
        )
      ]
    )
    (command.ShFunction
      name: hasq
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(has)} {($ VSub_DollarName '$EBUILD_PHASE')} {(prerm)} {(postrm)})
                (C {(eqawarn)} 
                  {(DQ ("QA Notice: The 'hasq' function is deprecated (replaced by 'has')"))}
                )
              ]
            )
            (C {(has)} {(DQ ($ VSub_At '$@'))})
          ]
        )
    )
    (command.ShFunction
      name: hasv
      body: 
        (command.BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: (C {(has)} {(DQ ($ VSub_At '$@'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(echo)} {(DQ ($ VSub_Number '$1'))})
                    (command.ControlFlow
                      token: <ControlFlow_Return return>
                      arg_word: {(0)}
                    )
                  ]
                )
              ]
            )
            (command.ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
          ]
        )
    )
    (command.ShFunction
      name: has
      body: 
        (command.BraceGroup
          children: [
            (C {(local)} {(Lit_VarLike 'needle=') ($ VSub_Number '$1')})
            (C {(shift)})
            (C {(local)} {(x)})
            (command.ForEach
              iter_name: x
              iter_words: [{(DQ ($ VSub_At '$@'))}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(Lit_LBracket '[')} {(DQ (${ VSub_Name x))} {(Lit_Equals '=')} 
                          {(DQ (${ VSub_Name needle))} {(Lit_RBracket ']')}
                        )
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(0)}
                        )
                      ]
                    )
                  ]
                )
            )
            (command.ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
          ]
        )
    )
    (command.ShFunction
      name: __repo_attr
      body: 
        (command.BraceGroup
          children: [
            (C {(local)} {(Lit_VarLike 'appropriate_section=') (0)} {(Lit_VarLike 'exit_status=') (1)} 
              {(line)} 
              {(Lit_VarLike 'saved_extglob_shopt=') 
                (command_sub
                  left_token: <Left_DollarParen '$('>
                  command_list: (command.CommandList children:[(C {(shopt)} {(-p)} {(extglob)})])
                )
              }
            )
            (C {(shopt)} {(-s)} {(extglob)})
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [(command.Sentence child:(C {(read)} {(line)}) terminator:<Op_Semi ';'>)]
              body: 
                (command.DoGroup
                  children: [
                    (command.AndOr
                      ops: [Op_DAmp Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.LogicalAnd
                              left: 
                                (bool_expr.Binary
                                  op_id: BoolBinary_GlobDEqual
                                  left: {(${ VSub_Name appropriate_section)}
                                  right: {(0)}
                                )
                              right: 
                                (bool_expr.Binary
                                  op_id: BoolBinary_GlobDEqual
                                  left: {(${ VSub_Name line)}
                                  right: {(DQ ('[') ($ VSub_Number '$1') (']'))}
                                )
                            )
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:appropriate_section)
                              op: Equal
                              rhs: {(1)}
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <ControlFlow_Continue continue>
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DAmp Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.LogicalAnd
                              left: 
                                (bool_expr.Binary
                                  op_id: BoolBinary_GlobDEqual
                                  left: {(${ VSub_Name appropriate_section)}
                                  right: {(1)}
                                )
                              right: 
                                (bool_expr.Binary
                                  op_id: BoolBinary_GlobDEqual
                                  left: {(${ VSub_Name line)}
                                  right: {(DQ ('[')) (Lit_Other '*') (DQ (']'))}
                                )
                            )
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:appropriate_section)
                              op: Equal
                              rhs: {(0)}
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <ControlFlow_Continue continue>
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.DBracket
                                  expr: 
                                    (bool_expr.LogicalAnd
                                      left: 
                                        (bool_expr.Binary
                                          op_id: BoolBinary_GlobDEqual
                                          left: {(${ VSub_Name appropriate_section)}
                                          right: {(1)}
                                        )
                                      right: 
                                        (bool_expr.Binary
                                          op_id: BoolBinary_EqualTilde
                                          left: {(${ VSub_Name line)}
                                          right: 
                                            {(Lit_Other '^') (${ VSub_Number 2) (Lit_Other '[') 
                                              (Lit_Other '[') (Lit_Other ':') (space) (Lit_Other ':') (Lit_Other ']') (Lit_Other ']') (Lit_Other '*') (Lit_Other '=')
                                            }
                                        )
                                    )
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {(echo)} 
                              {
                                (DQ 
                                  (braced_var_sub
                                    token: <VSub_Name line>
                                    suffix_op: 
                                      (suffix_op.Unary
                                        op_id: VOp1_DPound
                                        arg_word: {($ VSub_Number '$2') ('*( )=*( )')}
                                      )
                                  )
                                )
                              }
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:exit_status)
                                  op: Equal
                                  rhs: {(0)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Break break>
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
              redirects: [
                (redir.Redir
                  op: <Redir_TLess '<<<'>
                  fd: 16777215
                  arg_word: {(DQ (${ VSub_Name PORTAGE_REPOSITORIES))}
                )
              ]
            )
            (C {(eval)} {(DQ (${ VSub_Name saved_extglob_shopt))})
            (command.ControlFlow
              token: <ControlFlow_Return return>
              arg_word: {(${ VSub_Name exit_status)}
            )
          ]
        )
    )
    (command.ShFunction
      name: __eqaquote
      body: 
        (command.BraceGroup
          children: [
            (C {(local)} {(Lit_VarLike 'v=') (${ VSub_Number 1)} {(Lit_VarLike 'esc=') (SQ )})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:v)
                  op: Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <VSub_Name v>
                        suffix_op: 
                          (suffix_op.PatSub
                            pat: {(word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>)}
                            replace: 
                              {(word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) 
                                (word_part.EscapedLiteral
                                  token: <Lit_EscapedChar '\\\\'>
                                )
                              }
                            replace_mode: Lit_Slash
                          )
                      )
                    }
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:v)
                  op: Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <VSub_Name v>
                        suffix_op: 
                          (suffix_op.PatSub
                            pat: {(word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)}
                            replace: 
                              {(word_part.EscapedLiteral token:<Lit_EscapedChar '\\\\'>) 
                                (word_part.EscapedLiteral
                                  token: <Lit_EscapedChar '\\"'>
                                )
                              }
                            replace_mode: Lit_Slash
                          )
                      )
                    }
                )
              ]
            )
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [(command.Sentence child:(C {(read)} {(-r)}) terminator:<Op_Semi ';'>)]
              body: 
                (command.DoGroup
                  children: [
                    (C {(echo)} {(-n)} {(DQ (${ VSub_Name esc) (${ VSub_Name REPLY))})
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:esc) op:Equal rhs:{(SQ <'\\n'>)})]
                    )
                  ]
                )
              redirects: [
                (redir.Redir
                  op: <Redir_TLess '<<<'>
                  fd: 16777215
                  arg_word: {(DQ (${ VSub_Name v))}
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: __eqatag
      body: 
        (command.BraceGroup
          children: [
            (C {(local)} {(tag)} {(i)} 
              {(Lit_VarLike 'filenames=') (sh_array_literal left:<Op_LParen '('>)} {(Lit_VarLike 'data=') (sh_array_literal left:<Op_LParen '('>)} {(Lit_VarLike 'verbose=')}
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: BoolBinary_GlobDEqual
                              left: {(${ VSub_Number 1)}
                              right: {(BoolUnary_v -v)}
                            )
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:verbose) op:Equal rhs:{(1)})]
                    )
                    (C {(shift)})
                  ]
                )
              ]
            )
            (command.ShAssignment
              pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:tag) op:Equal rhs:{(${ VSub_Number 1)})]
            )
            (C {(shift)})
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (command.DBracket
                  expr: (bool_expr.Unary op_id:BoolUnary_n child:{(${ VSub_Name tag)})
                )
                (C {(die)} {(DQ (${ VSub_Name FUNCNAME) (': no tag specified'))})
              ]
            )
            (command.ForEach
              iter_name: i
              do_arg_iter: T
              body: 
                (command.DoGroup
                  children: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: BoolBinary_GlobDEqual
                                      left: {(${ VSub_Name i)}
                                      right: {(/) (Lit_Other '*')}
                                    )
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:filenames)
                                  op: PlusEqual
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: <Op_LParen '('>
                                        words: [{(DQ (${ VSub_Name i))}]
                                      )
                                    }
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Op_DAmp]
                              children: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Unary
                                      op_id: BoolUnary_n
                                      child: {(${ VSub_Name verbose)}
                                    )
                                )
                                (C {(eqawarn)} {(DQ ('  ') (${ VSub_Name i))})
                              ]
                            )
                          ]
                        )
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: BoolBinary_GlobDEqual
                                      left: {(${ VSub_Name i)}
                                      right: 
                                        {(Lit_Other '*') (BoolBinary_GlobEqual '=') (Lit_Other '*')}
                                    )
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:data)
                                  op: PlusEqual
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: <Op_LParen '('>
                                        words: [{(DQ (${ VSub_Name i))}]
                                      )
                                    }
                                )
                              ]
                            )
                          ]
                        )
                      ]
                      else_action: [
                        (C {(die)} 
                          {(DQ (${ VSub_Name FUNCNAME) (': invalid parameter: ') (${ VSub_Name i))}
                        )
                      ]
                    )
                  ]
                )
            )
            (command.Subshell
              command_list: 
                (command.CommandList
                  children: [
                    (C {(echo)} {(DQ ('- tag: ') (${ VSub_Name tag))})
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.DBracket
                                  expr: 
                                    (bool_expr.WordTest
                                      w: 
                                        {
                                          (braced_var_sub
                                            token: <VSub_Name data>
                                            bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                                          )
                                        }
                                    )
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {(echo)} {(DQ ('  data:'))})
                            (command.ForEach
                              iter_name: i
                              iter_words: [
                                {
                                  (DQ 
                                    (braced_var_sub
                                      token: <VSub_Name data>
                                      bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                                    )
                                  )
                                }
                              ]
                              do_arg_iter: F
                              body: 
                                (command.DoGroup
                                  children: [
                                    (C {(echo)} 
                                      {
                                        (DQ ('    ') 
                                          (braced_var_sub
                                            token: <VSub_Name i>
                                            suffix_op: 
                                              (suffix_op.Unary
                                                op_id: VOp1_DPercent
                                                arg_word: {('=*')}
                                              )
                                          ) (': ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>) 
                                          (command_sub
                                            left_token: <Left_DollarParen '$('>
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (C {(__eqaquote)} 
                                                    {
                                                      (DQ 
                                                        (braced_var_sub
                                                          token: <VSub_Name i>
                                                          suffix_op: 
                                                            (suffix_op.Unary
                                                              op_id: VOp1_Pound
                                                              arg_word: {('*=')}
                                                            )
                                                        )
                                                      )
                                                    }
                                                  )
                                                ]
                                              )
                                          ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                                        )
                                      }
                                    )
                                  ]
                                )
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.DBracket
                                  expr: 
                                    (bool_expr.WordTest
                                      w: 
                                        {
                                          (braced_var_sub
                                            token: <VSub_Name filenames>
                                            bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                                          )
                                        }
                                    )
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {(echo)} {(DQ ('  files:'))})
                            (command.ForEach
                              iter_name: i
                              iter_words: [
                                {
                                  (DQ 
                                    (braced_var_sub
                                      token: <VSub_Name filenames>
                                      bracket_op: (bracket_op.WholeArray op_id:Lit_At)
                                    )
                                  )
                                }
                              ]
                              do_arg_iter: F
                              body: 
                                (command.DoGroup
                                  children: [
                                    (C {(echo)} 
                                      {
                                        (DQ ('    - ') 
                                          (word_part.EscapedLiteral
                                            token: <Lit_EscapedChar '\\"'>
                                          ) 
                                          (command_sub
                                            left_token: <Left_DollarParen '$('>
                                            command_list: 
                                              (command.CommandList
                                                children: [(C {(__eqaquote)} {(DQ (${ VSub_Name i))})]
                                              )
                                          ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\"'>)
                                        )
                                      }
                                    )
                                  ]
                                )
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
              redirects: [
                (redir.Redir
                  op: <Redir_DGreat '>>'>
                  fd: 16777215
                  arg_word: {(DQ (${ VSub_Name T)) (/qa.log)}
                )
              ]
            )
          ]
        )
    )
    (C {(true)})
  ]
)