(command.CommandList
  children: [
    (C {<unalias>} {<-a>})
    (C {<unset>} {<BASH_COMPAT>})
    (command.AndOr
      ops: [Id.Op_DPipe]
      children: [
        (C {<source>} {(DQ (${ Id.VSub_Name PORTAGE_BIN_PATH) <'/isolated-functions.sh'>)})
        (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
      ]
    )
    (command.ShFunction
      name: __check_bash_version
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<maj>} {<min>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: (C {<___eapi_bash_3_2>})
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:maj)
                          op: assign_op.Equal
                          rhs: {<3>}
                          spids: [84]
                        )
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:min)
                          op: assign_op.Equal
                          rhs: {<2>}
                          spids: [87]
                        )
                      ]
                    )
                  ]
                  spids: [75 81]
                )
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: (C {<___eapi_bash_4_2>})
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:maj)
                          op: assign_op.Equal
                          rhs: {<4>}
                          spids: [100]
                        )
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:min)
                          op: assign_op.Equal
                          rhs: {<2>}
                          spids: [103]
                        )
                      ]
                    )
                  ]
                  spids: [91 97]
                )
              ]
              else_action: [(command.ControlFlow token:<Id.ControlFlow_Return return>)]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_lt
                                      left: 
                                        {
                                          (braced_var_sub
                                            token: <Id.VSub_Name BASH_VERSINFO>
                                            bracket_op: 
                                              (bracket_op.ArrayIndex
                                                expr: {<Id.Lit_Digits 0>}
                                              )
                                          )
                                        }
                                      right: {(${ Id.VSub_Name maj)}
                                    )
                                )
                                (command.DBracket
                                  expr: 
                                    (bool_expr.LogicalAnd
                                      left: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_eq
                                          left: 
                                            {
                                              (braced_var_sub
                                                token: <Id.VSub_Name BASH_VERSINFO>
                                                bracket_op: 
                                                  (bracket_op.ArrayIndex
                                                    expr: {<Id.Lit_Digits 0>}
                                                  )
                                              )
                                            }
                                          right: {(${ Id.VSub_Name maj)}
                                        )
                                      right: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_lt
                                          left: 
                                            {
                                              (braced_var_sub
                                                token: <Id.VSub_Name BASH_VERSINFO>
                                                bracket_op: 
                                                  (bracket_op.ArrayIndex
                                                    expr: {<Id.Lit_Digits 1>}
                                                  )
                                              )
                                            }
                                          right: {(${ Id.VSub_Name min)}
                                        )
                                    )
                                )
                              ]
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<die>} 
                      {
                        (DQ <'>=bash-'> (${ Id.VSub_Name maj) <.> (${ Id.VSub_Name min) <' is required'>)
                      }
                    )
                  ]
                  spids: [121 177]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:BASH_COMPAT)
                  op: assign_op.Equal
                  rhs: {(DQ (${ Id.VSub_Name maj) <.> (${ Id.VSub_Name min))}
                  spids: [211]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<___eapi_bash_3_2>})
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_gt
                                      left: 
                                        {
                                          (braced_var_sub
                                            token: <Id.VSub_Name BASH_VERSINFO>
                                            bracket_op: 
                                              (bracket_op.ArrayIndex
                                                expr: {<Id.Lit_Digits 0>}
                                              )
                                          )
                                        }
                                      right: {<3>}
                                    )
                                )
                              ]
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<shopt>} {<-s>} {<compat32>})]
                  spids: [252 275]
                )
              ]
            )
          ]
        )
    )
    (C {<__check_bash_version>})
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (command.DBracket
                      expr: 
                        (bool_expr.Binary
                          op_id: Id.BoolBinary_GlobNEqual
                          left: {($ Id.VSub_DollarName '$EBUILD_PHASE')}
                          right: {<depend>}
                        )
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<source>} {(DQ (${ Id.VSub_Name PORTAGE_BIN_PATH) <'/phase-functions.sh'>)})
                (C {<die>})
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<source>} {(DQ (${ Id.VSub_Name PORTAGE_BIN_PATH) <'/save-ebuild-env.sh'>)})
                (C {<die>})
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<source>} {(DQ (${ Id.VSub_Name PORTAGE_BIN_PATH) <'/phase-helpers.sh'>)})
                (C {<die>})
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<source>} {(DQ (${ Id.VSub_Name PORTAGE_BIN_PATH) <'/bashrc-functions.sh'>)})
                (C {<die>})
              ]
            )
          ]
          spids: [292 306]
        )
      ]
      else_action: [
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:funcs)
              op: assign_op.Equal
              rhs: 
                {
                  (DQ <'diropts docompress exeopts get_KV insopts\n'> 
                    <'\t\tKV_major KV_micro KV_minor KV_to_int\n'> <'\t\tlibopts register_die_hook register_success_hook\n'> <'\t\t__strip_duplicate_slashes\n'> 
                    <'\t\tuse useq usev use_with use_enable'>
                  )
                }
              spids: [379]
            )
          ]
        )
        (command.AndOr
          ops: [Id.Op_DAmp]
          children: [
            (C {<___eapi_has_usex>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:funcs)
                  op: assign_op.PlusEqual
                  rhs: {(DQ <' usex'>)}
                  spids: [393]
                )
              ]
            )
          ]
        )
        (command.AndOr
          ops: [Id.Op_DAmp]
          children: [
            (C {<___eapi_has_in_iuse>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:funcs)
                  op: assign_op.PlusEqual
                  rhs: {(DQ <' in_iuse'>)}
                  spids: [403]
                )
              ]
            )
          ]
        )
        (command.AndOr
          ops: [Id.Op_DAmp]
          children: [
            (C {<___eapi_has_get_libdir>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:funcs)
                  op: assign_op.PlusEqual
                  rhs: {(DQ <' get_libdir'>)}
                  spids: [413]
                )
              ]
            )
          ]
        )
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:funcs)
              op: assign_op.PlusEqual
              rhs: {(DQ <' best_version has_version portageq'>)}
              spids: [427]
            )
          ]
        )
        (command.AndOr
          ops: [Id.Op_DAmp]
          children: [
            (C {<___eapi_has_master_repositories>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:funcs)
                  op: assign_op.PlusEqual
                  rhs: {(DQ <' master_repositories'>)}
                  spids: [437]
                )
              ]
            )
          ]
        )
        (command.AndOr
          ops: [Id.Op_DAmp]
          children: [
            (C {<___eapi_has_repository_path>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:funcs)
                  op: assign_op.PlusEqual
                  rhs: {(DQ <' repository_path'>)}
                  spids: [447]
                )
              ]
            )
          ]
        )
        (command.AndOr
          ops: [Id.Op_DAmp]
          children: [
            (C {<___eapi_has_available_eclasses>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:funcs)
                  op: assign_op.PlusEqual
                  rhs: {(DQ <' available_eclasses'>)}
                  spids: [457]
                )
              ]
            )
          ]
        )
        (command.AndOr
          ops: [Id.Op_DAmp]
          children: [
            (C {<___eapi_has_eclass_path>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:funcs)
                  op: assign_op.PlusEqual
                  rhs: {(DQ <' eclass_path'>)}
                  spids: [467]
                )
              ]
            )
          ]
        )
        (command.AndOr
          ops: [Id.Op_DAmp]
          children: [
            (C {<___eapi_has_license_path>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:funcs)
                  op: assign_op.PlusEqual
                  rhs: {(DQ <' license_path'>)}
                  spids: [477]
                )
              ]
            )
          ]
        )
        (command.ForEach
          iter_name: x
          iter_words: [{(${ Id.VSub_Name funcs)}]
          do_arg_iter: F
          body: 
            (command.DoGroup
              children: [
                (C {<eval>} 
                  {
                    (DQ (${ Id.VSub_Name x) <'() { die '> 
                      (word_part.EscapedLiteral
                        token: <Id.Lit_EscapedChar '\\"'>
                      ) (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) 
                      <'{FUNCNAME}() calls are not allowed in global scope'> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) <'; }'>
                    )
                  }
                )
              ]
            )
        )
        (C {<unset>} {<funcs>} {<x>})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:_PORTAGE_ORIG_PATH)
              op: assign_op.Equal
              rhs: {(${ Id.VSub_Name PATH)}
              spids: [532]
            )
          ]
        )
        (C {<export>} {<Id.Lit_VarLike 'PATH='> <'/dev/null'>})
        (command.ShFunction
          name: command_not_found_handle
          body: 
            (BraceGroup
              children: [
                (C {<die>} 
                  {
                    (DQ <'External commands disallowed while sourcing ebuild: '> (${ Id.VSub_Star '*'))
                  }
                )
              ]
            )
        )
      ]
    )
    (C {<unset>} {<BASH_ENV>})
    (C {<export>} 
      {<Id.Lit_VarLike 'PORTAGE_BZIP2_COMMAND='> 
        (braced_var_sub
          token: <Id.VSub_Name PORTAGE_BZIP2_COMMAND>
          suffix_op: (suffix_op.Unary op_id:Id.VTest_ColonHyphen arg_word:{<bzip2>})
        )
      }
    )
    (command.ShFunction
      name: __qa_source
      body: 
        (BraceGroup
          children: [
            (C {<local>} 
              {<Id.Lit_VarLike 'shopts='> 
                (command_sub left_token:<Id.Left_DollarParen '$('> child:(C {<shopt>}))
              } {<Id.Lit_VarLike 'OLDIFS='> (DQ ($ Id.VSub_DollarName '$IFS'))}
            )
            (C {<local>} {<retval>})
            (C {<source>} {(DQ ($ Id.VSub_At '$@'))})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:retval)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_QMark '$?')}
                  spids: [648]
                )
              ]
            )
            (C {<Id.KW_Set set>} {<Id.Lit_Other '+'> <e>})
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.Binary
                      op_id: Id.BoolBinary_GlobNEqual
                      left: {($ Id.VSub_DollarName '$shopts')}
                      right: {(command_sub left_token:<Id.Left_DollarParen '$('> child:(C {<shopt>}))}
                    )
                )
                (C {<eqawarn>} 
                  {
                    (DQ 
                      <
'QA Notice: Global shell options changed and were not restored while sourcing \''
                      > ($ Id.VSub_Star '$*') <'\''>
                    )
                  }
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.Binary
                      op_id: Id.BoolBinary_GlobNEqual
                      left: {(DQ ($ Id.VSub_DollarName '$IFS'))}
                      right: {(DQ ($ Id.VSub_DollarName '$OLDIFS'))}
                    )
                )
                (C {<eqawarn>} 
                  {
                    (DQ <'QA Notice: Global IFS changed and was not restored while sourcing \''> 
                      ($ Id.VSub_Star '$*') <'\''>
                    )
                  }
                )
              ]
            )
            (command.ControlFlow
              token: <Id.ControlFlow_Return return>
              arg_word: {($ Id.VSub_DollarName '$retval')}
            )
          ]
        )
    )
    (command.ShFunction
      name: __qa_call
      body: 
        (BraceGroup
          children: [
            (C {<local>} 
              {<Id.Lit_VarLike 'shopts='> 
                (command_sub left_token:<Id.Left_DollarParen '$('> child:(C {<shopt>}))
              } {<Id.Lit_VarLike 'OLDIFS='> (DQ ($ Id.VSub_DollarName '$IFS'))}
            )
            (C {<local>} {<retval>})
            (C {(DQ ($ Id.VSub_At '$@'))})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:retval)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_QMark '$?')}
                  spids: [745]
                )
              ]
            )
            (C {<Id.KW_Set set>} {<Id.Lit_Other '+'> <e>})
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.Binary
                      op_id: Id.BoolBinary_GlobNEqual
                      left: {($ Id.VSub_DollarName '$shopts')}
                      right: {(command_sub left_token:<Id.Left_DollarParen '$('> child:(C {<shopt>}))}
                    )
                )
                (C {<eqawarn>} 
                  {
                    (DQ 
                      <
'QA Notice: Global shell options changed and were not restored while calling \''
                      > ($ Id.VSub_Star '$*') <'\''>
                    )
                  }
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.Binary
                      op_id: Id.BoolBinary_GlobNEqual
                      left: {(DQ ($ Id.VSub_DollarName '$IFS'))}
                      right: {(DQ ($ Id.VSub_DollarName '$OLDIFS'))}
                    )
                )
                (C {<eqawarn>} 
                  {
                    (DQ <'QA Notice: Global IFS changed and was not restored while calling \''> 
                      ($ Id.VSub_Star '$*') <'\''>
                    )
                  }
                )
              ]
            )
            (command.ControlFlow
              token: <Id.ControlFlow_Return return>
              arg_word: {($ Id.VSub_DollarName '$retval')}
            )
          ]
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:EBUILD_SH_ARGS)
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_Star '$*'))}
          spids: [812]
        )
      ]
    )
    (C {<shift>} {($ Id.VSub_Pound '$#')})
    (C {<unset>} {<GZIP>} {<BZIP>} {<BZIP2>} {<CDPATH>} {<GREP_OPTIONS>} {<GREP_COLOR>} {<GLOBIGNORE>})
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (command.DBracket
          expr: 
            (bool_expr.Binary
              op_id: Id.BoolBinary_GlobNEqual
              left: {($ Id.VSub_DollarName '$PORTAGE_QUIET')}
              right: {(DQ )}
            )
        )
        (C {<export>} {<PORTAGE_QUIET>})
      ]
    )
    (command.ShFunction
      name: __sb_append_var
      body: 
        (BraceGroup
          children: [
            (command.Sentence
              child: (C {<local>} {<Id.Lit_VarLike '_v='> ($ Id.VSub_Number '$1')})
              terminator: <Id.Op_Semi _>
            )
            (C {<shift>})
            (C {<local>} {<Id.Lit_VarLike 'var='> (DQ <SANDBOX_> (${ Id.VSub_Name _v))})
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.LogicalOr
                      left: (bool_expr.Unary op_id:Id.BoolUnary_z child:{($ Id.VSub_Number '$1')})
                      right: (bool_expr.Unary op_id:Id.BoolUnary_n child:{($ Id.VSub_Number '$2')})
                    )
                )
                (C {<die>} 
                  {
                    (DQ <'Usage: add'> 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (command.Simple
                            words: [{<tr>} {(DQ <'[:upper:]'>)} {(DQ <'[:lower:]'>)}]
                            redirects: [
                              (redir
                                op: <Id.Redir_TLess '<<<'>
                                loc: (redir_loc.Fd fd:0)
                                arg: {(DQ (${ Id.VSub_Name _v))}
                              )
                            ]
                            more_env: [(env_pair name:LC_ALL val:{<C>} spids:[913])]
                            do_fork: T
                          )
                      ) <' <colon-delimited list of paths>'>
                    )
                  }
                )
              ]
            )
            (C {<export>} 
              {(${ Id.VSub_Name var) <Id.Lit_Equals '='> 
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name var>
                    prefix_op: (Id.VSub_Bang)
                    suffix_op: 
                      (suffix_op.Unary
                        op_id: Id.VTest_ColonPlus
                        arg_word: 
                          {(braced_var_sub token:<Id.VSub_Name var> prefix_op:(Id.VSub_Bang)) <':'>}
                      )
                  ) ($ Id.VSub_Number '$1')
                )
              }
            )
          ]
        )
    )
    (command.ShFunction
      name: addread
      body: 
        (BraceGroup
          children: [
            (command.Sentence
              child: (C {<__sb_append_var>} {<READ>} {(DQ ($ Id.VSub_At '$@'))})
              terminator: <Id.Op_Semi _>
            )
          ]
        )
    )
    (command.ShFunction
      name: addwrite
      body: 
        (BraceGroup
          children: [
            (command.Sentence
              child: (C {<__sb_append_var>} {<WRITE>} {(DQ ($ Id.VSub_At '$@'))})
              terminator: <Id.Op_Semi _>
            )
          ]
        )
    )
    (command.ShFunction
      name: adddeny
      body: 
        (BraceGroup
          children: [
            (command.Sentence
              child: (C {<__sb_append_var>} {<DENY>} {(DQ ($ Id.VSub_At '$@'))})
              terminator: <Id.Op_Semi _>
            )
          ]
        )
    )
    (command.ShFunction
      name: addpredict
      body: 
        (BraceGroup
          children: [
            (command.Sentence
              child: (C {<__sb_append_var>} {<PREDICT>} {(DQ ($ Id.VSub_At '$@'))})
              terminator: <Id.Op_Semi _>
            )
          ]
        )
    )
    (C {<addwrite>} {(DQ (${ Id.VSub_Name PORTAGE_TMPDIR))})
    (C {<addread>} {(DQ <'/:'> (${ Id.VSub_Name PORTAGE_TMPDIR))})
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (command.DBracket
          expr: (bool_expr.Unary op_id:Id.BoolUnary_n child:{(${ Id.VSub_Name PORTAGE_GPG_DIR)})
        )
        (C {<addpredict>} {(DQ (${ Id.VSub_Name PORTAGE_GPG_DIR))})
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (command.DBracket
                      expr: (bool_expr.Unary op_id:Id.BoolUnary_w child:{($ Id.VSub_DollarName '$T')})
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (C {<export>} {<Id.Lit_VarLike 'TEMP='> ($ Id.VSub_DollarName '$T')})
            (C {<export>} {<Id.Lit_VarLike 'TMP='> ($ Id.VSub_DollarName '$T')})
            (C {<export>} {<Id.Lit_VarLike 'TMPDIR='> ($ Id.VSub_DollarName '$T')})
          ]
          spids: [1083 1095]
        )
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (command.DBracket
                      expr: 
                        (bool_expr.Binary
                          op_id: Id.BoolBinary_GlobEqual
                          left: {($ Id.VSub_DollarName '$SANDBOX_ON')}
                          right: {<1>}
                        )
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.ForEach
              iter_name: x
              iter_words: [{<TEMP>} {<TMP>} {<TMPDIR>}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_n
                              child: {(braced_var_sub token:<Id.VSub_Name x> prefix_op:(Id.VSub_Bang))}
                            )
                        )
                        (C {<addwrite>} 
                          {(DQ (braced_var_sub token:<Id.VSub_Name x> prefix_op:(Id.VSub_Bang)))}
                        )
                      ]
                    )
                  ]
                )
            )
            (C {<unset>} {<x>})
          ]
          spids: [1115 1129]
        )
      ]
    )
    (C {<export>} {<Id.Lit_VarLike 'SANDBOX_ON='> <0>})
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (command.DBracket
                      expr: (bool_expr.Unary op_id:Id.BoolUnary_d child:{(${ Id.VSub_Name HOME)})
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [(C {<cd>} {(DQ (${ Id.VSub_Name HOME))}) (C {<die>})]
            )
          ]
          spids: [1200 1213]
        )
      ]
      else_action: [
        (command.AndOr
          ops: [Id.Op_DPipe]
          children: [
            (C {<cd>} {(DQ (${ Id.VSub_Name PORTAGE_PYM_PATH))})
            (C {<die>} 
              {(DQ <'PORTAGE_PYM_PATH does not exist: \''> (${ Id.VSub_Name PORTAGE_PYM_PATH) <'\''>)}
            )
          ]
        )
      ]
    )
    (C {<umask>} {<022>})
    (command.ShFunction
      name: debug-print
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.LogicalOr
                      left: 
                        (bool_expr.Binary
                          op_id: Id.BoolBinary_GlobEqual
                          left: {($ Id.VSub_DollarName '$EBUILD_PHASE')}
                          right: {<depend>}
                        )
                      right: 
                        (bool_expr.LogicalOr
                          left: 
                            (bool_expr.LogicalNot
                              child: (bool_expr.Unary op_id:Id.BoolUnary_d child:{(${ Id.VSub_Name T)})
                            )
                          right: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_eq
                              left: {(${ Id.VSub_Pound '#')}
                              right: {<0>}
                            )
                        )
                    )
                )
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {<0>}
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: {(${ Id.VSub_Name ECLASS_DEBUG_OUTPUT)}
                                  right: {<on>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.Simple
                      words: [{<printf>} {(SQ <'debug: %s\\n'>)} {(DQ (${ Id.VSub_At '@'))}]
                      redirects: [(redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
                      do_fork: T
                    )
                  ]
                  spids: [1349 1364]
                )
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_n
                                  child: {(${ Id.VSub_Name ECLASS_DEBUG_OUTPUT)}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.Simple
                      words: [{<printf>} {(SQ <'debug: %s\\n'>)} {(DQ (${ Id.VSub_At '@'))}]
                      redirects: [
                        (redir
                          op: <Id.Redir_DGreat '>>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(DQ (${ Id.VSub_Name ECLASS_DEBUG_OUTPUT))}
                        )
                      ]
                      do_fork: T
                    )
                  ]
                  spids: [1383 1396]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_w
                                  child: {($ Id.VSub_DollarName '$T')}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.Simple
                      words: [{<printf>} {(SQ <'%s\\n'>)} {(DQ (${ Id.VSub_At '@'))}]
                      redirects: [
                        (redir
                          op: <Id.Redir_DGreat '>>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(DQ (${ Id.VSub_Name T) <'/eclass-debug.log'>)}
                        )
                      ]
                      do_fork: T
                    )
                    (C {<chgrp>} 
                      {
                        (DQ 
                          (braced_var_sub
                            token: <Id.VSub_Name PORTAGE_GRPNAME>
                            suffix_op: 
                              (suffix_op.Unary
                                op_id: Id.VTest_ColonHyphen
                                arg_word: {<portage>}
                              )
                          )
                        )
                      } {(DQ (${ Id.VSub_Name T) <'/eclass-debug.log'>)}
                    )
                    (C {<chmod>} {<g> <Id.Lit_Other '+'> <w>} 
                      {(DQ (${ Id.VSub_Name T) <'/eclass-debug.log'>)}
                    )
                  ]
                  spids: [1424 1436]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: debug-print-function
      body: 
        (BraceGroup
          children: [
            (C {<debug-print>} 
              {
                (DQ (${ Id.VSub_Number 1) <': entering function, parameters: '> 
                  (braced_var_sub
                    token: <Id.VSub_Star '*'>
                    suffix_op: (suffix_op.Slice begin:{<Id.Lit_Digits 2>})
                  )
                )
              }
            )
          ]
        )
    )
    (command.ShFunction
      name: debug-print-section
      body: 
        (BraceGroup
          children: [(C {<debug-print>} {(DQ <'now in section '> (${ Id.VSub_Star '*'))})]
        )
    )
    (C {<declare>} {<-ix>} {<Id.Lit_VarLike 'ECLASS_DEPTH='> <0>})
    (command.ShFunction
      name: inherit
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:ECLASS_DEPTH)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (word_part.ArithSub
                        anode: 
                          (arith_expr.Binary
                            op_id: Id.Arith_Plus
                            left: {($ Id.VSub_DollarName '$ECLASS_DEPTH')}
                            right: {<Id.Lit_Digits 1>}
                          )
                      )
                    }
                  spids: [1570]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.Op_Great
                                  left: {(${ Id.VSub_Name ECLASS_DEPTH)}
                                  right: {<1>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<debug-print>} 
                      {
                        (DQ <'*** Multiple Inheritence (Level: '> (${ Id.VSub_Name ECLASS_DEPTH) <')'>)
                      }
                    )
                  ]
                  spids: [1581 1596]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.LogicalAnd
                                  left: 
                                    (bool_expr.Unary
                                      op_id: Id.BoolUnary_n
                                      child: {($ Id.VSub_DollarName '$ECLASS')}
                                    )
                                  right: 
                                    (bool_expr.Unary
                                      op_id: Id.BoolUnary_n
                                      child: 
                                        {
                                          (braced_var_sub
                                            token: <Id.VSub_Name __export_funcs_var>
                                            prefix_op: (Id.VSub_Bang)
                                          )
                                        }
                                    )
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.Pipeline
                      children: [
                        (C {<echo>} {(DQ <'QA Notice: EXPORT_FUNCTIONS is called before inherit in'>)} 
                          {
                            (DQ ($ Id.VSub_DollarName '$ECLASS') 
                              <'.eclass. For compatibility with <=portage-2.1.6.7,'>
                            )
                          } {(DQ <'only call EXPORT_FUNCTIONS after inherit(s).'>)}
                        )
                        (C {<fmt>} {<-w>} {<75>})
                        (command.WhileUntil
                          keyword: <Id.KW_While while>
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: (C {<read>} {<-r>})
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          body: 
                            (command.DoGroup
                              children: [
                                (command.Sentence
                                  child: (C {<eqawarn>} {(DQ ($ Id.VSub_DollarName '$REPLY'))})
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                        )
                      ]
                      negated: F
                    )
                  ]
                  spids: [1614 1635]
                )
              ]
            )
            (C {<local>} {<repo_location>})
            (C {<local>} {<location>})
            (C {<local>} {<potential_location>})
            (C {<local>} {<x>})
            (C {<local>} {<Id.Lit_VarLike 'PECLASS='> ($ Id.VSub_DollarName '$ECLASS')})
            (C {<local>} 
              {<Id.Lit_VarLike 'prev_export_funcs_var='> ($ Id.VSub_DollarName '$__export_funcs_var')}
            )
            (C {<local>} {<B_IUSE>})
            (C {<local>} {<B_REQUIRED_USE>})
            (C {<local>} {<B_DEPEND>})
            (C {<local>} {<B_RDEPEND>})
            (C {<local>} {<B_PDEPEND>})
            (C {<local>} {<B_HDEPEND>})
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: 
                        (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_Number '$1'))} 
                          {<Id.Lit_RBracket ']'>}
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:location)
                          op: assign_op.Equal
                          rhs: {(DQ )}
                          spids: [1776]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:potential_location)
                          op: assign_op.Equal
                          rhs: {(DQ )}
                          spids: [1781]
                        )
                      ]
                    )
                    (C {<export>} {<Id.Lit_VarLike 'ECLASS='> (DQ ($ Id.VSub_Number '$1'))})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:__export_funcs_var)
                          op: assign_op.Equal
                          rhs: {<__export_functions_> ($ Id.VSub_DollarName '$ECLASS_DEPTH')}
                          spids: [1795]
                        )
                      ]
                    )
                    (C {<unset>} {($ Id.VSub_DollarName '$__export_funcs_var')})
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.LogicalAnd
                                      left: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobNEqual
                                          left: {(${ Id.VSub_Name EBUILD_PHASE)}
                                          right: {<depend>}
                                        )
                                      right: 
                                        (bool_expr.LogicalAnd
                                          left: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobNEqual
                                              left: {(${ Id.VSub_Name EBUILD_PHASE)}
                                              right: {<nofetch>}
                                            )
                                          right: 
                                            (bool_expr.LogicalAnd
                                              left: 
                                                (bool_expr.Binary
                                                  op_id: Id.BoolBinary_GlobNEqual
                                                  left: {(${ Id.VSub_Name EBUILD_PHASE)}
                                                  right: {<Id.Lit_Other '*'> <rm>}
                                                )
                                              right: 
                                                (bool_expr.LogicalAnd
                                                  left: 
                                                    (bool_expr.Binary
                                                      op_id: Id.BoolBinary_GlobNEqual
                                                      left: {(${ Id.VSub_Name EMERGE_FROM)}
                                                      right: {(DQ <binary>)}
                                                    )
                                                  right: 
                                                    (bool_expr.Unary
                                                      op_id: Id.BoolUnary_z
                                                      child: {(${ Id.VSub_Name _IN_INSTALL_QA_CHECK)}
                                                    )
                                                )
                                            )
                                        )
                                    )
                                )
                              ]
                            )
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (command.Pipeline
                                              children: [
                                                (C {<has>} {($ Id.VSub_DollarName '$ECLASS')} 
                                                  {($ Id.VSub_DollarName '$INHERITED')} {($ Id.VSub_DollarName '$__INHERITED_QA_CACHE')}
                                                )
                                              ]
                                              negated: T
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (C {<eqawarn>} 
                                      {
                                        (DQ <'QA Notice: ECLASS \''> ($ Id.VSub_DollarName '$ECLASS') 
                                          <'\' inherited illegally in '> ($ Id.VSub_DollarName '$CATEGORY') <'/'> ($ Id.VSub_DollarName '$PF') <' '> 
                                          ($ Id.VSub_DollarName '$EBUILD_PHASE')
                                        )
                                      }
                                    )
                                  ]
                                  spids: [1893 1907]
                                )
                              ]
                            )
                          ]
                          spids: [1806 1866]
                        )
                      ]
                    )
                    (command.ForEach
                      iter_name: repo_location
                      iter_words: [
                        {
                          (DQ 
                            (braced_var_sub
                              token: <Id.VSub_Name PORTAGE_ECLASS_LOCATIONS>
                              bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                            )
                          )
                        }
                      ]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:potential_location)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ (${ Id.VSub_Name repo_location) <'/eclass/'> 
                                        (${ Id.VSub_Number 1) <.eclass>
                                      )
                                    }
                                  spids: [1950]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (command.DBracket
                                              expr: 
                                                (bool_expr.Unary
                                                  op_id: Id.BoolUnary_f
                                                  child: {(${ Id.VSub_Name potential_location)}
                                                )
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:location)
                                          op: assign_op.Equal
                                          rhs: {(DQ (${ Id.VSub_Name potential_location))}
                                          spids: [1979]
                                        )
                                      ]
                                    )
                                    (C {<debug-print>} 
                                      {(DQ <'  eclass exists: '> (${ Id.VSub_Name location))}
                                    )
                                    (command.ControlFlow
                                      token: <Id.ControlFlow_Break break>
                                    )
                                  ]
                                  spids: [1963 1976]
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (C {<debug-print>} 
                      {
                        (DQ <'inherit: '> ($ Id.VSub_Number '$1') <' -> '> 
                          ($ Id.VSub_DollarName '$location')
                        )
                      }
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_z
                              child: {(${ Id.VSub_Name location)}
                            )
                        )
                        (C {<die>} 
                          {(DQ (${ Id.VSub_Number 1) <'.eclass could not be found by inherit()'>)}
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_z
                                          child: {(${ Id.VSub_Name _IN_INSTALL_QA_CHECK)}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<Id.KW_Set set>} {<-f>})
                            (C {<unset>} {<B_IUSE>} {<B_REQUIRED_USE>} {<B_DEPEND>} {<B_RDEPEND>} 
                              {<B_PDEPEND>} {<B_HDEPEND>}
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<Id.Lit_LBracket '['>} 
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name IUSE>
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op_id: Id.VTest_Plus
                                            arg_word: {<set>}
                                          )
                                      )
                                    )
                                  } {<Id.Lit_Equals '='>} {<Id.KW_Set set>} {<Id.Lit_RBracket ']'>}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:B_IUSE)
                                      op: assign_op.Equal
                                      rhs: {(DQ (${ Id.VSub_Name IUSE))}
                                      spids: [2115]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<Id.Lit_LBracket '['>} 
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name REQUIRED_USE>
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op_id: Id.VTest_Plus
                                            arg_word: {<set>}
                                          )
                                      )
                                    )
                                  } {<Id.Lit_Equals '='>} {<Id.KW_Set set>} {<Id.Lit_RBracket ']'>}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:B_REQUIRED_USE)
                                      op: assign_op.Equal
                                      rhs: {(DQ (${ Id.VSub_Name REQUIRED_USE))}
                                      spids: [2141]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<Id.Lit_LBracket '['>} 
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name DEPEND>
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op_id: Id.VTest_Plus
                                            arg_word: {<set>}
                                          )
                                      )
                                    )
                                  } {<Id.Lit_Equals '='>} {<Id.KW_Set set>} {<Id.Lit_RBracket ']'>}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:B_DEPEND)
                                      op: assign_op.Equal
                                      rhs: {(DQ (${ Id.VSub_Name DEPEND))}
                                      spids: [2167]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<Id.Lit_LBracket '['>} 
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name RDEPEND>
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op_id: Id.VTest_Plus
                                            arg_word: {<set>}
                                          )
                                      )
                                    )
                                  } {<Id.Lit_Equals '='>} {<Id.KW_Set set>} {<Id.Lit_RBracket ']'>}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:B_RDEPEND)
                                      op: assign_op.Equal
                                      rhs: {(DQ (${ Id.VSub_Name RDEPEND))}
                                      spids: [2193]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<Id.Lit_LBracket '['>} 
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name PDEPEND>
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op_id: Id.VTest_Plus
                                            arg_word: {<set>}
                                          )
                                      )
                                    )
                                  } {<Id.Lit_Equals '='>} {<Id.KW_Set set>} {<Id.Lit_RBracket ']'>}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:B_PDEPEND)
                                      op: assign_op.Equal
                                      rhs: {(DQ (${ Id.VSub_Name PDEPEND))}
                                      spids: [2219]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<Id.Lit_LBracket '['>} 
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name HDEPEND>
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op_id: Id.VTest_Plus
                                            arg_word: {<set>}
                                          )
                                      )
                                    )
                                  } {<Id.Lit_Equals '='>} {<Id.KW_Set set>} {<Id.Lit_RBracket ']'>}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:B_HDEPEND)
                                      op: assign_op.Equal
                                      rhs: {(DQ (${ Id.VSub_Name HDEPEND))}
                                      spids: [2245]
                                    )
                                  ]
                                )
                              ]
                            )
                            (C {<unset>} {<IUSE>} {<REQUIRED_USE>} {<DEPEND>} {<RDEPEND>} {<PDEPEND>} 
                              {<HDEPEND>}
                            )
                            (C {<Id.KW_Set set>} {<Id.Lit_Other '+'> <f>})
                          ]
                          spids: [2043 2056]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<__qa_source>} {(DQ ($ Id.VSub_DollarName '$location'))})
                        (C {<die>} 
                          {
                            (DQ <'died sourcing '> ($ Id.VSub_DollarName '$location') <' in inherit()'>)
                          }
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_z
                                          child: {(${ Id.VSub_Name _IN_INSTALL_QA_CHECK)}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<Id.KW_Set set>} {<-f>})
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<Id.Lit_LBracket '['>} 
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name IUSE>
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op_id: Id.VTest_Plus
                                            arg_word: {<set>}
                                          )
                                      )
                                    )
                                  } {<Id.Lit_Equals '='>} {<Id.KW_Set set>} {<Id.Lit_RBracket ']'>}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:E_IUSE)
                                      op: assign_op.PlusEqual
                                      rhs: 
                                        {
                                          (DQ 
                                            (braced_var_sub
                                              token: <Id.VSub_Name E_IUSE>
                                              suffix_op: 
                                                (suffix_op.Unary
                                                  op_id: Id.VTest_ColonPlus
                                                  arg_word: {<' '>}
                                                )
                                            ) (${ Id.VSub_Name IUSE)
                                          )
                                        }
                                      spids: [2353]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<Id.Lit_LBracket '['>} 
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name REQUIRED_USE>
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op_id: Id.VTest_Plus
                                            arg_word: {<set>}
                                          )
                                      )
                                    )
                                  } {<Id.Lit_Equals '='>} {<Id.KW_Set set>} {<Id.Lit_RBracket ']'>}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:E_REQUIRED_USE)
                                      op: assign_op.PlusEqual
                                      rhs: 
                                        {
                                          (DQ 
                                            (braced_var_sub
                                              token: <Id.VSub_Name E_REQUIRED_USE>
                                              suffix_op: 
                                                (suffix_op.Unary
                                                  op_id: Id.VTest_ColonPlus
                                                  arg_word: {<' '>}
                                                )
                                            ) (${ Id.VSub_Name REQUIRED_USE)
                                          )
                                        }
                                      spids: [2384]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<Id.Lit_LBracket '['>} 
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name DEPEND>
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op_id: Id.VTest_Plus
                                            arg_word: {<set>}
                                          )
                                      )
                                    )
                                  } {<Id.Lit_Equals '='>} {<Id.KW_Set set>} {<Id.Lit_RBracket ']'>}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:E_DEPEND)
                                      op: assign_op.PlusEqual
                                      rhs: 
                                        {
                                          (DQ 
                                            (braced_var_sub
                                              token: <Id.VSub_Name E_DEPEND>
                                              suffix_op: 
                                                (suffix_op.Unary
                                                  op_id: Id.VTest_ColonPlus
                                                  arg_word: {<' '>}
                                                )
                                            ) (${ Id.VSub_Name DEPEND)
                                          )
                                        }
                                      spids: [2415]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<Id.Lit_LBracket '['>} 
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name RDEPEND>
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op_id: Id.VTest_Plus
                                            arg_word: {<set>}
                                          )
                                      )
                                    )
                                  } {<Id.Lit_Equals '='>} {<Id.KW_Set set>} {<Id.Lit_RBracket ']'>}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:E_RDEPEND)
                                      op: assign_op.PlusEqual
                                      rhs: 
                                        {
                                          (DQ 
                                            (braced_var_sub
                                              token: <Id.VSub_Name E_RDEPEND>
                                              suffix_op: 
                                                (suffix_op.Unary
                                                  op_id: Id.VTest_ColonPlus
                                                  arg_word: {<' '>}
                                                )
                                            ) (${ Id.VSub_Name RDEPEND)
                                          )
                                        }
                                      spids: [2446]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<Id.Lit_LBracket '['>} 
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name PDEPEND>
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op_id: Id.VTest_Plus
                                            arg_word: {<set>}
                                          )
                                      )
                                    )
                                  } {<Id.Lit_Equals '='>} {<Id.KW_Set set>} {<Id.Lit_RBracket ']'>}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:E_PDEPEND)
                                      op: assign_op.PlusEqual
                                      rhs: 
                                        {
                                          (DQ 
                                            (braced_var_sub
                                              token: <Id.VSub_Name E_PDEPEND>
                                              suffix_op: 
                                                (suffix_op.Unary
                                                  op_id: Id.VTest_ColonPlus
                                                  arg_word: {<' '>}
                                                )
                                            ) (${ Id.VSub_Name PDEPEND)
                                          )
                                        }
                                      spids: [2477]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<Id.Lit_LBracket '['>} 
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name HDEPEND>
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op_id: Id.VTest_Plus
                                            arg_word: {<set>}
                                          )
                                      )
                                    )
                                  } {<Id.Lit_Equals '='>} {<Id.KW_Set set>} {<Id.Lit_RBracket ']'>}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:E_HDEPEND)
                                      op: assign_op.PlusEqual
                                      rhs: 
                                        {
                                          (DQ 
                                            (braced_var_sub
                                              token: <Id.VSub_Name E_HDEPEND>
                                              suffix_op: 
                                                (suffix_op.Unary
                                                  op_id: Id.VTest_ColonPlus
                                                  arg_word: {<' '>}
                                                )
                                            ) (${ Id.VSub_Name HDEPEND)
                                          )
                                        }
                                      spids: [2508]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<Id.Lit_LBracket '['>} 
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name B_IUSE>
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op_id: Id.VTest_Plus
                                            arg_word: {<set>}
                                          )
                                      )
                                    )
                                  } {<Id.Lit_Equals '='>} {<Id.KW_Set set>} {<Id.Lit_RBracket ']'>}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:IUSE)
                                      op: assign_op.Equal
                                      rhs: {(DQ (${ Id.VSub_Name B_IUSE))}
                                      spids: [2540]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (C {<Id.Lit_LBracket '['>} 
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name B_IUSE>
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op_id: Id.VTest_Plus
                                            arg_word: {<set>}
                                          )
                                      )
                                    )
                                  } {<Id.Lit_Equals '='>} {<Id.KW_Set set>} {<Id.Lit_RBracket ']'>}
                                )
                                (C {<unset>} {<IUSE>})
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<Id.Lit_LBracket '['>} 
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name B_REQUIRED_USE>
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op_id: Id.VTest_Plus
                                            arg_word: {<set>}
                                          )
                                      )
                                    )
                                  } {<Id.Lit_Equals '='>} {<Id.KW_Set set>} {<Id.Lit_RBracket ']'>}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:REQUIRED_USE)
                                      op: assign_op.Equal
                                      rhs: {(DQ (${ Id.VSub_Name B_REQUIRED_USE))}
                                      spids: [2591]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (C {<Id.Lit_LBracket '['>} 
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name B_REQUIRED_USE>
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op_id: Id.VTest_Plus
                                            arg_word: {<set>}
                                          )
                                      )
                                    )
                                  } {<Id.Lit_Equals '='>} {<Id.KW_Set set>} {<Id.Lit_RBracket ']'>}
                                )
                                (C {<unset>} {<REQUIRED_USE>})
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<Id.Lit_LBracket '['>} 
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name B_DEPEND>
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op_id: Id.VTest_Plus
                                            arg_word: {<set>}
                                          )
                                      )
                                    )
                                  } {<Id.Lit_Equals '='>} {<Id.KW_Set set>} {<Id.Lit_RBracket ']'>}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:DEPEND)
                                      op: assign_op.Equal
                                      rhs: {(DQ (${ Id.VSub_Name B_DEPEND))}
                                      spids: [2641]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (C {<Id.Lit_LBracket '['>} 
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name B_DEPEND>
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op_id: Id.VTest_Plus
                                            arg_word: {<set>}
                                          )
                                      )
                                    )
                                  } {<Id.Lit_Equals '='>} {<Id.KW_Set set>} {<Id.Lit_RBracket ']'>}
                                )
                                (C {<unset>} {<DEPEND>})
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<Id.Lit_LBracket '['>} 
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name B_RDEPEND>
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op_id: Id.VTest_Plus
                                            arg_word: {<set>}
                                          )
                                      )
                                    )
                                  } {<Id.Lit_Equals '='>} {<Id.KW_Set set>} {<Id.Lit_RBracket ']'>}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:RDEPEND)
                                      op: assign_op.Equal
                                      rhs: {(DQ (${ Id.VSub_Name B_RDEPEND))}
                                      spids: [2691]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (C {<Id.Lit_LBracket '['>} 
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name B_RDEPEND>
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op_id: Id.VTest_Plus
                                            arg_word: {<set>}
                                          )
                                      )
                                    )
                                  } {<Id.Lit_Equals '='>} {<Id.KW_Set set>} {<Id.Lit_RBracket ']'>}
                                )
                                (C {<unset>} {<RDEPEND>})
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<Id.Lit_LBracket '['>} 
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name B_PDEPEND>
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op_id: Id.VTest_Plus
                                            arg_word: {<set>}
                                          )
                                      )
                                    )
                                  } {<Id.Lit_Equals '='>} {<Id.KW_Set set>} {<Id.Lit_RBracket ']'>}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:PDEPEND)
                                      op: assign_op.Equal
                                      rhs: {(DQ (${ Id.VSub_Name B_PDEPEND))}
                                      spids: [2741]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (C {<Id.Lit_LBracket '['>} 
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name B_PDEPEND>
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op_id: Id.VTest_Plus
                                            arg_word: {<set>}
                                          )
                                      )
                                    )
                                  } {<Id.Lit_Equals '='>} {<Id.KW_Set set>} {<Id.Lit_RBracket ']'>}
                                )
                                (C {<unset>} {<PDEPEND>})
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<Id.Lit_LBracket '['>} 
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name B_HDEPEND>
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op_id: Id.VTest_Plus
                                            arg_word: {<set>}
                                          )
                                      )
                                    )
                                  } {<Id.Lit_Equals '='>} {<Id.KW_Set set>} {<Id.Lit_RBracket ']'>}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:HDEPEND)
                                      op: assign_op.Equal
                                      rhs: {(DQ (${ Id.VSub_Name B_HDEPEND))}
                                      spids: [2791]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (C {<Id.Lit_LBracket '['>} 
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name B_HDEPEND>
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op_id: Id.VTest_Plus
                                            arg_word: {<set>}
                                          )
                                      )
                                    )
                                  } {<Id.Lit_Equals '='>} {<Id.KW_Set set>} {<Id.Lit_RBracket ']'>}
                                )
                                (C {<unset>} {<HDEPEND>})
                              ]
                            )
                            (C {<Id.KW_Set set>} {<Id.Lit_Other '+'> <f>})
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (command.DBracket
                                              expr: 
                                                (bool_expr.Unary
                                                  op_id: Id.BoolUnary_n
                                                  child: 
                                                    {
                                                      (braced_var_sub
                                                        token: <Id.VSub_Name __export_funcs_var>
                                                        prefix_op: (Id.VSub_Bang)
                                                      )
                                                    }
                                                )
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ForEach
                                      iter_name: x
                                      iter_words: [
                                        {
                                          (braced_var_sub
                                            token: <Id.VSub_Name __export_funcs_var>
                                            prefix_op: (Id.VSub_Bang)
                                          )
                                        }
                                      ]
                                      do_arg_iter: F
                                      body: 
                                        (command.DoGroup
                                          children: [
                                            (C {<debug-print>} 
                                              {
                                                (DQ <'EXPORT_FUNCTIONS: '> ($ Id.VSub_DollarName '$x') 
                                                  <' -> '> (${ Id.VSub_Name ECLASS) <_> ($ Id.VSub_DollarName '$x')
                                                )
                                              }
                                            )
                                            (command.AndOr
                                              ops: [Id.Op_DPipe]
                                              children: [
                                                (command.Simple
                                                  words: [
                                                    {<declare>}
                                                    {<-F>}
                                                    {
                                                      (DQ (${ Id.VSub_Name ECLASS) <_> 
                                                        ($ Id.VSub_DollarName '$x')
                                                      )
                                                    }
                                                  ]
                                                  redirects: [
                                                    (redir
                                                      op: <Id.Redir_Great '>'>
                                                      loc: (redir_loc.Fd fd:1)
                                                      arg: {<'/dev/null'>}
                                                    )
                                                  ]
                                                  do_fork: T
                                                )
                                                (C {<die>} 
                                                  {
                                                    (DQ <'EXPORT_FUNCTIONS: '> 
                                                      (${ Id.VSub_Name ECLASS) <_> ($ Id.VSub_DollarName '$x') <' is not defined'>
                                                    )
                                                  }
                                                )
                                              ]
                                            )
                                            (command.Simple
                                              words: [
                                                {<eval>}
                                                {
                                                  (DQ ($ Id.VSub_DollarName '$x') <'() { '> 
                                                    (${ Id.VSub_Name ECLASS) <_> ($ Id.VSub_DollarName '$x') <' '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) 
                                                    (word_part.EscapedLiteral
                                                      token: <Id.Lit_EscapedChar '\\$'>
                                                    ) <'@'> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) <' ; }'>
                                                  )
                                                }
                                              ]
                                              redirects: [
                                                (redir
                                                  op: <Id.Redir_Great '>'>
                                                  loc: (redir_loc.Fd fd:1)
                                                  arg: {<'/dev/null'>}
                                                )
                                              ]
                                              do_fork: T
                                            )
                                          ]
                                        )
                                    )
                                  ]
                                  spids: [2834 2849]
                                )
                              ]
                            )
                            (C {<unset>} {($ Id.VSub_DollarName '$__export_funcs_var')})
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (C {<has>} {($ Id.VSub_Number '$1')} 
                                  {($ Id.VSub_DollarName '$INHERITED')}
                                )
                                (C {<export>} 
                                  {<Id.Lit_VarLike 'INHERITED='> 
                                    (DQ ($ Id.VSub_DollarName '$INHERITED') <' '> 
                                      ($ Id.VSub_Number '$1')
                                    )
                                  }
                                )
                              ]
                            )
                          ]
                          spids: [2301 2314]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                )
            )
            (command.DParen
              child: 
                (arith_expr.UnaryAssign
                  op_id: Id.Arith_DMinus
                  child: <Id.Lit_ArithVarLike ECLASS_DEPTH>
                )
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DParen
                              child: 
                                (arith_expr.Binary
                                  op_id: Id.Arith_Great
                                  left: <Id.Lit_ArithVarLike ECLASS_DEPTH>
                                  right: {<Id.Lit_Digits 0>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<export>} {<Id.Lit_VarLike 'ECLASS='> ($ Id.VSub_DollarName '$PECLASS')})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:__export_funcs_var)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName '$prev_export_funcs_var')}
                          spids: [3011]
                        )
                      ]
                    )
                  ]
                  spids: [2987 3002]
                )
              ]
              else_action: [(C {<unset>} {<ECLASS>} {<__export_funcs_var>})]
            )
            (command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<0>})
          ]
        )
    )
    (command.ShFunction
      name: EXPORT_FUNCTIONS
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {<-z>} {(DQ ($ Id.VSub_DollarName '$ECLASS'))} 
                              {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<die>} {(DQ <'EXPORT_FUNCTIONS without a defined ECLASS'>)})]
                  spids: [3054 3067]
                )
              ]
            )
            (C {<eval>} 
              {($ Id.VSub_DollarName '$__export_funcs_var') <Id.Lit_Other '+'> <Id.Lit_Equals '='> 
                (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>)
              } {($ Id.VSub_Star '$*') (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>)}
            )
          ]
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:PORTAGE_BASHRCS_SOURCED)
          op: assign_op.Equal
          rhs: {<0>}
          spids: [3093]
        )
      ]
    )
    (command.ShFunction
      name: __source_all_bashrcs
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.Binary
                      op_id: Id.BoolBinary_GlobEqual
                      left: {($ Id.VSub_DollarName '$PORTAGE_BASHRCS_SOURCED')}
                      right: {<1>}
                    )
                )
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {<0>}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:PORTAGE_BASHRCS_SOURCED)
                  op: assign_op.Equal
                  rhs: {<1>}
                  spids: [3154]
                )
              ]
            )
            (C {<local>} {<x>})
            (C {<local>} {<Id.Lit_VarLike 'OCC='> (DQ (${ Id.VSub_Name CC))} 
              {<Id.Lit_VarLike 'OCXX='> (DQ (${ Id.VSub_Name CXX))}
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobNEqual
                                  left: {($ Id.VSub_DollarName '$EBUILD_PHASE')}
                                  right: {<depend>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<save_IFS>})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:IFS)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (single_quoted
                                left: <Id.Left_CSingleQuote '$\''>
                                tokens: [<Id.Char_OneChar '\\n'>]
                                multiline: F
                              )
                            }
                          spids: [3206]
                        )
                      ]
                    )
                    (C {<local>} 
                      {<Id.Lit_VarLike 'bashenv_files='> 
                        (sh_array_literal
                          left: <Id.Op_LParen _>
                          words: [{($ Id.VSub_DollarName '$PORTAGE_BASHRC_FILES')}]
                        )
                      }
                    )
                    (C {<restore_IFS>})
                    (command.ForEach
                      iter_name: x
                      iter_words: [
                        {
                          (DQ 
                            (braced_var_sub
                              token: <Id.VSub_Name bashenv_files>
                              bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                            )
                          )
                        }
                      ]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [(C {<__try_source>} {(DQ (${ Id.VSub_Name x))})]
                        )
                    )
                  ]
                  spids: [3182 3196]
                )
              ]
            )
            (C {<__try_source>} {<--no-qa>} {(DQ (${ Id.VSub_Name PORTAGE_BASHRC))})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobNEqual
                                  left: {($ Id.VSub_DollarName '$EBUILD_PHASE')}
                                  right: {<depend>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<__source_env_files>} {<--no-qa>} {(DQ (${ Id.VSub_Name PM_EBUILD_HOOK_DIR))})
                  ]
                  spids: [3279 3293]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {<Id.KW_Bang '!'>} {<-z>} {(DQ (${ Id.VSub_Name OCC))} 
                  {<Id.Lit_RBracket ']'>}
                )
                (C {<export>} {<Id.Lit_VarLike 'CC='> (DQ (${ Id.VSub_Name OCC))})
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {<Id.KW_Bang '!'>} {<-z>} {(DQ (${ Id.VSub_Name OCXX))} 
                  {<Id.Lit_RBracket ']'>}
                )
                (C {<export>} {<Id.Lit_VarLike 'CXX='> (DQ (${ Id.VSub_Name OCXX))})
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: __source_env_files
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'argument='> (sh_array_literal left:<Id.Op_LParen _>)})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: {($ Id.VSub_Number '$1')}
                                  right: {<--no-qa>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:argument)
                          op: assign_op.Equal
                          rhs: {(sh_array_literal left:<Id.Op_LParen _> words:[{<--no-qa>}])}
                          spids: [3413]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                  spids: [3397 3410]
                )
              ]
            )
            (command.ForEach
              iter_name: x
              iter_words: [
                (word.BracedTree
                  parts: [
                    (DQ (${ Id.VSub_Number 1))
                    <'/'>
                    (${ Id.VSub_Name CATEGORY)
                    <'/'>
                    (word_part.BracedTuple
                      words: [
                        {(${ Id.VSub_Name PN)}
                        {(${ Id.VSub_Name PN) <Id.Lit_Colon ':'> 
                          (braced_var_sub
                            token: <Id.VSub_Name SLOT>
                            suffix_op: 
                              (suffix_op.Unary
                                op_id: Id.VOp1_Percent
                                arg_word: {<Id.Lit_Slash '/'> <'*'>}
                              )
                          )
                        }
                        {(${ Id.VSub_Name P)}
                        {(${ Id.VSub_Name PF)}
                      ]
                    )
                  ]
                )
              ]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (C {<__try_source>} 
                      {
                        (DQ 
                          (braced_var_sub
                            token: <Id.VSub_Name argument>
                            bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                          )
                        )
                      } {(DQ (${ Id.VSub_Name x))}
                    )
                  ]
                )
            )
          ]
        )
    )
    (command.ShFunction
      name: __try_source
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'qa='> <true>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: {($ Id.VSub_Number '$1')}
                                  right: {<--no-qa>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:qa)
                          op: assign_op.Equal
                          rhs: {<false>}
                          spids: [3542]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                  spids: [3526 3539]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.LogicalAnd
                                  left: 
                                    (bool_expr.Unary
                                      op_id: Id.BoolUnary_r
                                      child: {($ Id.VSub_Number '$1')}
                                    )
                                  right: 
                                    (bool_expr.Unary
                                      op_id: Id.BoolUnary_f
                                      child: {($ Id.VSub_Number '$1')}
                                    )
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<local>} {<Id.Lit_VarLike 'debug_on='> <false>})
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.AndOr
                                      ops: [Id.Op_DAmp]
                                      children: [
                                        (command.DBracket
                                          expr: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobDEqual
                                              left: {(DQ ($ Id.VSub_DollarName '$PORTAGE_DEBUG'))}
                                              right: {(DQ <1>)}
                                            )
                                        )
                                        (command.DBracket
                                          expr: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobDEqual
                                              left: 
                                                {
                                                  (DQ 
                                                    (braced_var_sub
                                                      token: <Id.VSub_Hyphen ->
                                                      suffix_op: 
                                                        (suffix_op.PatSub
                                                          pat: {<x>}
                                                          replace: {}
                                                          replace_mode: Id.Undefined_Tok
                                                        )
                                                    )
                                                  )
                                                }
                                              right: {(DQ ($ Id.VSub_Hyphen '$-'))}
                                            )
                                        )
                                      ]
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:debug_on)
                                  op: assign_op.Equal
                                  rhs: {<true>}
                                  spids: [3619]
                                )
                              ]
                            )
                          ]
                          spids: [3578 3616]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [(C {($ Id.VSub_DollarName '$debug_on')}) (C {<Id.KW_Set set>} {<-x>})]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: (bool_expr.WordTest w:{(${ Id.VSub_Name qa)})
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [(C {<source>} {(DQ (${ Id.VSub_Number 1))})]
                          spids: [3647 3658]
                        )
                      ]
                      else_action: [(C {<__qa_source>} {(DQ (${ Id.VSub_Number 1))})]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {($ Id.VSub_DollarName '$debug_on')})
                        (C {<Id.KW_Set set>} {<Id.Lit_Other '+'> <x>})
                      ]
                    )
                  ]
                  spids: [3552 3569]
                )
              ]
            )
          ]
        )
    )
    (C {<export>} {<Id.Lit_VarLike 'SANDBOX_ON='> (DQ <1>)})
    (C {<export>} {<Id.Lit_VarLike 'S='> (${ Id.VSub_Name WORKDIR) <'/'> (${ Id.VSub_Name P)})
    (C {<shopt>} {<-u>} {<extglob>})
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (command.DBracket
                      expr: 
                        (bool_expr.Binary
                          op_id: Id.BoolBinary_GlobDEqual
                          left: {(${ Id.VSub_Name EBUILD_PHASE)}
                          right: {<depend>}
                        )
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:QA_INTERCEPTORS)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ <'awk bash cc egrep equery fgrep g++\n'> 
                        <'\t\tgawk gcc grep javac java-config nawk perl\n'> <'\t\tpkg-config python python-config sed'>
                      )
                    }
                  spids: [3757]
                )
              ]
            )
          ]
          spids: [3738 3754]
        )
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (command.DBracket
                      expr: 
                        (bool_expr.Binary
                          op_id: Id.BoolBinary_GlobDEqual
                          left: {(${ Id.VSub_Name EBUILD_PHASE)}
                          right: {<clean> <Id.Lit_Other '*'>}
                        )
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [(C {<unset>} {<QA_INTERCEPTORS>})]
          spids: [3764 3781]
        )
      ]
      else_action: [
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:QA_INTERCEPTORS)
              op: assign_op.Equal
              rhs: {(DQ <'autoconf automake aclocal libtoolize'>)}
              spids: [3791]
            )
          ]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (command.DBracket
                      expr: 
                        (bool_expr.Unary
                          op_id: Id.BoolUnary_n
                          child: {(${ Id.VSub_Name QA_INTERCEPTORS)}
                        )
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.ForEach
              iter_name: BIN
              iter_words: [{(${ Id.VSub_Name QA_INTERCEPTORS)}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:BIN_PATH)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: (C {<type>} {<-Pf>} {(${ Id.VSub_Name BIN)})
                              )
                            }
                          spids: [3832]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_QMark '$?'))} 
                                      {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ <0>)} {<Id.Lit_RBracket ']'>}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:BODY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ <'echo '> 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\"'>
                                        ) <'*** missing command: '> (${ Id.VSub_Name BIN) 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\"'>
                                        ) <' >&2; return 127'>
                                      )
                                    }
                                  spids: [3865]
                                )
                              ]
                            )
                          ]
                          spids: [3844 3862]
                        )
                      ]
                      else_action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:BODY)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (DQ (${ Id.VSub_Name BIN_PATH) <' '> 
                                    (word_part.EscapedLiteral
                                      token: <Id.Lit_EscapedChar '\\"'>
                                    ) (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'@'> 
                                    (word_part.EscapedLiteral
                                      token: <Id.Lit_EscapedChar '\\"'>
                                    ) <'; return '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'?'>
                                  )
                                }
                              spids: [3881]
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobDEqual
                                          left: {(${ Id.VSub_Name EBUILD_PHASE)}
                                          right: {<depend>}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:FUNC_SRC)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ (${ Id.VSub_Name BIN) <'() {\n'> <'\t\t\t\tif [ '> 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\$'>
                                        ) <'ECLASS_DEPTH -gt 0 ]; then\n'> <'\t\t\t\t\teqawarn '> 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\"'>
                                        ) <'QA Notice: \''> (${ Id.VSub_Name BIN) <'\' called in global scope: eclass '> 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\$'>
                                        ) <'{ECLASS}'> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) <'\n'> <'\t\t\t\telse\n'> 
                                        <'\t\t\t\t\teqawarn '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) <'QA Notice: \''> (${ Id.VSub_Name BIN) 
                                        <'\' called in global scope: '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'{CATEGORY}/'> 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\$'>
                                        ) <'{PF}'> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) <'\n'> <'\t\t\t\tfi\n'> <'\t\t\t'> 
                                        (${ Id.VSub_Name BODY) <'\n'> <'\t\t\t}'>
                                      )
                                    }
                                  spids: [3919]
                                )
                              ]
                            )
                          ]
                          spids: [3900 3916]
                        )
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<has>} {(${ Id.VSub_Name BIN)} {<autoconf>} {<automake>} 
                                      {<aclocal>} {<libtoolize>}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:FUNC_SRC)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ (${ Id.VSub_Name BIN) <'() {\n'> <'\t\t\t\tif ! has '> 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\$'>
                                        ) <'{FUNCNAME[1]} eautoreconf eaclocal _elibtoolize '> 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\\\'>
                                        ) <'\n'> <'\t\t\t\t\teautoheader eautoconf eautomake autotools_run_tool '> 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\\\'>
                                        ) <'\n'> <'\t\t\t\t\tautotools_check_macro autotools_get_subdirs '> 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\\\'>
                                        ) <'\n'> <'\t\t\t\t\tautotools_get_auxdir ; then\n'> <'\t\t\t\t\teqawarn '> 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\"'>
                                        ) <'QA Notice: \''> (${ Id.VSub_Name BIN) <'\' called by '> 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\$'>
                                        ) <'{FUNCNAME[1]}: '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'{CATEGORY}/'> 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\$'>
                                        ) <'{PF}'> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) <'\n'> <'\t\t\t\t\teqawarn '> 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\"'>
                                        ) <'Use autotools.eclass instead of calling \''> (${ Id.VSub_Name BIN) <'\' directly.'> 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\"'>
                                        ) <'\n'> <'\t\t\t\tfi\n'> <'\t\t\t'> (${ Id.VSub_Name BODY) <'\n'> <'\t\t\t}'>
                                      )
                                    }
                                  spids: [3984]
                                )
                              ]
                            )
                          ]
                          spids: [3963 3981]
                        )
                      ]
                      else_action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:FUNC_SRC)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (DQ (${ Id.VSub_Name BIN) <'() {\n'> <'\t\t\t\teqawarn '> 
                                    (word_part.EscapedLiteral
                                      token: <Id.Lit_EscapedChar '\\"'>
                                    ) <'QA Notice: \''> (${ Id.VSub_Name BIN) <'\' called by '> 
                                    (word_part.EscapedLiteral
                                      token: <Id.Lit_EscapedChar '\\$'>
                                    ) <'{FUNCNAME[1]}: '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'{CATEGORY}/'> 
                                    (word_part.EscapedLiteral
                                      token: <Id.Lit_EscapedChar '\\$'>
                                    ) <'{PF}'> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) <'\n'> <'\t\t\t'> 
                                    (${ Id.VSub_Name BODY) <'\n'> <'\t\t\t}'>
                                  )
                                }
                              spids: [4039]
                            )
                          ]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<eval>} {(DQ ($ Id.VSub_DollarName '$FUNC_SRC'))})
                        (command.Simple
                          words: [
                            {<echo>}
                            {(DQ <'error creating QA interceptor '> (${ Id.VSub_Name BIN))}
                          ]
                          redirects: [
                            (redir
                              op: <Id.Redir_GreatAnd '>&'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<2>}
                            )
                          ]
                          do_fork: T
                        )
                      ]
                    )
                  ]
                )
            )
            (C {<unset>} {<BIN_PATH>} {<BIN>} {<BODY>} {<FUNC_SRC>})
          ]
          spids: [3801 3815]
        )
      ]
    )
    (C {<export>} 
      {<Id.Lit_VarLike 'EBUILD_MASTER_PID='> 
        (braced_var_sub
          token: <Id.VSub_Name BASHPID>
          suffix_op: 
            (suffix_op.Unary
              op_id: Id.VTest_ColonHyphen
              arg_word: {(command_sub left_token:<Id.Left_DollarParen '$('> child:(C {<__bashpid>}))}
            )
        )
      }
    )
    (C {<trap>} {(SQ <'exit 1'>)} {<SIGTERM>})
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (command.AndOr
                      ops: [Id.Op_DAmp Id.Op_DAmp]
                      children: [
                        (command.Pipeline
                          children: [
                            (C {<has>} {(DQ ($ Id.VSub_DollarName '$EBUILD_PHASE'))} {<clean>} 
                              {<cleanrm>} {<depend>}
                            )
                          ]
                          negated: T
                        )
                        (command.Pipeline
                          children: [
                            (command.DBracket
                              expr: 
                                (bool_expr.LogicalAnd
                                  left: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_GlobEqual
                                      left: {($ Id.VSub_DollarName '$EMERGE_FROM')}
                                      right: {<ebuild>}
                                    )
                                  right: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_GlobEqual
                                      left: {($ Id.VSub_DollarName '$EBUILD_PHASE')}
                                      right: {<setup>}
                                    )
                                )
                            )
                          ]
                          negated: T
                        )
                        (C {<Id.Lit_LBracket '['>} {<-f>} {(DQ (${ Id.VSub_Name T)) <'/environment'>} 
                          {<Id.Lit_RBracket ']'>}
                        )
                      ]
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<__preprocess_ebuild_env>})
                (C {<die>} {(DQ <'error processing environment'>)})
              ]
            )
            (command.ForEach
              iter_name: x
              iter_words: [{<SANDBOX_DENY>} {<SANDBOX_READ>} {<SANDBOX_PREDICT>} {<SANDBOX_WRITE>}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (C {<export>} 
                      {<PORTAGE_> (${ Id.VSub_Name x) <Id.Lit_Equals '='> 
                        (DQ (braced_var_sub token:<Id.VSub_Name x> prefix_op:(Id.VSub_Bang)))
                      }
                    )
                  ]
                )
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:PORTAGE_SANDBOX_ON)
                  op: assign_op.Equal
                  rhs: {(${ Id.VSub_Name SANDBOX_ON)}
                  spids: [4264]
                )
              ]
            )
            (C {<export>} {<Id.Lit_VarLike 'SANDBOX_ON='> <1>})
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<source>} {(DQ (${ Id.VSub_Name T)) <'/environment'>})
                (C {<die>} {(DQ <'error sourcing environment'>)})
              ]
            )
            (C {<export>} {<Id.Lit_VarLike 'SANDBOX_ON='> <0>})
            (command.ForEach
              iter_name: x
              iter_words: [{<SANDBOX_DENY>} {<SANDBOX_PREDICT>} {<SANDBOX_READ>} {<SANDBOX_WRITE>}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:y)
                          op: assign_op.Equal
                          rhs: {(DQ <PORTAGE_> (${ Id.VSub_Name x))}
                          spids: [4337]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<Id.Lit_LBracket '['>} {<-z>} 
                                      {
                                        (DQ 
                                          (braced_var_sub
                                            token: <Id.VSub_Name x>
                                            prefix_op: (Id.VSub_Bang)
                                          )
                                        )
                                      } {<Id.Lit_RBracket ']'>}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<export>} 
                              {(${ Id.VSub_Name x) <Id.Lit_Equals '='> 
                                (DQ (braced_var_sub token:<Id.VSub_Name y> prefix_op:(Id.VSub_Bang)))
                              }
                            )
                          ]
                          spids: [4346 4363]
                        )
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.AndOr
                                      ops: [Id.Op_DAmp]
                                      children: [
                                        (C {<Id.Lit_LBracket '['>} {<-n>} 
                                          {
                                            (DQ 
                                              (braced_var_sub
                                                token: <Id.VSub_Name y>
                                                prefix_op: (Id.VSub_Bang)
                                              )
                                            )
                                          } {<Id.Lit_RBracket ']'>}
                                        )
                                        (C {<Id.Lit_LBracket '['>} 
                                          {
                                            (DQ 
                                              (braced_var_sub
                                                token: <Id.VSub_Name y>
                                                prefix_op: (Id.VSub_Bang)
                                              )
                                            )
                                          } {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} 
                                          {
                                            (DQ 
                                              (braced_var_sub
                                                token: <Id.VSub_Name x>
                                                prefix_op: (Id.VSub_Bang)
                                              )
                                            )
                                          } {<Id.Lit_RBracket ']'>}
                                        )
                                      ]
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<export>} 
                              {(${ Id.VSub_Name x) <Id.Lit_Equals '='> 
                                (DQ 
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (command.Pipeline
                                        children: [
                                          (C {<printf>} 
                                            {
                                              (DQ 
                                                (braced_var_sub
                                                  token: <Id.VSub_Name y>
                                                  prefix_op: (Id.VSub_Bang)
                                                ) <':'> (braced_var_sub token:<Id.VSub_Name x> prefix_op:(Id.VSub_Bang))
                                              )
                                            }
                                          )
                                          (C {<tr>} {(DQ <':'>)} {(DQ <Id.Lit_BadBackslash '\\'> <0>)})
                                          (C {<sort>} {<-z>} {<-u>})
                                          (C {<tr>} {(DQ <Id.Lit_BadBackslash '\\'> <0>)} {(DQ <':'>)})
                                        ]
                                        negated: F
                                      )
                                  )
                                )
                              }
                            )
                          ]
                          spids: [4380 4420]
                        )
                      ]
                    )
                    (C {<export>} 
                      {(${ Id.VSub_Name x) <Id.Lit_Equals '='> 
                        (DQ 
                          (braced_var_sub
                            token: <Id.VSub_Name x>
                            prefix_op: (Id.VSub_Bang)
                            suffix_op: (suffix_op.Unary op_id:Id.VOp1_Percent arg_word:{<':'>})
                          )
                        )
                      }
                    )
                    (C {<unset>} {<PORTAGE_> (${ Id.VSub_Name x)})
                  ]
                )
            )
            (C {<unset>} {<x>} {<y>})
            (C {<export>} {<Id.Lit_VarLike 'SANDBOX_ON='> (${ Id.VSub_Name PORTAGE_SANDBOX_ON)})
            (C {<unset>} {<PORTAGE_SANDBOX_ON>})
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.DBracket
                  expr: (bool_expr.Unary op_id:Id.BoolUnary_n child:{($ Id.VSub_DollarName '$EAPI')})
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:EAPI)
                      op: assign_op.Equal
                      rhs: {<0>}
                      spids: [4548]
                    )
                  ]
                )
              ]
            )
          ]
          spids: [4132 4191]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: (C {<___eapi_enables_globstar>})
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [(C {<shopt>} {<-s>} {<globstar>})]
          spids: [4554 4559]
        )
      ]
    )
    (C {<eval>} {(DQ <'PORTAGE_ECLASS_LOCATIONS=('> (${ Id.VSub_Name PORTAGE_ECLASS_LOCATIONS) <')'>)})
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (command.Pipeline
                      children: [
                        (C {<has>} {(DQ ($ Id.VSub_DollarName '$EBUILD_PHASE'))} {<clean>} {<cleanrm>})
                      ]
                      negated: T
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.LogicalAnd
                                      left: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobEqual
                                          left: {($ Id.VSub_DollarName '$EBUILD_PHASE')}
                                          right: {<setup>}
                                        )
                                      right: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobEqual
                                          left: {($ Id.VSub_DollarName '$EMERGE_FROM')}
                                          right: {<ebuild>}
                                        )
                                    )
                                )
                                (command.DBracket
                                  expr: 
                                    (bool_expr.LogicalOr
                                      left: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobEqual
                                          left: {($ Id.VSub_DollarName '$EBUILD_PHASE')}
                                          right: {<depend>}
                                        )
                                      right: 
                                        (bool_expr.LogicalOr
                                          left: 
                                            (bool_expr.LogicalNot
                                              child: 
                                                (bool_expr.Unary
                                                  op_id: Id.BoolUnary_f
                                                  child: 
                                                    {($ Id.VSub_DollarName '$T') <'/environment'>}
                                                )
                                            )
                                          right: 
                                            (bool_expr.LogicalOr
                                              left: 
                                                (bool_expr.Unary
                                                  op_id: Id.BoolUnary_f
                                                  child: 
                                                    {($ Id.VSub_DollarName '$PORTAGE_BUILDDIR') 
                                                      <'/.ebuild_changed'>
                                                    }
                                                )
                                              right: 
                                                (bool_expr.Binary
                                                  op_id: Id.BoolBinary_GlobDEqual
                                                  left: {(DQ <' '> (${ Id.VSub_Name FEATURES) <' '>)}
                                                  right: 
                                                    {<Id.Lit_Other '*'> (DQ <' noauto '>) 
                                                      <Id.Lit_Other '*'>
                                                    }
                                                )
                                            )
                                        )
                                    )
                                )
                              ]
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<__source_all_bashrcs>})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:__INHERITED_QA_CACHE)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName '$INHERITED')}
                          spids: [4715]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: (C {<___eapi_enables_failglob_in_global_scope>})
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [(C {<shopt>} {<-s>} {<failglob>})]
                          spids: [4732 4737]
                        )
                      ]
                    )
                    (C {<unset>} {<EAPI>} {<DEPEND>} {<RDEPEND>} {<PDEPEND>} {<HDEPEND>} {<INHERITED>} 
                      {<IUSE>} {<REQUIRED_USE>} {<ECLASS>} {<E_IUSE>} {<E_REQUIRED_USE>} {<E_DEPEND>} {<E_RDEPEND>} {<E_PDEPEND>} 
                      {<E_HDEPEND>} {<PROVIDES_EXCLUDE>} {<REQUIRES_EXCLUDE>}
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.LogicalOr
                                          left: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobNEqual
                                              left: {($ Id.VSub_DollarName '$PORTAGE_DEBUG')}
                                              right: {<1>}
                                            )
                                          right: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobNEqual
                                              left: 
                                                {
                                                  (braced_var_sub
                                                    token: <Id.VSub_Hyphen ->
                                                    suffix_op: 
                                                      (suffix_op.PatSub
                                                        pat: {<x>}
                                                        replace: {}
                                                        replace_mode: Id.Undefined_Tok
                                                      )
                                                  )
                                                }
                                              right: {($ Id.VSub_Hyphen '$-')}
                                            )
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (C {<source>} {(DQ ($ Id.VSub_DollarName '$EBUILD'))})
                                (C {<die>} {(DQ <'error sourcing ebuild'>)})
                              ]
                            )
                          ]
                          spids: [4809 4836]
                        )
                      ]
                      else_action: [
                        (C {<Id.KW_Set set>} {<-x>})
                        (command.AndOr
                          ops: [Id.Op_DPipe]
                          children: [
                            (C {<source>} {(DQ ($ Id.VSub_DollarName '$EBUILD'))})
                            (C {<die>} {(DQ <'error sourcing ebuild'>)})
                          ]
                        )
                        (C {<Id.KW_Set set>} {<Id.Lit_Other '+'> <x>})
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: (C {<___eapi_enables_failglob_in_global_scope>})
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [(C {<shopt>} {<-u>} {<failglob>})]
                          spids: [4887 4892]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobNEqual
                                          left: {(DQ (${ Id.VSub_Name EBUILD_PHASE))}
                                          right: {(DQ <depend>)}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:RESTRICT)
                                  op: assign_op.Equal
                                  rhs: {(${ Id.VSub_Name PORTAGE_RESTRICT)}
                                  spids: [4929]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Unary
                                      op_id: Id.BoolUnary_e
                                      child: 
                                        {($ Id.VSub_DollarName '$PORTAGE_BUILDDIR') 
                                          <'/.ebuild_changed'>
                                        }
                                    )
                                )
                                (C {<rm>} 
                                  {
                                    (DQ ($ Id.VSub_DollarName '$PORTAGE_BUILDDIR') 
                                      <'/.ebuild_changed'>
                                    )
                                  }
                                )
                              ]
                            )
                          ]
                          spids: [4906 4926]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<Id.Lit_LBracket '['>} 
                          {
                            (DQ 
                              (braced_var_sub
                                token: <Id.VSub_Name EAPI>
                                suffix_op: (suffix_op.Unary op_id:Id.VTest_Plus arg_word:{<set>})
                              )
                            )
                          } {<Id.Lit_Equals '='>} {<Id.KW_Set set>} {<Id.Lit_RBracket ']'>}
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:EAPI)
                              op: assign_op.Equal
                              rhs: {<0>}
                              spids: [4978]
                            )
                          ]
                        )
                      ]
                    )
                    (C {<export>} {<EAPI>})
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: (C {<___eapi_has_RDEPEND_DEPEND_fallback>})
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<export>} 
                              {<Id.Lit_VarLike 'RDEPEND='> 
                                (braced_var_sub
                                  token: <Id.VSub_Name RDEPEND>
                                  suffix_op: 
                                    (suffix_op.Unary
                                      op_id: Id.VTest_Hyphen
                                      arg_word: {(${ Id.VSub_Name DEPEND)}
                                    )
                                )
                              }
                            )
                            (C {<debug-print>} 
                              {(DQ <'RDEPEND: not set... Setting to: '> (${ Id.VSub_Name DEPEND))}
                            )
                          ]
                          spids: [4993 4998]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:IUSE)
                          op: assign_op.PlusEqual
                          rhs: 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name IUSE>
                                  suffix_op: 
                                    (suffix_op.Unary
                                      op_id: Id.VTest_ColonPlus
                                      arg_word: {<' '>}
                                    )
                                ) (${ Id.VSub_Name E_IUSE)
                              )
                            }
                          spids: [5031]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:DEPEND)
                          op: assign_op.PlusEqual
                          rhs: 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name DEPEND>
                                  suffix_op: 
                                    (suffix_op.Unary
                                      op_id: Id.VTest_ColonPlus
                                      arg_word: {<' '>}
                                    )
                                ) (${ Id.VSub_Name E_DEPEND)
                              )
                            }
                          spids: [5044]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:RDEPEND)
                          op: assign_op.PlusEqual
                          rhs: 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name RDEPEND>
                                  suffix_op: 
                                    (suffix_op.Unary
                                      op_id: Id.VTest_ColonPlus
                                      arg_word: {<' '>}
                                    )
                                ) (${ Id.VSub_Name E_RDEPEND)
                              )
                            }
                          spids: [5057]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:PDEPEND)
                          op: assign_op.PlusEqual
                          rhs: 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name PDEPEND>
                                  suffix_op: 
                                    (suffix_op.Unary
                                      op_id: Id.VTest_ColonPlus
                                      arg_word: {<' '>}
                                    )
                                ) (${ Id.VSub_Name E_PDEPEND)
                              )
                            }
                          spids: [5070]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:HDEPEND)
                          op: assign_op.PlusEqual
                          rhs: 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name HDEPEND>
                                  suffix_op: 
                                    (suffix_op.Unary
                                      op_id: Id.VTest_ColonPlus
                                      arg_word: {<' '>}
                                    )
                                ) (${ Id.VSub_Name E_HDEPEND)
                              )
                            }
                          spids: [5083]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:REQUIRED_USE)
                          op: assign_op.PlusEqual
                          rhs: 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name REQUIRED_USE>
                                  suffix_op: 
                                    (suffix_op.Unary
                                      op_id: Id.VTest_ColonPlus
                                      arg_word: {<' '>}
                                    )
                                ) (${ Id.VSub_Name E_REQUIRED_USE)
                              )
                            }
                          spids: [5096]
                        )
                      ]
                    )
                    (C {<unset>} {<ECLASS>} {<E_IUSE>} {<E_REQUIRED_USE>} {<E_DEPEND>} {<E_RDEPEND>} 
                      {<E_PDEPEND>} {<E_HDEPEND>} {<__INHERITED_QA_CACHE>}
                    )
                    (command.Case
                      to_match: {(${ Id.VSub_Name EAPI)}
                      arms: [
                        (case_arm
                          pat_list: [{<0>} {<1>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:_valid_phases)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ <'src_compile pkg_config pkg_info src_install\n'> 
                                        <
'\t\t\t\t\tpkg_nofetch pkg_postinst pkg_postrm pkg_preinst pkg_prerm\n'
                                        > <'\t\t\t\t\tpkg_setup src_test src_unpack'>
                                      )
                                    }
                                  spids: [5152]
                                )
                              ]
                            )
                          ]
                          spids: [5146 5149 5160 -1]
                        )
                        (case_arm
                          pat_list: [{<2>} {<3>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:_valid_phases)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ <'src_compile pkg_config src_configure pkg_info\n'> 
                                        <
'\t\t\t\t\tsrc_install pkg_nofetch pkg_postinst pkg_postrm pkg_preinst\n'
                                        > <'\t\t\t\t\tsrc_prepare pkg_prerm pkg_setup src_test src_unpack'>
                                      )
                                    }
                                  spids: [5169]
                                )
                              ]
                            )
                          ]
                          spids: [5163 5166 5177 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:_valid_phases)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ <'src_compile pkg_config src_configure pkg_info\n'> 
                                        <
'\t\t\t\t\tsrc_install pkg_nofetch pkg_postinst pkg_postrm pkg_preinst\n'
                                        > <'\t\t\t\t\tsrc_prepare pkg_prerm pkg_pretend pkg_setup src_test src_unpack'>
                                      )
                                    }
                                  spids: [5184]
                                )
                              ]
                            )
                          ]
                          spids: [5180 5181 5192 -1]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:DEFINED_PHASES)
                          op: assign_op.Equal
                          rhs: (word.Empty)
                          spids: [5199]
                        )
                      ]
                    )
                    (command.ForEach
                      iter_name: _f
                      iter_words: [{($ Id.VSub_DollarName '$_valid_phases')}]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (command.Simple
                                              words: [{<declare>} {<-F>} {($ Id.VSub_DollarName '$_f')}]
                                              redirects: [
                                                (redir
                                                  op: <Id.Redir_Great '>'>
                                                  loc: (redir_loc.Fd fd:1)
                                                  arg: {<'/dev/null'>}
                                                )
                                              ]
                                              do_fork: T
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:_f)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (braced_var_sub
                                                token: <Id.VSub_Name _f>
                                                suffix_op: 
                                                  (suffix_op.Unary
                                                    op_id: Id.VOp1_Pound
                                                    arg_word: {<pkg_>}
                                                  )
                                              )
                                            }
                                          spids: [5231]
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:DEFINED_PHASES)
                                          op: assign_op.PlusEqual
                                          rhs: 
                                            {
                                              (DQ <' '> 
                                                (braced_var_sub
                                                  token: <Id.VSub_Name _f>
                                                  suffix_op: 
                                                    (suffix_op.Unary
                                                      op_id: Id.VOp1_Pound
                                                      arg_word: {<src_>}
                                                    )
                                                )
                                              )
                                            }
                                          spids: [5239]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [5215 5228]
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_n
                              child: {($ Id.VSub_DollarName '$DEFINED_PHASES')}
                            )
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:DEFINED_PHASES)
                              op: assign_op.Equal
                              rhs: {<->}
                              spids: [5266]
                            )
                          ]
                        )
                      ]
                    )
                    (C {<unset>} {<_f>} {<_valid_phases>})
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobNEqual
                                          left: {($ Id.VSub_DollarName '$EBUILD_PHASE')}
                                          right: {<depend>}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<has>} {<distcc>} {($ Id.VSub_DollarName '$FEATURES')})
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.AndOr
                                      ops: [Id.Op_DAmp]
                                      children: [
                                        (command.DBracket
                                          expr: 
                                            (bool_expr.Unary
                                              op_id: Id.BoolUnary_n
                                              child: {($ Id.VSub_DollarName '$DISTCC_LOG')}
                                            )
                                        )
                                        (C {<addwrite>} 
                                          {
                                            (DQ 
                                              (braced_var_sub
                                                token: <Id.VSub_Name DISTCC_LOG>
                                                suffix_op: 
                                                  (suffix_op.Unary
                                                    op_id: Id.VOp1_Percent
                                                    arg_word: {<Id.Lit_Slash '/'> <'*'>}
                                                  )
                                              )
                                            )
                                          }
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [5297 5307]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<has>} {<ccache>} {($ Id.VSub_DollarName '$FEATURES')})
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: 
                                            (condition.Shell
                                              commands: [
                                                (command.Sentence
                                                  child: 
                                                    (command.DBracket
                                                      expr: 
                                                        (bool_expr.Unary
                                                          op_id: Id.BoolUnary_n
                                                          child: 
                                                            {($ Id.VSub_DollarName '$CCACHE_DIR')}
                                                        )
                                                    )
                                                  terminator: <Id.Op_Semi _>
                                                )
                                              ]
                                            )
                                          action: [
                                            (C {<addread>} {(DQ ($ Id.VSub_DollarName '$CCACHE_DIR'))})
                                            (C {<addwrite>} {(DQ ($ Id.VSub_DollarName '$CCACHE_DIR'))})
                                          ]
                                          spids: [5350 5362]
                                        )
                                      ]
                                    )
                                    (command.AndOr
                                      ops: [Id.Op_DAmp]
                                      children: [
                                        (command.DBracket
                                          expr: 
                                            (bool_expr.Unary
                                              op_id: Id.BoolUnary_n
                                              child: {($ Id.VSub_DollarName '$CCACHE_SIZE')}
                                            )
                                        )
                                        (command.Simple
                                          words: [
                                            {<ccache>}
                                            {<-M>}
                                            {($ Id.VSub_DollarName '$CCACHE_SIZE')}
                                          ]
                                          redirects: [
                                            (redir
                                              op: <Id.Redir_AndGreat '&>'>
                                              loc: (redir_loc.Fd fd:1)
                                              arg: {<'/dev/null'>}
                                            )
                                          ]
                                          do_fork: T
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [5336 5346]
                                )
                              ]
                            )
                          ]
                          spids: [5279 5293]
                        )
                      ]
                    )
                  ]
                  spids: [4610 4684]
                )
              ]
            )
          ]
          spids: [4591 4607]
        )
      ]
    )
    (command.ForEach
      iter_name: x
      iter_words: [{(${ Id.VSub_Name USE_EXPAND)}]
      do_arg_iter: F
      body: 
        (command.DoGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} 
                  {(DQ (braced_var_sub token:<Id.VSub_Name x> prefix_op:(Id.VSub_Bang)))} {<Id.Lit_Equals '='> <Id.Lit_Equals '='>} {(DQ <'*'>)} {<Id.Lit_RBracket ']'>}
                )
                (C {<unset>} {(${ Id.VSub_Name x)})
              ]
            )
          ]
        )
    )
    (C {<unset>} {<x>})
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.AndOr
                  ops: [Id.Op_DPipe]
                  children: [
                    (C {<has>} {<nostrip>} {(${ Id.VSub_Name FEATURES)} {(${ Id.VSub_Name RESTRICT)})
                    (C {<has>} {<strip>} {(${ Id.VSub_Name RESTRICT)})
                  ]
                )
              ]
            )
          action: [(C {<export>} {<Id.Lit_VarLike 'DEBUGBUILD='> <1>})]
          spids: [5466 5490]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (command.DBracket
                      expr: 
                        (bool_expr.Binary
                          op_id: Id.BoolBinary_GlobEqual
                          left: {($ Id.VSub_DollarName '$EBUILD_PHASE')}
                          right: {<depend>}
                        )
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (C {<export>} {<Id.Lit_VarLike 'SANDBOX_ON='> (DQ <0>)})
            (C {<Id.KW_Set set>} {<-f>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {<-n>} {(DQ (${ Id.VSub_Name dbkey))} 
                              {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<Id.Lit_LBracket '['>} {<Id.KW_Bang '!'>} {<-d>} 
                                      {
                                        (DQ 
                                          (braced_var_sub
                                            token: <Id.VSub_Name dbkey>
                                            suffix_op: 
                                              (suffix_op.Unary
                                                op_id: Id.VOp1_Percent
                                                arg_word: {<Id.Lit_Slash '/'> <'*'>}
                                              )
                                          )
                                        )
                                      } {<Id.Lit_RBracket ']'>}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<install>} {<-d>} {<-g>} {(${ Id.VSub_Name PORTAGE_GID)} {<-m2775>} 
                              {
                                (DQ 
                                  (braced_var_sub
                                    token: <Id.VSub_Name dbkey>
                                    suffix_op: 
                                      (suffix_op.Unary
                                        op_id: Id.VOp1_Percent
                                        arg_word: {<Id.Lit_Slash '/'> <'*'>}
                                      )
                                  )
                                )
                              }
                            )
                          ]
                          spids: [5551 5571]
                        )
                      ]
                    )
                    (C {<umask>} {<002>})
                  ]
                  spids: [5532 5548]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:auxdbkeys)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ <'DEPEND RDEPEND SLOT SRC_URI RESTRICT HOMEPAGE LICENSE\n'> 
                        <
'\t\tDESCRIPTION KEYWORDS INHERITED IUSE REQUIRED_USE PDEPEND PROVIDE EAPI\n'
                        > <'\t\tPROPERTIES DEFINED_PHASES HDEPEND UNUSED_04\n'> <'\t\tUNUSED_03 UNUSED_02 UNUSED_01'>
                      )
                    }
                  spids: [5612]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: (command.Pipeline children:[(C {<___eapi_has_HDEPEND>})] negated:T)
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<unset>} {<HDEPEND>})]
                  spids: [5622 5629]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {<-n>} {(DQ (${ Id.VSub_Name dbkey))} 
                              {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.Simple
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(DQ (${ Id.VSub_Name dbkey))}
                        )
                      ]
                      do_fork: F
                    )
                    (command.ForEach
                      iter_name: f
                      iter_words: [{(${ Id.VSub_Name auxdbkeys)}]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (command.Simple
                                  words: [
                                    {<echo>}
                                    {
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (C {<echo>} 
                                            {
                                              (braced_var_sub
                                                token: <Id.VSub_Name f>
                                                prefix_op: (Id.VSub_Bang)
                                              )
                                            }
                                          )
                                      )
                                    }
                                  ]
                                  redirects: [
                                    (redir
                                      op: <Id.Redir_DGreat '>>'>
                                      loc: (redir_loc.Fd fd:1)
                                      arg: {(DQ (${ Id.VSub_Name dbkey))}
                                    )
                                  ]
                                  do_fork: T
                                )
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Exit exit>
                                  arg_word: {($ Id.VSub_QMark '$?')}
                                )
                              ]
                            )
                          ]
                        )
                    )
                  ]
                  spids: [5645 5661]
                )
              ]
              else_action: [
                (command.ForEach
                  iter_name: f
                  iter_words: [{(${ Id.VSub_Name auxdbkeys)}]
                  do_arg_iter: F
                  body: 
                    (command.DoGroup
                      children: [
                        (command.AndOr
                          ops: [Id.Op_DPipe]
                          children: [
                            (C {<eval>} 
                              {
                                (DQ <'echo '> 
                                  (word_part.EscapedLiteral
                                    token: <Id.Lit_EscapedChar '\\$'>
                                  ) <'(echo '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'{!f}) 1>&'> 
                                  (${ Id.VSub_Name PORTAGE_PIPE_FD)
                                )
                              }
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Exit exit>
                              arg_word: {($ Id.VSub_QMark '$?')}
                            )
                          ]
                        )
                      ]
                    )
                )
                (C {<eval>} {(DQ <'exec '> (${ Id.VSub_Name PORTAGE_PIPE_FD) <'>&-'>)})
              ]
            )
            (C {<Id.KW_Set set>} {<Id.Lit_Other '+'> <f>})
          ]
          spids: [5501 5515]
        )
      ]
      else_action: [
        (C {<declare>} {<-r>} {($ Id.VSub_DollarName '$PORTAGE_READONLY_METADATA')} 
          {($ Id.VSub_DollarName '$PORTAGE_READONLY_VARS')}
        )
        (command.If
          arms: [
            (if_arm
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: (C {<___eapi_has_prefix_variables>})
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              action: [(C {<declare>} {<-r>} {<ED>} {<EPREFIX>} {<EROOT>})]
              spids: [5797 5802]
            )
          ]
        )
        (command.If
          arms: [
            (if_arm
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: 
                        (command.AndOr
                          ops: [Id.Op_DAmp]
                          children: [
                            (command.DBracket
                              expr: 
                                (bool_expr.LogicalAnd
                                  left: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_GlobDEqual
                                      left: {(${ Id.VSub_Name EBUILD_PHASE)}
                                      right: {<test>}
                                    )
                                  right: 
                                    (bool_expr.LogicalAnd
                                      left: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobDEqual
                                          left: {(${ Id.VSub_Name EBUILD_FORCE_TEST)}
                                          right: {<1>}
                                        )
                                      right: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_EqualTilde
                                          left: {<test>}
                                          right: {(${ Id.VSub_Name PORTAGE_IUSE)}
                                        )
                                    )
                                )
                            )
                            (command.Pipeline
                              children: [(C {<has>} {<test>} {(${ Id.VSub_Name USE)})]
                              negated: T
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              action: [(C {<export>} {<Id.Lit_VarLike 'USE='> (DQ (${ Id.VSub_Name USE) <' test'>)})]
              spids: [5828 5877]
            )
          ]
        )
        (C {<declare>} {<-r>} {<USE>})
        (command.If
          arms: [
            (if_arm
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_n
                              child: {($ Id.VSub_DollarName '$EBUILD_SH_ARGS')}
                            )
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              action: [
                (command.Subshell
                  child: 
                    (command.CommandList
                      children: [
                        (command.If
                          arms: [
                            (if_arm
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.Sentence
                                      child: 
                                        (command.DBracket
                                          expr: 
                                            (bool_expr.Unary
                                              op_id: Id.BoolUnary_n
                                              child: {(${ Id.VSub_Name PORTAGE_PIPE_FD)}
                                            )
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                )
                              action: [
                                (C {<eval>} {(DQ <'exec '> (${ Id.VSub_Name PORTAGE_PIPE_FD) <'>&-'>)})
                                (C {<unset>} {<PORTAGE_PIPE_FD>})
                              ]
                              spids: [5928 5942]
                            )
                          ]
                        )
                        (C {<__ebuild_main>} {(${ Id.VSub_Name EBUILD_SH_ARGS)})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Exit exit>
                          arg_word: {<0>}
                        )
                      ]
                    )
                )
                (command.ControlFlow
                  token: <Id.ControlFlow_Exit exit>
                  arg_word: {($ Id.VSub_QMark '$?')}
                )
              ]
              spids: [5902 5914]
            )
          ]
        )
      ]
    )
    (C {<true>})
  ]
)