(command.CommandList
  children: [
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:PORTAGE_READONLY_METADATA)
          op: assign_op.Equal
          rhs: 
            {
              (DQ <'DEFINED_PHASES DEPEND DESCRIPTION\n'> 
                <'\tEAPI HDEPEND HOMEPAGE INHERITED IUSE REQUIRED_USE KEYWORDS LICENSE\n'> <'\tPDEPEND PROVIDE RDEPEND REPOSITORY RESTRICT SLOT SRC_URI'>
              )
            }
          spids: [23]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:PORTAGE_READONLY_VARS)
          op: assign_op.Equal
          rhs: 
            {
              (DQ <'D EBUILD EBUILD_PHASE EBUILD_PHASE_FUNC '> 
                <'\tEBUILD_SH_ARGS ECLASSDIR EMERGE_FROM FILESDIR MERGE_TYPE '> <'\tPM_EBUILD_HOOK_DIR '> <'\tPORTAGE_ACTUAL_DISTDIR PORTAGE_ARCHLIST PORTAGE_BASHRC  '> 
                <'\tPORTAGE_BINPKG_FILE PORTAGE_BINPKG_TAR_OPTS PORTAGE_BINPKG_TMPFILE '> <'\tPORTAGE_BIN_PATH PORTAGE_BUILDDIR PORTAGE_BUILD_GROUP '> 
                <'\tPORTAGE_BUILD_USER PORTAGE_BUNZIP2_COMMAND '> <'\tPORTAGE_BZIP2_COMMAND PORTAGE_COLORMAP PORTAGE_CONFIGROOT '> 
                <'\tPORTAGE_DEBUG PORTAGE_DEPCACHEDIR PORTAGE_EBUILD_EXIT_FILE '> <'\tPORTAGE_ECLASS_LOCATIONS '> <'\tPORTAGE_GID PORTAGE_GRPNAME PORTAGE_INST_GID PORTAGE_INST_UID '> 
                <'\tPORTAGE_INTERNAL_CALLER PORTAGE_IPC_DAEMON PORTAGE_IUSE PORTAGE_LOG_FILE '> <'\tPORTAGE_MUTABLE_FILTERED_VARS PORTAGE_OVERRIDE_EPREFIX '> 
                <'\tPORTAGE_PYM_PATH PORTAGE_PYTHON PORTAGE_PYTHONPATH '> <'\tPORTAGE_READONLY_METADATA PORTAGE_READONLY_VARS '> 
                <'\tPORTAGE_REPO_NAME PORTAGE_REPOSITORIES PORTAGE_RESTRICT '> <'\tPORTAGE_SAVED_READONLY_VARS PORTAGE_SIGPIPE_STATUS '> 
                <'\tPORTAGE_TMPDIR PORTAGE_UPDATE_ENV PORTAGE_USERNAME '> <'\tPORTAGE_VERBOSE PORTAGE_WORKDIR_MODE PORTAGE_XATTR_EXCLUDE '> <'\tPORTDIR '> 
                <'\tREPLACING_VERSIONS REPLACED_BY_VERSION T WORKDIR '> <'\t__PORTAGE_HELPER __PORTAGE_TEST_HARDLINK_LOCKS'>
              )
            }
          spids: [31]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:PORTAGE_SAVED_READONLY_VARS)
          op: assign_op.Equal
          rhs: {(DQ <'A CATEGORY P PF PN PR PV PVR'>)}
          spids: [79]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:PORTAGE_MUTABLE_FILTERED_VARS)
          op: assign_op.Equal
          rhs: {(DQ <'AA HOSTNAME'>)}
          spids: [97]
        )
      ]
    )
    (command.ShFunction
      name: __filter_readonly_variables
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<x>} {<filtered_vars>})
            (C {<local>} 
              {<Id.Lit_VarLike 'readonly_bash_vars='> 
                (DQ <'BASHOPTS BASHPID DIRSTACK EUID\n'> 
                  <'\t\tFUNCNAME GROUPS PIPESTATUS PPID SHELLOPTS UID'>
                )
              }
            )
            (C {<local>} 
              {<Id.Lit_VarLike 'bash_misc_vars='> 
                (DQ <'BASH BASH_.* COLUMNS COMP_WORDBREAKS HISTCMD\n'> 
                  <'\t\tHISTFILE HOSTNAME HOSTTYPE IFS LINENO MACHTYPE OLDPWD\n'> <'\t\tOPTERR OPTIND OSTYPE POSIXLY_CORRECT PS4 PWD RANDOM\n'> <'\t\tSECONDS SHLVL _'>
                )
              }
            )
            (C {<local>} 
              {<Id.Lit_VarLike 'filtered_sandbox_vars='> 
                (DQ <'SANDBOX_ACTIVE SANDBOX_BASHRC\n'> 
                  <'\t\tSANDBOX_DEBUG_LOG SANDBOX_DISABLED SANDBOX_LIB\n'> <'\t\tSANDBOX_LOG SANDBOX_ON'>
                )
              }
            )
            (C {<local>} {<Id.Lit_VarLike 'binpkg_untrusted_vars='> (DQ <'CATEGORY P PF PN PR PV PVR'>)})
            (C {<local>} {<Id.Lit_VarLike 'misc_garbage_vars='> (DQ <_portage_filter_opts>)})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:filtered_vars)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ ($ Id.VSub_DollarName '$readonly_bash_vars') <' '> 
                        ($ Id.VSub_DollarName '$bash_misc_vars') <'\n'> <'\t\t'> ($ Id.VSub_DollarName '$PORTAGE_READONLY_VARS') <' '> 
                        ($ Id.VSub_DollarName '$misc_garbage_vars')
                      )
                    }
                  spids: [293]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: (C {<___eapi_has_prefix_variables>})
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:filtered_vars)
                          op: assign_op.PlusEqual
                          rhs: {(DQ <' ED EPREFIX EROOT'>)}
                          spids: [323]
                        )
                      ]
                    )
                  ]
                  spids: [315 320]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: (C {<has>} {<--filter-sandbox>} {($ Id.VSub_Star '$*')})
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:filtered_vars)
                          op: assign_op.Equal
                          rhs: {(DQ (${ Id.VSub_Name filtered_vars) <' SANDBOX_.*'>)}
                          spids: [346]
                        )
                      ]
                    )
                  ]
                  spids: [333 343]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:filtered_vars)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (DQ (${ Id.VSub_Name filtered_vars) <' '> 
                            (${ Id.VSub_Name filtered_sandbox_vars)
                          )
                        }
                      spids: [358]
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: (C {<has>} {<--filter-features>} {($ Id.VSub_Star '$*')})
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:filtered_vars)
                          op: assign_op.Equal
                          rhs: {(DQ (${ Id.VSub_Name filtered_vars) <' FEATURES PORTAGE_FEATURES'>)}
                          spids: [386]
                        )
                      ]
                    )
                  ]
                  spids: [373 383]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: (C {<has>} {<--filter-path>} {($ Id.VSub_Star '$*')})
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:filtered_vars)
                          op: assign_op.PlusEqual
                          rhs: {(DQ <' PATH'>)}
                          spids: [411]
                        )
                      ]
                    )
                  ]
                  spids: [398 408]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: (C {<has>} {<--filter-locale>} {($ Id.VSub_Star '$*')})
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:filtered_vars)
                          op: assign_op.PlusEqual
                          rhs: 
                            {
                              (DQ <' LANG LC_ALL LC_COLLATE\n'> 
                                <'\t\t\tLC_CTYPE LC_MESSAGES LC_MONETARY\n'> <'\t\t\tLC_NUMERIC LC_PAPER LC_TIME'>
                              )
                            }
                          spids: [433]
                        )
                      ]
                    )
                  ]
                  spids: [420 430]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.Pipeline
                              children: [(C {<has>} {<--allow-extra-vars>} {($ Id.VSub_Star '$*')})]
                              negated: T
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<Id.Lit_LBracket '['>} {(DQ (${ Id.VSub_Name EMERGE_FROM))} 
                                      {<Id.Lit_Equals '='>} {<binary>} {<Id.Lit_RBracket ']'>}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:filtered_vars)
                                  op: assign_op.PlusEqual
                                  rhs: {(DQ <' '> (${ Id.VSub_Name binpkg_untrusted_vars))}
                                  spids: [488]
                                )
                              ]
                            )
                          ]
                          spids: [459 477]
                        )
                      ]
                      else_action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:filtered_vars)
                              op: assign_op.PlusEqual
                              rhs: {(DQ <' '> (${ Id.VSub_Name PORTAGE_SAVED_READONLY_VARS))}
                              spids: [500]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:filtered_vars)
                              op: assign_op.PlusEqual
                              rhs: {(DQ <' '> (${ Id.VSub_Name PORTAGE_MUTABLE_FILTERED_VARS))}
                              spids: [509]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [444 456]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C 
                  {
                    (DQ 
                      (braced_var_sub
                        token: <Id.VSub_Name PORTAGE_PYTHON>
                        suffix_op: 
                          (suffix_op.Unary
                            op_id: Id.VTest_ColonHyphen
                            arg_word: 
                              {<Id.Lit_Slash '/'> <usr> <Id.Lit_Slash '/'> <bin> <Id.Lit_Slash '/'> 
                                <python>
                              }
                          )
                      )
                    )
                  } {(DQ (${ Id.VSub_Name PORTAGE_BIN_PATH)) <'/filter-bash-environment.py'>} 
                  {(DQ (${ Id.VSub_Name filtered_vars))}
                )
                (C {<die>} {(DQ <'filter-bash-environment.py failed'>)})
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: __preprocess_ebuild_env
      body: 
        (BraceGroup
          children: [
            (C {<local>} 
              {<Id.Lit_VarLike '_portage_filter_opts='> 
                (DQ <'--filter-features --filter-locale --filter-path --filter-sandbox'>)
              }
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<Id.Lit_LBracket '['>} {<-f>} {(DQ (${ Id.VSub_Name T) <'/environment.raw'>)} 
                  {<Id.Lit_RBracket ']'>}
                )
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {<0>}
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.Simple
                  words: [
                    {<__filter_readonly_variables>}
                    {($ Id.VSub_DollarName '$_portage_filter_opts')}
                  ]
                  redirects: [
                    (redir
                      op: <Id.Redir_Less '<'>
                      loc: (redir_loc.Fd fd:0)
                      arg: {(DQ (${ Id.VSub_Name T)) <'/environment'>}
                    )
                    (redir
                      op: <Id.Redir_DGreat '>>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {(DQ ($ Id.VSub_DollarName '$T') <'/environment.filtered'>)}
                    )
                  ]
                  do_fork: T
                )
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {($ Id.VSub_QMark '$?')}
                )
              ]
            )
            (C {<unset>} {<_portage_filter_opts>})
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<mv>} {(DQ (${ Id.VSub_Name T)) <'/environment.filtered'>} 
                  {(DQ (${ Id.VSub_Name T)) <'/environment'>}
                )
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {($ Id.VSub_QMark '$?')}
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<rm>} {<-f>} {(DQ (${ Id.VSub_Name T) <'/environment.success'>)})
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {($ Id.VSub_QMark '$?')}
                )
              ]
            )
            (command.Subshell
              child: 
                (command.CommandList
                  children: [
                    (C {<export>} {<Id.Lit_VarLike 'SANDBOX_ON='> <1>})
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<source>} {(DQ (${ Id.VSub_Name T) <'/environment'>)})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Exit exit>
                          arg_word: {($ Id.VSub_QMark '$?')}
                        )
                      ]
                    )
                    (C {<export>} {<Id.Lit_VarLike 'SANDBOX_ON='> <0>})
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<source>} {(DQ (${ Id.VSub_Name PORTAGE_BIN_PATH) <'/save-ebuild-env.sh'>)})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Exit exit>
                          arg_word: {($ Id.VSub_QMark '$?')}
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<__save_ebuild_env>})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Exit exit>
                          arg_word: {($ Id.VSub_QMark '$?')}
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (command.Simple
                          redirects: [
                            (redir
                              op: <Id.Redir_DGreat '>>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {(DQ ($ Id.VSub_DollarName '$T') <'/environment.success'>)}
                            )
                          ]
                          do_fork: F
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Exit exit>
                          arg_word: {($ Id.VSub_QMark '$?')}
                        )
                      ]
                    )
                  ]
                )
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ (${ Id.VSub_Name T) <'/environment.filtered'>)}
                )
              ]
            )
            (C {<local>} {<retval>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {<-e>} 
                              {(DQ (${ Id.VSub_Name T) <'/environment.success'>)} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.Simple
                      words: [{<__filter_readonly_variables>} {<--filter-features>}]
                      redirects: [
                        (redir
                          op: <Id.Redir_Less '<'>
                          loc: (redir_loc.Fd fd:0)
                          arg: {(DQ (${ Id.VSub_Name T) <'/environment.filtered'>)}
                        )
                        (redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(DQ (${ Id.VSub_Name T) <'/environment'>)}
                        )
                      ]
                      do_fork: T
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:retval)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_QMark '$?')}
                          spids: [901]
                        )
                      ]
                    )
                  ]
                  spids: [856 873]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:retval)
                      op: assign_op.Equal
                      rhs: {<1>}
                      spids: [908]
                    )
                  ]
                )
              ]
            )
            (C {<rm>} {<-f>} 
              (word.BracedTree
                parts: [
                  (DQ (${ Id.VSub_Name T))
                  <'/environment.'>
                  (word_part.BracedTuple words:[{<filtered>} {<raw>} {<success>}])
                ]
              )
            )
            (command.ControlFlow
              token: <Id.ControlFlow_Return return>
              arg_word: {(${ Id.VSub_Name retval)}
            )
          ]
        )
    )
    (command.ShFunction
      name: __ebuild_phase
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.Simple
                  words: [{<declare>} {<-F>} {(DQ ($ Id.VSub_Number '$1'))}]
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {<'/dev/null'>}
                    )
                  ]
                  do_fork: T
                )
                (C {<__qa_call>} {($ Id.VSub_Number '$1')})
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: __ebuild_phase_with_hooks
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<x>} {<Id.Lit_VarLike 'phase_name='> (${ Id.VSub_Number 1)})
            (command.ForEach
              iter_name: x
              iter_words: [
                (word.BracedTree
                  parts: [
                    (word_part.BracedTuple words:[{<pre_>} {} {<post_>}])
                    (${ Id.VSub_Name phase_name)
                  ]
                )
              ]
              do_arg_iter: F
              body: (command.DoGroup children:[(C {<__ebuild_phase>} {(${ Id.VSub_Name x)})])
            )
          ]
        )
    )
    (command.ShFunction
      name: __dyn_pretend
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_e
                                  child: {($ Id.VSub_DollarName '$PORTAGE_BUILDDIR') <'/.pretended'>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<__vecho>} 
                      {
                        (DQ <'>>> It appears that \''> ($ Id.VSub_DollarName '$PF') 
                          <'\' is already pretended; skipping.'>
                        )
                      }
                    )
                    (C {<__vecho>} 
                      {
                        (DQ <'>>> Remove \''> ($ Id.VSub_DollarName '$PORTAGE_BUILDDIR') 
                          <'/.pretended\' to force pretend.'>
                        )
                      }
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [1027 1040]
                )
              ]
            )
            (C {<__ebuild_phase>} {<pre_pkg_pretend>})
            (C {<__ebuild_phase>} {<pkg_pretend>})
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.Simple
                  redirects: [
                    (redir
                      op: <Id.Redir_DGreat '>>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {(DQ ($ Id.VSub_DollarName '$PORTAGE_BUILDDIR') <'/.pretended'>)}
                    )
                  ]
                  do_fork: F
                )
                (C {<die>} 
                  {
                    (DQ <'Failed to create '> ($ Id.VSub_DollarName '$PORTAGE_BUILDDIR') 
                      <'/.pretended'>
                    )
                  }
                )
              ]
            )
            (C {<__ebuild_phase>} {<post_pkg_pretend>})
          ]
        )
    )
    (command.ShFunction
      name: __dyn_setup
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_e
                                  child: {($ Id.VSub_DollarName '$PORTAGE_BUILDDIR') <'/.setuped'>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<__vecho>} 
                      {
                        (DQ <'>>> It appears that \''> ($ Id.VSub_DollarName '$PF') 
                          <'\' is already setup; skipping.'>
                        )
                      }
                    )
                    (C {<__vecho>} 
                      {
                        (DQ <'>>> Remove \''> ($ Id.VSub_DollarName '$PORTAGE_BUILDDIR') 
                          <'/.setuped\' to force setup.'>
                        )
                      }
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [1113 1126]
                )
              ]
            )
            (C {<__ebuild_phase>} {<pre_pkg_setup>})
            (C {<__ebuild_phase>} {<pkg_setup>})
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.Simple
                  redirects: [
                    (redir
                      op: <Id.Redir_DGreat '>>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {(DQ ($ Id.VSub_DollarName '$PORTAGE_BUILDDIR') <'/.setuped'>)}
                    )
                  ]
                  do_fork: F
                )
                (C {<die>} 
                  {
                    (DQ <'Failed to create '> ($ Id.VSub_DollarName '$PORTAGE_BUILDDIR') <'/.setuped'>)
                  }
                )
              ]
            )
            (C {<__ebuild_phase>} {<post_pkg_setup>})
          ]
        )
    )
    (command.ShFunction
      name: __dyn_unpack
      body: 
        (BraceGroup
          children: [
            (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 PORTAGE_BUILDDIR) <'/.unpacked'>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<__vecho>} {(DQ <'>>> WORKDIR is up-to-date, keeping...'>)})
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [1199 1214]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {<Id.KW_Bang '!'>} {<-d>} 
                              {(DQ (${ Id.VSub_Name WORKDIR))} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<install>} 
                          {<-m> 
                            (braced_var_sub
                              token: <Id.VSub_Name PORTAGE_WORKDIR_MODE>
                              suffix_op: (suffix_op.Unary op_id:Id.VTest_ColonHyphen arg_word:{<0700>})
                            )
                          } {<-d>} {(DQ (${ Id.VSub_Name WORKDIR))}
                        )
                        (C {<die>} {(DQ <'Failed to create dir \''> (${ Id.VSub_Name WORKDIR) <'\''>)})
                      ]
                    )
                  ]
                  spids: [1232 1249]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<cd>} {(DQ (${ Id.VSub_Name WORKDIR))})
                (C {<die>} 
                  {
                    (DQ <'Directory change failed: '> 
                      (word_part.EscapedLiteral
                        token: <Id.Lit_EscapedChar '\\`'>
                      ) <'cd \''> (${ Id.VSub_Name WORKDIR) <'\''> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\`'>)
                    )
                  }
                )
              ]
            )
            (C {<__ebuild_phase>} {<pre_src_unpack>})
            (C {<__vecho>} {(DQ <'>>> Unpacking source...'>)})
            (C {<__ebuild_phase>} {<src_unpack>})
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.Simple
                  redirects: [
                    (redir
                      op: <Id.Redir_DGreat '>>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {(DQ ($ Id.VSub_DollarName '$PORTAGE_BUILDDIR') <'/.unpacked'>)}
                    )
                  ]
                  do_fork: F
                )
                (C {<die>} 
                  {
                    (DQ <'Failed to create '> ($ Id.VSub_DollarName '$PORTAGE_BUILDDIR') <'/.unpacked'>)
                  }
                )
              ]
            )
            (C {<__vecho>} {(DQ <'>>> Source unpacked in '> (${ Id.VSub_Name WORKDIR))})
            (C {<__ebuild_phase>} {<post_src_unpack>})
          ]
        )
    )
    (command.ShFunction
      name: __dyn_clean
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {<-z>} {(DQ (${ Id.VSub_Name PORTAGE_BUILDDIR))} 
                              {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<echo>} {(DQ <'Aborting clean phase because PORTAGE_BUILDDIR is unset!'>)})
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<1>}
                    )
                  ]
                  spids: [1370 1385]
                )
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {<Id.KW_Bang '!'>} {<-d>} 
                              {(DQ (${ Id.VSub_Name PORTAGE_BUILDDIR))} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<0>})]
                  spids: [1400 1418]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: (C {<has>} {<chflags>} {($ Id.VSub_DollarName '$FEATURES')})
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<chflags>} {<-R>} 
                      {<noschg> <Id.Lit_Comma ','> <nouchg> <Id.Lit_Comma ','> <nosappnd> 
                        <Id.Lit_Comma ','> <nouappnd>
                      } {(DQ (${ Id.VSub_Name PORTAGE_BUILDDIR))}
                    )
                    (command.Simple
                      words: [
                        {<chflags>}
                        {<-R>}
                        {<nosunlnk> <Id.Lit_Comma ','> <nouunlnk>}
                        {(DQ (${ Id.VSub_Name PORTAGE_BUILDDIR))}
                      ]
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '2>'>
                          loc: (redir_loc.Fd fd:2)
                          arg: {<'/dev/null'>}
                        )
                      ]
                      do_fork: T
                    )
                  ]
                  spids: [1429 1439]
                )
              ]
            )
            (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 {<rm>} {<-rf>} {(DQ (${ Id.VSub_Name PORTAGE_BUILDDIR) <'/image'>)} 
              {(DQ (${ Id.VSub_Name PORTAGE_BUILDDIR) <'/homedir'>)}
            )
            (C {<rm>} {<-f>} {(DQ (${ Id.VSub_Name PORTAGE_BUILDDIR) <'/.installed'>)})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.AndOr
                              ops: [Id.Op_DPipe Id.Op_DAmp]
                              children: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_GlobEqual
                                      left: {($ Id.VSub_DollarName '$EMERGE_FROM')}
                                      right: {<binary>}
                                    )
                                )
                                (command.Pipeline
                                  children: [
                                    (C {<has>} {<keeptemp>} {($ Id.VSub_DollarName '$FEATURES')})
                                  ]
                                  negated: T
                                )
                                (command.Pipeline
                                  children: [
                                    (C {<has>} {<keepwork>} {($ Id.VSub_DollarName '$FEATURES')})
                                  ]
                                  negated: T
                                )
                              ]
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<rm>} {<-rf>} {(DQ (${ Id.VSub_Name T))})]
                  spids: [1547 1583]
                )
              ]
            )
            (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_GlobEqual
                                      left: {($ Id.VSub_DollarName '$EMERGE_FROM')}
                                      right: {<binary>}
                                    )
                                )
                                (command.Pipeline
                                  children: [
                                    (C {<has>} {<keepwork>} {($ Id.VSub_DollarName '$FEATURES')})
                                  ]
                                  negated: T
                                )
                              ]
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<rm>} {<-f>} 
                      (word.BracedTree
                        parts: [
                          (DQ ($ Id.VSub_DollarName '$PORTAGE_BUILDDIR'))
                          <'/.'>
                          (word_part.BracedTuple
                            words: [
                              {<ebuild_changed>}
                              {<logid>}
                              {<pretended>}
                              {<setuped>}
                              {<unpacked>}
                              {<prepared>}
                            ]
                          )
                        ]
                      ) 
                      (word.BracedTree
                        parts: [
                          (DQ ($ Id.VSub_DollarName '$PORTAGE_BUILDDIR'))
                          <'/.'>
                          (word_part.BracedTuple
                            words: [{<configured>} {<compiled>} {<tested>} {<packaged>}]
                          )
                        ]
                      ) {(DQ ($ Id.VSub_DollarName '$PORTAGE_BUILDDIR')) <'/.die_hooks'>} 
                      (word.BracedTree
                        parts: [
                          (DQ ($ Id.VSub_DollarName '$PORTAGE_BUILDDIR'))
                          <'/.ipc_'>
                          (word_part.BracedTuple
                            words: [{<Id.KW_In in>} {<out>} {<lock>}]
                          )
                        ]
                      ) {(DQ ($ Id.VSub_DollarName '$PORTAGE_BUILDDIR')) <'/.exit_status'>}
                    )
                    (C {<rm>} {<-rf>} {(DQ (${ Id.VSub_Name PORTAGE_BUILDDIR) <'/build-info'>)})
                    (C {<rm>} {<-rf>} {(DQ (${ Id.VSub_Name WORKDIR))})
                    (C {<rm>} {<-f>} {(DQ (${ Id.VSub_Name PORTAGE_BUILDDIR) <'/files'>)})
                  ]
                  spids: [1601 1624]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {<-f>} 
                              {(DQ (${ Id.VSub_Name PORTAGE_BUILDDIR) <'/.unpacked'>)} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.Pipeline
                      children: [
                        (C {<find>} {(DQ (${ Id.VSub_Name PORTAGE_BUILDDIR))} {<-type>} {<d>} 
                          {<Id.KW_Bang '!'>} {<-regex>} {(DQ <'^'> (${ Id.VSub_Name WORKDIR))}
                        )
                        (C {<sort>} {<-r>})
                        (C {<tr>} {(DQ <Id.Lit_BadBackslash '\\'> <n>)} 
                          {(DQ <Id.Lit_BadBackslash '\\'> <0>)}
                        )
                        (command.Simple
                          words: [{($ Id.VSub_DollarName '$XARGS')} {<-0>} {<rmdir>}]
                          redirects: [
                            (redir
                              op: <Id.Redir_AndGreat '&>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<'/dev/null'>}
                            )
                          ]
                          do_fork: T
                        )
                      ]
                      negated: F
                    )
                  ]
                  spids: [1734 1750]
                )
              ]
            )
            (C {<rm>} {<-rf>} {(DQ (${ Id.VSub_Name PORTAGE_BUILDDIR) <'/distdir'>)})
            (command.Simple
              words: [{<rmdir>} {(DQ ($ Id.VSub_DollarName '$PORTAGE_BUILDDIR'))}]
              redirects: [(redir op:<Id.Redir_Great '2>'> loc:(redir_loc.Fd fd:2) arg:{<'/dev/null'>})]
              do_fork: T
            )
            (C {<true>})
          ]
        )
    )
    (command.ShFunction
      name: __abort_handler
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<msg>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_Number '$2'))} 
                              {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ <fail>)} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:msg)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ (${ Id.VSub_Name EBUILD) <': '> (${ Id.VSub_Number 1) 
                                <' aborted; exiting.'>
                              )
                            }
                          spids: [1882]
                        )
                      ]
                    )
                  ]
                  spids: [1861 1879]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:msg)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (DQ (${ Id.VSub_Name EBUILD) <': '> (${ Id.VSub_Number 1) 
                            <' failed; exiting.'>
                          )
                        }
                      spids: [1898]
                    )
                  ]
                )
              ]
            )
            (C {<echo>})
            (C {<echo>} {(DQ ($ Id.VSub_DollarName '$msg'))})
            (C {<echo>})
            (C {<eval>} {(${ Id.VSub_Number 3)})
            (C {<trap>} {<->} {<SIGINT>} {<SIGQUIT>})
          ]
        )
    )
    (command.ShFunction
      name: __abort_prepare
      body: 
        (BraceGroup
          children: [
            (C {<__abort_handler>} {<src_prepare>} {($ Id.VSub_Number '$1')})
            (C {<rm>} {<-f>} {(DQ ($ Id.VSub_DollarName '$PORTAGE_BUILDDIR') <'/.prepared'>)})
            (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
          ]
        )
    )
    (command.ShFunction
      name: __abort_configure
      body: 
        (BraceGroup
          children: [
            (C {<__abort_handler>} {<src_configure>} {($ Id.VSub_Number '$1')})
            (C {<rm>} {<-f>} {(DQ ($ Id.VSub_DollarName '$PORTAGE_BUILDDIR') <'/.configured'>)})
            (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
          ]
        )
    )
    (command.ShFunction
      name: __abort_compile
      body: 
        (BraceGroup
          children: [
            (C {<__abort_handler>} {(DQ <src_compile>)} {($ Id.VSub_Number '$1')})
            (C {<rm>} {<-f>} {(DQ (${ Id.VSub_Name PORTAGE_BUILDDIR) <'/.compiled'>)})
            (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
          ]
        )
    )
    (command.ShFunction
      name: __abort_test
      body: 
        (BraceGroup
          children: [
            (C {<__abort_handler>} {(DQ <__dyn_test>)} {($ Id.VSub_Number '$1')})
            (C {<rm>} {<-f>} {(DQ (${ Id.VSub_Name PORTAGE_BUILDDIR) <'/.tested'>)})
            (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
          ]
        )
    )
    (command.ShFunction
      name: __abort_install
      body: 
        (BraceGroup
          children: [
            (C {<__abort_handler>} {(DQ <src_install>)} {($ Id.VSub_Number '$1')})
            (C {<rm>} {<-rf>} {(DQ (${ Id.VSub_Name PORTAGE_BUILDDIR) <'/image'>)})
            (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
          ]
        )
    )
    (command.ShFunction
      name: __has_phase_defined_up_to
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<phase>})
            (command.ForEach
              iter_name: phase
              iter_words: [{<unpack>} {<prepare>} {<configure>} {<compile>} {<install>}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<has>} {(${ Id.VSub_Name phase)} {(${ Id.VSub_Name DEFINED_PHASES)})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<0>}
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobDEqual
                              left: {(${ Id.VSub_Name phase)}
                              right: {($ Id.VSub_Number '$1')}
                            )
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<1>}
                        )
                      ]
                    )
                  ]
                )
            )
            (command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<1>})
          ]
        )
    )
    (command.ShFunction
      name: __dyn_prepare
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_e
                                  child: {($ Id.VSub_DollarName '$PORTAGE_BUILDDIR') <'/.prepared'>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<__vecho>} 
                      {
                        (DQ <'>>> It appears that \''> ($ Id.VSub_DollarName '$PF') 
                          <'\' is already prepared; skipping.'>
                        )
                      }
                    )
                    (C {<__vecho>} 
                      {
                        (DQ <'>>> Remove \''> ($ Id.VSub_DollarName '$PORTAGE_BUILDDIR') 
                          <'/.prepared\' to force prepare.'>
                        )
                      }
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [2206 2219]
                )
              ]
            )
            (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_DollarName '$S')}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<cd>} {(DQ (${ Id.VSub_Name S))})]
                  spids: [2249 2261]
                )
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: (C {<___eapi_has_S_WORKDIR_fallback>})
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<cd>} {(DQ (${ Id.VSub_Name WORKDIR))})]
                  spids: [2273 2278]
                )
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Unary
                                      op_id: Id.BoolUnary_z
                                      child: {(${ Id.VSub_Name A)}
                                    )
                                )
                                (command.Pipeline
                                  children: [(C {<__has_phase_defined_up_to>} {<prepare>})]
                                  negated: T
                                )
                              ]
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<cd>} {(DQ (${ Id.VSub_Name WORKDIR))})]
                  spids: [2290 2311]
                )
              ]
              else_action: [
                (C {<die>} {(DQ <'The source directory \''> (${ Id.VSub_Name S) <'\' doesn\'t exist'>)})
              ]
            )
            (C {<trap>} {<__abort_prepare>} {<SIGINT>} {<SIGQUIT>})
            (C {<__ebuild_phase>} {<pre_src_prepare>})
            (C {<__vecho>} {(DQ <'>>> Preparing source in '> ($ Id.VSub_DollarName '$PWD') <' ...'>)})
            (C {<__ebuild_phase>} {<src_prepare>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<___eapi_has_eapply_user>})
                                (command.DBracket
                                  expr: 
                                    (bool_expr.LogicalNot
                                      child: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_f
                                          child: 
                                            {(${ Id.VSub_Name T) <'/.portage_user_patches_applied'>}
                                        )
                                    )
                                )
                              ]
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<die>} {(DQ <'eapply_user (or default) must be called in src_prepare()!'>)})
                  ]
                  spids: [2375 2395]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.Simple
                  redirects: [
                    (redir
                      op: <Id.Redir_DGreat '>>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {(DQ ($ Id.VSub_DollarName '$PORTAGE_BUILDDIR') <'/.prepared'>)}
                    )
                  ]
                  do_fork: F
                )
                (C {<die>} 
                  {
                    (DQ <'Failed to create '> ($ Id.VSub_DollarName '$PORTAGE_BUILDDIR') <'/.prepared'>)
                  }
                )
              ]
            )
            (C {<__vecho>} {(DQ <'>>> Source prepared.'>)})
            (C {<__ebuild_phase>} {<post_src_prepare>})
            (C {<trap>} {<->} {<SIGINT>} {<SIGQUIT>})
          ]
        )
    )
    (command.ShFunction
      name: __start_distcc
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<has>} {<distcc>} {($ Id.VSub_DollarName '$FEATURES')})
                                (C {<has>} {<distcc-pump>} {($ Id.VSub_DollarName '$FEATURES')})
                              ]
                            )
                          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.Unary
                                              op_id: Id.BoolUnary_z
                                              child: {($ Id.VSub_DollarName '$INCLUDE_SERVER_PORT')}
                                            )
                                        )
                                        (command.DBracket
                                          expr: 
                                            (bool_expr.LogicalNot
                                              child: 
                                                (bool_expr.Unary
                                                  op_id: Id.BoolUnary_w
                                                  child: 
                                                    {($ Id.VSub_DollarName '$INCLUDE_SERVER_PORT')}
                                                )
                                            )
                                        )
                                      ]
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<eval>} 
                              {
                                (command_sub
                                  left_token: <Id.Left_DollarParen '$('>
                                  child: 
                                    (command.Pipeline
                                      children: [(C {<pump>} {<--startup>}) (C {<grep>} {<-v>} {<PATH>})]
                                      negated: F
                                    )
                                )
                              }
                            )
                            (C {<trap>} {(DQ <'pump --shutdown >/dev/null'>)} {<EXIT>})
                          ]
                          spids: [2490 2514]
                        )
                      ]
                    )
                  ]
                  spids: [2469 2487]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: __dyn_configure
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_e
                                  child: {($ Id.VSub_DollarName '$PORTAGE_BUILDDIR') <'/.configured'>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<__vecho>} 
                      {
                        (DQ <'>>> It appears that \''> ($ Id.VSub_DollarName '$PF') 
                          <'\' is already configured; skipping.'>
                        )
                      }
                    )
                    (C {<__vecho>} 
                      {
                        (DQ <'>>> Remove \''> ($ Id.VSub_DollarName '$PORTAGE_BUILDDIR') 
                          <'/.configured\' to force configuration.'>
                        )
                      }
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [2563 2576]
                )
              ]
            )
            (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_DollarName '$S')}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<cd>} {(DQ (${ Id.VSub_Name S))})]
                  spids: [2606 2618]
                )
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: (C {<___eapi_has_S_WORKDIR_fallback>})
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<cd>} {(DQ (${ Id.VSub_Name WORKDIR))})]
                  spids: [2630 2635]
                )
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Unary
                                      op_id: Id.BoolUnary_z
                                      child: {(${ Id.VSub_Name A)}
                                    )
                                )
                                (command.Pipeline
                                  children: [(C {<__has_phase_defined_up_to>} {<configure>})]
                                  negated: T
                                )
                              ]
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<cd>} {(DQ (${ Id.VSub_Name WORKDIR))})]
                  spids: [2647 2668]
                )
              ]
              else_action: [
                (C {<die>} {(DQ <'The source directory \''> (${ Id.VSub_Name S) <'\' doesn\'t exist'>)})
              ]
            )
            (C {<trap>} {<__abort_configure>} {<SIGINT>} {<SIGQUIT>})
            (C {<__start_distcc>})
            (C {<__ebuild_phase>} {<pre_src_configure>})
            (C {<__vecho>} {(DQ <'>>> Configuring source in '> ($ Id.VSub_DollarName '$PWD') <' ...'>)})
            (C {<__ebuild_phase>} {<src_configure>})
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.Simple
                  redirects: [
                    (redir
                      op: <Id.Redir_DGreat '>>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {(DQ ($ Id.VSub_DollarName '$PORTAGE_BUILDDIR') <'/.configured'>)}
                    )
                  ]
                  do_fork: F
                )
                (C {<die>} 
                  {
                    (DQ <'Failed to create '> ($ Id.VSub_DollarName '$PORTAGE_BUILDDIR') 
                      <'/.configured'>
                    )
                  }
                )
              ]
            )
            (C {<__vecho>} {(DQ <'>>> Source configured.'>)})
            (C {<__ebuild_phase>} {<post_src_configure>})
            (C {<trap>} {<->} {<SIGINT>} {<SIGQUIT>})
          ]
        )
    )
    (command.ShFunction
      name: __dyn_compile
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_e
                                  child: {($ Id.VSub_DollarName '$PORTAGE_BUILDDIR') <'/.compiled'>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<__vecho>} 
                      {
                        (DQ <'>>> It appears that \''> (${ Id.VSub_Name PF) 
                          <'\' is already compiled; skipping.'>
                        )
                      }
                    )
                    (C {<__vecho>} 
                      {
                        (DQ <'>>> Remove \''> ($ Id.VSub_DollarName '$PORTAGE_BUILDDIR') 
                          <'/.compiled\' to force compilation.'>
                        )
                      }
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [2784 2797]
                )
              ]
            )
            (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_DollarName '$S')}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<cd>} {(DQ (${ Id.VSub_Name S))})]
                  spids: [2829 2841]
                )
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: (C {<___eapi_has_S_WORKDIR_fallback>})
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<cd>} {(DQ (${ Id.VSub_Name WORKDIR))})]
                  spids: [2853 2858]
                )
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Unary
                                      op_id: Id.BoolUnary_z
                                      child: {(${ Id.VSub_Name A)}
                                    )
                                )
                                (command.Pipeline
                                  children: [(C {<__has_phase_defined_up_to>} {<compile>})]
                                  negated: T
                                )
                              ]
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<cd>} {(DQ (${ Id.VSub_Name WORKDIR))})]
                  spids: [2870 2891]
                )
              ]
              else_action: [
                (C {<die>} {(DQ <'The source directory \''> (${ Id.VSub_Name S) <'\' doesn\'t exist'>)})
              ]
            )
            (C {<trap>} {<__abort_compile>} {<SIGINT>} {<SIGQUIT>})
            (C {<__start_distcc>})
            (C {<__ebuild_phase>} {<pre_src_compile>})
            (C {<__vecho>} {(DQ <'>>> Compiling source in '> ($ Id.VSub_DollarName '$PWD') <' ...'>)})
            (C {<__ebuild_phase>} {<src_compile>})
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.Simple
                  redirects: [
                    (redir
                      op: <Id.Redir_DGreat '>>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {(DQ ($ Id.VSub_DollarName '$PORTAGE_BUILDDIR') <'/.compiled'>)}
                    )
                  ]
                  do_fork: F
                )
                (C {<die>} 
                  {
                    (DQ <'Failed to create '> ($ Id.VSub_DollarName '$PORTAGE_BUILDDIR') <'/.compiled'>)
                  }
                )
              ]
            )
            (C {<__vecho>} {(DQ <'>>> Source compiled.'>)})
            (C {<__ebuild_phase>} {<post_src_compile>})
            (C {<trap>} {<->} {<SIGINT>} {<SIGQUIT>})
          ]
        )
    )
    (command.ShFunction
      name: __dyn_test
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_e
                                  child: {($ Id.VSub_DollarName '$PORTAGE_BUILDDIR') <'/.tested'>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<__vecho>} 
                      {
                        (DQ <'>>> It appears that '> (${ Id.VSub_Name PN) 
                          <' has already been tested; skipping.'>
                        )
                      }
                    )
                    (C {<__vecho>} 
                      {
                        (DQ <'>>> Remove \''> (${ Id.VSub_Name PORTAGE_BUILDDIR) 
                          <'/.tested\' to force test.'>
                        )
                      }
                    )
                    (command.ControlFlow token:<Id.ControlFlow_Return return>)
                  ]
                  spids: [3007 3020]
                )
              ]
            )
            (C {<trap>} {(DQ <__abort_test>)} {<SIGINT>} {<SIGQUIT>})
            (C {<__start_distcc>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {<-d>} {(DQ (${ Id.VSub_Name S))} 
                              {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<cd>} {(DQ (${ Id.VSub_Name S))})]
                  spids: [3067 3082]
                )
              ]
              else_action: [(C {<cd>} {(DQ (${ Id.VSub_Name WORKDIR))})]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: (C {<has>} {<test>} {(${ Id.VSub_Name RESTRICT)})
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<einfo>} {(DQ <'Skipping make test/check due to ebuild restriction.'>)})
                    (C {<__vecho>} 
                      {
                        (DQ <'>>> Test phase [disabled because of RESTRICT=test]: '> 
                          (${ Id.VSub_Name CATEGORY) <'/'> (${ Id.VSub_Name PF)
                        )
                      }
                    )
                  ]
                  spids: [3110 3122]
                )
                (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_GlobNEqual
                                      left: {(${ Id.VSub_Name EBUILD_FORCE_TEST)}
                                      right: {<1>}
                                    )
                                )
                                (command.Pipeline
                                  children: [(C {<has>} {<test>} {(${ Id.VSub_Name FEATURES)})]
                                  negated: T
                                )
                              ]
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<__vecho>} 
                      {
                        (DQ <'>>> Test phase [not enabled]: '> (${ Id.VSub_Name CATEGORY) <'/'> 
                          (${ Id.VSub_Name PF)
                        )
                      }
                    )
                  ]
                  spids: [3155 3183]
                )
              ]
              else_action: [
                (C {<local>} {<Id.Lit_VarLike 'save_sp='> (${ Id.VSub_Name SANDBOX_PREDICT)})
                (C {<addpredict>} {<'/'>})
                (C {<__ebuild_phase>} {<pre_src_test>})
                (C {<__vecho>} 
                  {(DQ <'>>> Test phase: '> (${ Id.VSub_Name CATEGORY) <'/'> (${ Id.VSub_Name PF))}
                )
                (C {<__ebuild_phase>} {<src_test>})
                (C {<__vecho>} 
                  {
                    (DQ <'>>> Completed testing '> (${ Id.VSub_Name CATEGORY) <'/'> (${ Id.VSub_Name PF))
                  }
                )
                (command.AndOr
                  ops: [Id.Op_DPipe]
                  children: [
                    (command.Simple
                      redirects: [
                        (redir
                          op: <Id.Redir_DGreat '>>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(DQ ($ Id.VSub_DollarName '$PORTAGE_BUILDDIR') <'/.tested'>)}
                        )
                      ]
                      do_fork: F
                    )
                    (C {<die>} 
                      {
                        (DQ <'Failed to create '> ($ Id.VSub_DollarName '$PORTAGE_BUILDDIR') 
                          <'/.tested'>
                        )
                      }
                    )
                  ]
                )
                (C {<__ebuild_phase>} {<post_src_test>})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:SANDBOX_PREDICT)
                      op: assign_op.Equal
                      rhs: {(${ Id.VSub_Name save_sp)}
                      spids: [3281]
                    )
                  ]
                )
              ]
            )
            (C {<trap>} {<->} {<SIGINT>} {<SIGQUIT>})
          ]
        )
    )
    (command.ShFunction
      name: __dyn_install
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {<-z>} {(DQ ($ Id.VSub_DollarName '$PORTAGE_BUILDDIR'))} 
                  {<Id.Lit_RBracket ']'>}
                )
                (C {<die>} {(DQ (${ Id.VSub_Name FUNCNAME) <': PORTAGE_BUILDDIR is unset'>)})
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: (C {<has>} {<noauto>} {($ Id.VSub_DollarName '$FEATURES')})
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<rm>} {<-f>} {(DQ (${ Id.VSub_Name PORTAGE_BUILDDIR) <'/.installed'>)})]
                  spids: [3331 3341]
                )
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_e
                                  child: {($ Id.VSub_DollarName '$PORTAGE_BUILDDIR') <'/.installed'>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<__vecho>} 
                      {
                        (DQ <'>>> It appears that \''> (${ Id.VSub_Name PF) 
                          <'\' is already installed; skipping.'>
                        )
                      }
                    )
                    (C {<__vecho>} 
                      {
                        (DQ <'>>> Remove \''> (${ Id.VSub_Name PORTAGE_BUILDDIR) 
                          <'/.installed\' to force install.'>
                        )
                      }
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [3356 3369]
                )
              ]
            )
            (C {<trap>} {(DQ <__abort_install>)} {<SIGINT>} {<SIGQUIT>})
            (C {<__start_distcc>})
            (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 '$QA_PREBUILT')}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:QA_EXECSTACK)
                          op: assign_op.PlusEqual
                          rhs: {(DQ <' '> ($ Id.VSub_DollarName '$QA_PREBUILT'))}
                          spids: [3452]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:QA_TEXTRELS)
                          op: assign_op.PlusEqual
                          rhs: {(DQ <' '> ($ Id.VSub_DollarName '$QA_PREBUILT'))}
                          spids: [3459]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:QA_WX_LOAD)
                          op: assign_op.PlusEqual
                          rhs: {(DQ <' '> ($ Id.VSub_DollarName '$QA_PREBUILT'))}
                          spids: [3466]
                        )
                      ]
                    )
                    (command.ForEach
                      iter_name: x
                      iter_words: [{<QA_DT_NEEDED>} {<QA_FLAGS_IGNORED>} {<QA_PRESTRIPPED>} {<QA_SONAME>}]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (command.DBracket
                                              expr: 
                                                (bool_expr.Binary
                                                  op_id: Id.BoolBinary_GlobEqual
                                                  left: 
                                                    {
                                                      (command_sub
                                                        left_token: <Id.Left_DollarParen '$('>
                                                        child: 
                                                          (command.Simple
                                                            words: [
                                                              {<declare>}
                                                              {<-p>}
                                                              {($ Id.VSub_DollarName '$x')}
                                                            ]
                                                            redirects: [
                                                              (redir
                                                                op: <Id.Redir_Great '2>'>
                                                                loc: (redir_loc.Fd fd:2)
                                                                arg: {<'/dev/null'>}
                                                              )
                                                            ]
                                                            do_fork: T
                                                          )
                                                      )
                                                    }
                                                  right: 
                                                    {<declare> 
                                                      (word_part.EscapedLiteral
                                                        token: <Id.Lit_EscapedChar '\\ '>
                                                      ) <Id.BoolUnary_a -a> <Id.Lit_Other '*'>
                                                    }
                                                )
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (C {<eval>} 
                                      {
                                        (DQ ($ Id.VSub_DollarName '$x') <'=('> 
                                          (word_part.EscapedLiteral
                                            token: <Id.Lit_EscapedChar '\\"'>
                                          ) (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'{'> ($ Id.VSub_DollarName '$x') <'[@]}'> 
                                          (word_part.EscapedLiteral
                                            token: <Id.Lit_EscapedChar '\\"'>
                                          ) <' '> 
                                          (braced_var_sub
                                            token: <Id.VSub_Name QA_PREBUILT>
                                            suffix_op: 
                                              (suffix_op.PatSub
                                                pat: 
                                                  {
                                                    (word_part.EscapedLiteral
                                                      token: <Id.Lit_EscapedChar '\\*'>
                                                    )
                                                  }
                                                replace: {<'.*'>}
                                                replace_mode: Id.Lit_Slash
                                              )
                                          ) <')'>
                                        )
                                      }
                                    )
                                  ]
                                  spids: [3501 3527]
                                )
                              ]
                              else_action: [
                                (C {<eval>} 
                                  {
                                    (DQ ($ Id.VSub_DollarName '$x') <'+='> 
                                      (word_part.EscapedLiteral
                                        token: <Id.Lit_EscapedChar '\\"'>
                                      ) <' '> 
                                      (braced_var_sub
                                        token: <Id.VSub_Name QA_PREBUILT>
                                        suffix_op: 
                                          (suffix_op.PatSub
                                            pat: 
                                              {
                                                (word_part.EscapedLiteral
                                                  token: <Id.Lit_EscapedChar '\\*'>
                                                )
                                              }
                                            replace: {<'.*'>}
                                            replace_mode: Id.Lit_Slash
                                          )
                                      ) (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>)
                                    )
                                  }
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (C {<unset>} {<x>})
                  ]
                  spids: [3433 3445]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.Unary
                      op_id: Id.BoolUnary_n
                      child: {($ Id.VSub_DollarName '$QA_PRESTRIPPED')}
                    )
                )
                (C {<export>} {<QA_PRESTRIPPED>})
              ]
            )
            (C {<eval>} 
              {
                (DQ <'[[ -n '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) 
                  <QA_PRESTRIPPED_> 
                  (braced_var_sub
                    token: <Id.VSub_Name ARCH>
                    suffix_op: 
                      (suffix_op.PatSub
                        pat: {<->}
                        replace: {<_>}
                        replace_mode: Id.Undefined_Tok
                      )
                  ) <' ]] && '> <'\t\texport QA_PRESTRIPPED_'> 
                  (braced_var_sub
                    token: <Id.VSub_Name ARCH>
                    suffix_op: 
                      (suffix_op.PatSub
                        pat: {<->}
                        replace: {<_>}
                        replace_mode: Id.Undefined_Tok
                      )
                  )
                )
              }
            )
            (C {<__ebuild_phase>} {<pre_src_install>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: (C {<___eapi_has_prefix_variables>})
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:_x)
                          op: assign_op.Equal
                          rhs: {(${ Id.VSub_Name ED)}
                          spids: [3651]
                        )
                      ]
                    )
                  ]
                  spids: [3643 3648]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:_x)
                      op: assign_op.Equal
                      rhs: {(${ Id.VSub_Name D)}
                      spids: [3660]
                    )
                  ]
                )
              ]
            )
            (C {<rm>} {<-rf>} {(DQ (${ Id.VSub_Name D))})
            (C {<mkdir>} {<-p>} {(DQ (${ Id.VSub_Name _x))})
            (C {<unset>} {<_x>})
            (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_DollarName '$S')}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<cd>} {(DQ (${ Id.VSub_Name S))})]
                  spids: [3697 3709]
                )
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: (C {<___eapi_has_S_WORKDIR_fallback>})
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<cd>} {(DQ (${ Id.VSub_Name WORKDIR))})]
                  spids: [3721 3726]
                )
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Unary
                                      op_id: Id.BoolUnary_z
                                      child: {(${ Id.VSub_Name A)}
                                    )
                                )
                                (command.Pipeline
                                  children: [(C {<__has_phase_defined_up_to>} {<install>})]
                                  negated: T
                                )
                              ]
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<cd>} {(DQ (${ Id.VSub_Name WORKDIR))})]
                  spids: [3738 3759]
                )
              ]
              else_action: [
                (C {<die>} {(DQ <'The source directory \''> (${ Id.VSub_Name S) <'\' doesn\'t exist'>)})
              ]
            )
            (C {<__vecho>})
            (C {<__vecho>} 
              {
                (DQ <'>>> Install '> (${ Id.VSub_Name PF) <' into '> (${ Id.VSub_Name D) <' category '> 
                  (${ Id.VSub_Name CATEGORY)
                )
              }
            )
            (C {<export>} {<S>} {<D>})
            (C {<export>} {<Id.Lit_VarLike 'DESTTREE='> <'/usr'>})
            (C {<export>} {<Id.Lit_VarLike 'INSDESTTREE='> (DQ )})
            (C {<export>} {<Id.Lit_VarLike '_E_EXEDESTTREE_='> (DQ )})
            (C {<export>} {<Id.Lit_VarLike '_E_DOCDESTTREE_='> (DQ )})
            (C {<__ebuild_phase>} {<src_install>})
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.Simple
                  redirects: [
                    (redir
                      op: <Id.Redir_DGreat '>>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {(DQ ($ Id.VSub_DollarName '$PORTAGE_BUILDDIR') <'/.installed'>)}
                    )
                  ]
                  do_fork: F
                )
                (C {<die>} 
                  {
                    (DQ <'Failed to create '> ($ Id.VSub_DollarName '$PORTAGE_BUILDDIR') 
                      <'/.installed'>
                    )
                  }
                )
              ]
            )
            (C {<__vecho>} 
              {(DQ <'>>> Completed installing '> (${ Id.VSub_Name PF) <' into '> (${ Id.VSub_Name D))}
            )
            (C {<__vecho>})
            (C {<__ebuild_phase>} {<post_src_install>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.Simple
                              words: [{<type>} {<-P>} {<du>}]
                              redirects: [
                                (redir
                                  op: <Id.Redir_AndGreat '&>'>
                                  loc: (redir_loc.Fd fd:1)
                                  arg: {<'/dev/null'>}
                                )
                              ]
                              do_fork: T
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<local>} 
                      {<Id.Lit_VarLike 'nsz='> 
                        (sh_array_literal
                          left: <Id.Op_LParen _>
                          words: [
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: (C {<du>} {<-ks>} {(DQ (${ Id.VSub_Name WORKDIR))})
                              )
                            }
                          ]
                        )
                      }
                    )
                    (C {<local>} 
                      {<Id.Lit_VarLike 'isz='> 
                        (sh_array_literal
                          left: <Id.Op_LParen _>
                          words: [
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: (C {<du>} {<-ks>} {(DQ (${ Id.VSub_Name D))})
                              )
                            }
                          ]
                        )
                      }
                    )
                    (command.Subshell
                      child: 
                        (command.CommandList
                          children: [
                            (command.ShFunction
                              name: padl
                              body: 
                                (BraceGroup
                                  children: [
                                    (C {<local>} {<Id.Lit_VarLike 's1='> ($ Id.VSub_Number '$1')})
                                    (C {<local>} {<Id.Lit_VarLike 's2='> ($ Id.VSub_Number '$2')})
                                    (C {<local>} 
                                      {<Id.Lit_VarLike 'width='> 
                                        (braced_var_sub
                                          token: <Id.VSub_Name s1>
                                          prefix_op: (Id.VSub_Pound)
                                        )
                                      }
                                    )
                                    (command.AndOr
                                      ops: [Id.Op_DAmp]
                                      children: [
                                        (command.DBracket
                                          expr: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_gt
                                              left: 
                                                {
                                                  (braced_var_sub
                                                    token: <Id.VSub_Name s2>
                                                    prefix_op: (Id.VSub_Pound)
                                                  )
                                                }
                                              right: {(${ Id.VSub_Name width)}
                                            )
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:width)
                                              op: assign_op.Equal
                                              rhs: 
                                                {
                                                  (braced_var_sub
                                                    token: <Id.VSub_Name s2>
                                                    prefix_op: (Id.VSub_Pound)
                                                  )
                                                }
                                              spids: [4034]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (C {<printf>} {(DQ <'%*s'>)} {(${ Id.VSub_Name width)} 
                                      {(DQ (${ Id.VSub_Name s1))}
                                    )
                                  ]
                                )
                            )
                            (command.ShFunction
                              name: human
                              body: 
                                (BraceGroup
                                  children: [
                                    (C {<local>} {<Id.Lit_VarLike 's1='> ($ Id.VSub_Number '$1')})
                                    (C {<local>} 
                                      {<Id.Lit_VarLike 'units='> 
                                        (sh_array_literal
                                          left: <Id.Op_LParen _>
                                          words: [{<KiB>} {<MiB>} {<GiB>} {<TiB>}]
                                        )
                                      }
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:s1)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (word_part.ArithSub
                                                anode: 
                                                  (arith_expr.Binary
                                                    op_id: Id.Arith_Star
                                                    left: <Id.Lit_ArithVarLike s1>
                                                    right: {<Id.Lit_Digits 10>}
                                                  )
                                              )
                                            }
                                          spids: [4096]
                                        )
                                      ]
                                    )
                                    (command.WhileUntil
                                      keyword: <Id.KW_While while>
                                      cond: 
                                        (condition.Shell
                                          commands: [
                                            (command.Sentence
                                              child: 
                                                (command.DBracket
                                                  expr: 
                                                    (bool_expr.LogicalAnd
                                                      left: 
                                                        (bool_expr.Binary
                                                          op_id: Id.BoolBinary_gt
                                                          left: {(${ Id.VSub_Name s1)}
                                                          right: {<10240>}
                                                        )
                                                      right: 
                                                        (bool_expr.Binary
                                                          op_id: Id.BoolBinary_gt
                                                          left: 
                                                            {
                                                              (braced_var_sub
                                                                token: <Id.VSub_Name units>
                                                                prefix_op: (Id.VSub_Pound)
                                                                bracket_op: 
                                                                  (bracket_op.WholeArray
                                                                    op_id: Id.Lit_At
                                                                  )
                                                              )
                                                            }
                                                          right: {<1>}
                                                        )
                                                    )
                                                )
                                              terminator: <Id.Op_Semi _>
                                            )
                                          ]
                                        )
                                      body: 
                                        (command.DoGroup
                                          children: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:s1)
                                                  op: assign_op.Equal
                                                  rhs: 
                                                    {
                                                      (word_part.ArithSub
                                                        anode: 
                                                          (arith_expr.Binary
                                                            op_id: Id.Arith_Slash
                                                            left: <Id.Lit_ArithVarLike s1>
                                                            right: {<Id.Lit_Digits 1024>}
                                                          )
                                                      )
                                                    }
                                                  spids: [4140]
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:units)
                                                  op: assign_op.Equal
                                                  rhs: 
                                                    {
                                                      (sh_array_literal
                                                        left: <Id.Op_LParen _>
                                                        words: [
                                                          {
                                                            (braced_var_sub
                                                              token: <Id.VSub_Name units>
                                                              bracket_op: 
                                                                (bracket_op.WholeArray
                                                                  op_id: Id.Lit_At
                                                                )
                                                              suffix_op: 
                                                                (suffix_op.Slice
                                                                  begin: {<Id.Lit_Digits 1>}
                                                                )
                                                            )
                                                          }
                                                        ]
                                                      )
                                                    }
                                                  spids: [4152]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                    )
                                    (C {<local>} 
                                      {<Id.Lit_VarLike 'r='> 
                                        (braced_var_sub
                                          token: <Id.VSub_Name s1>
                                          suffix_op: 
                                            (suffix_op.Slice
                                              begin: 
                                                (arith_expr.Unary
                                                  op_id: Id.Node_UnaryMinus
                                                  child: {<Id.Lit_Digits 1>}
                                                )
                                            )
                                        )
                                      }
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:s1)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (word_part.ArithSub
                                                anode: 
                                                  (arith_expr.Binary
                                                    op_id: Id.Arith_Slash
                                                    left: <Id.Lit_ArithVarLike s1>
                                                    right: {<Id.Lit_Digits 10>}
                                                  )
                                              )
                                            }
                                          spids: [4183]
                                        )
                                      ]
                                    )
                                    (C {<printf>} {(DQ <'%s.%s %s'>)} {(DQ (${ Id.VSub_Name s1))} 
                                      {(DQ (${ Id.VSub_Name r))} 
                                      {
                                        (DQ 
                                          (braced_var_sub
                                            token: <Id.VSub_Name units>
                                            bracket_op: 
                                              (bracket_op.ArrayIndex
                                                expr: {<Id.Lit_Digits 0>}
                                              )
                                          )
                                        )
                                      }
                                    )
                                  ]
                                )
                            )
                            (command.ShFunction
                              name: size
                              body: 
                                (BraceGroup
                                  children: [
                                    (C {<local>} {<Id.Lit_VarLike 's1='> ($ Id.VSub_Number '$1')})
                                    (C {<local>} {<Id.Lit_VarLike 's2='> ($ Id.VSub_Number '$2')})
                                    (C {<local>} 
                                      {<Id.Lit_VarLike 'out='> 
                                        (DQ 
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            child: 
                                              (C {<padl>} {(DQ (${ Id.VSub_Name s1))} 
                                                {(DQ (${ Id.VSub_Name s2))}
                                              )
                                          ) <' KiB'>
                                        )
                                      }
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: 
                                            (condition.Shell
                                              commands: [
                                                (command.Sentence
                                                  child: 
                                                    (command.DBracket
                                                      expr: 
                                                        (bool_expr.Binary
                                                          op_id: Id.BoolBinary_gt
                                                          left: {(${ Id.VSub_Name s1)}
                                                          right: {<1024>}
                                                        )
                                                    )
                                                  terminator: <Id.Op_Semi _>
                                                )
                                              ]
                                            )
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:s1)
                                                  op: assign_op.Equal
                                                  rhs: 
                                                    {
                                                      (command_sub
                                                        left_token: <Id.Left_DollarParen '$('>
                                                        child: (C {<human>} {(${ Id.VSub_Name s1)})
                                                      )
                                                    }
                                                  spids: [4288]
                                                )
                                              ]
                                            )
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: 
                                                    (condition.Shell
                                                      commands: [
                                                        (command.Sentence
                                                          child: 
                                                            (command.DBracket
                                                              expr: 
                                                                (bool_expr.Binary
                                                                  op_id: Id.BoolBinary_gt
                                                                  left: {(${ Id.VSub_Name s2)}
                                                                  right: {<1024>}
                                                                )
                                                            )
                                                          terminator: <Id.Op_Semi _>
                                                        )
                                                      ]
                                                    )
                                                  action: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:s2)
                                                          op: assign_op.Equal
                                                          rhs: 
                                                            {
                                                              (command_sub
                                                                left_token: 
                                                                  <Id.Left_DollarParen '$('>
                                                                child: 
                                                                  (C {<human>} {(${ Id.VSub_Name s2)})
                                                              )
                                                            }
                                                          spids: [4317]
                                                        )
                                                      ]
                                                    )
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:s1)
                                                          op: assign_op.Equal
                                                          rhs: 
                                                            {
                                                              (command_sub
                                                                left_token: 
                                                                  <Id.Left_DollarParen '$('>
                                                                child: 
                                                                  (C {<padl>} 
                                                                    {(DQ (${ Id.VSub_Name s1))} {(DQ (${ Id.VSub_Name s2))}
                                                                  )
                                                              )
                                                            }
                                                          spids: [4327]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                  spids: [4298 4314]
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:out)
                                                  op: assign_op.PlusEqual
                                                  rhs: {(DQ <' ('> (${ Id.VSub_Name s1) <')'>)}
                                                  spids: [4348]
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [4269 4285]
                                        )
                                      ]
                                    )
                                    (C {<echo>} {(DQ (${ Id.VSub_Name out))})
                                  ]
                                )
                            )
                            (C {<einfo>} 
                              {
                                (DQ <'Final size of build directory: '> 
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (C {<size>} 
                                        {
                                          (braced_var_sub
                                            token: <Id.VSub_Name nsz>
                                            bracket_op: 
                                              (bracket_op.ArrayIndex
                                                expr: {<Id.Lit_Digits 0>}
                                              )
                                          )
                                        } {(braced_var_sub token:<Id.VSub_Name isz> bracket_op:(bracket_op.ArrayIndex expr:{<Id.Lit_Digits 0>}))}
                                      )
                                  )
                                )
                              }
                            )
                            (C {<einfo>} 
                              {
                                (DQ <'Final size of installed tree:  '> 
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (C {<size>} 
                                        {
                                          (braced_var_sub
                                            token: <Id.VSub_Name isz>
                                            bracket_op: 
                                              (bracket_op.ArrayIndex
                                                expr: {<Id.Lit_Digits 0>}
                                              )
                                          )
                                        } {(braced_var_sub token:<Id.VSub_Name nsz> bracket_op:(bracket_op.ArrayIndex expr:{<Id.Lit_Digits 0>}))}
                                      )
                                  )
                                )
                              }
                            )
                          ]
                        )
                    )
                    (C {<__vecho>})
                  ]
                  spids: [3918 3930]
                )
              ]
            )
            (C {<cd>} {(DQ (${ Id.VSub_Name PORTAGE_BUILDDIR)) <'/build-info'>})
            (C {<Id.KW_Set set>} {<-f>})
            (C {<local>} {<f>} {<x>})
            (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_Literals ' '>
                          <Id.Char_OneChar '\\t'>
                          <Id.Char_OneChar '\\n'>
                          <Id.Char_OneChar '\\r'>
                        ]
                        multiline: F
                      )
                    }
                  spids: [4453]
                )
              ]
            )
            (command.ForEach
              iter_name: f
              iter_words: [
                {<CATEGORY>}
                {<DEFINED_PHASES>}
                {<FEATURES>}
                {<INHERITED>}
                {<IUSE>}
                {<PF>}
                {<PKGUSE>}
                {<SLOT>}
                {<KEYWORDS>}
                {<HOMEPAGE>}
                {<DESCRIPTION>}
              ]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:x)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<echo>} {<-n>} 
                                    {(braced_var_sub token:<Id.VSub_Name f> prefix_op:(Id.VSub_Bang))}
                                  )
                              )
                            }
                          spids: [4497]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_n
                              child: {($ Id.VSub_DollarName '$x')}
                            )
                        )
                        (command.Simple
                          words: [{<echo>} {(DQ ($ Id.VSub_DollarName '$x'))}]
                          redirects: [
                            (redir
                              op: <Id.Redir_Great '>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {($ Id.VSub_DollarName '$f')}
                            )
                          ]
                          do_fork: T
                        )
                      ]
                    )
                  ]
                )
            )
            (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 '$CATEGORY')}
                                  right: {<virtual>}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ForEach
                      iter_name: f
                      iter_words: [
                        {<ASFLAGS>}
                        {<CBUILD>}
                        {<CC>}
                        {<CFLAGS>}
                        {<CHOST>}
                        {<CTARGET>}
                        {<CXX>}
                        {<CXXFLAGS>}
                        {<EXTRA_ECONF>}
                        {<EXTRA_EINSTALL>}
                        {<EXTRA_MAKE>}
                        {<LDFLAGS>}
                        {<LIBCFLAGS>}
                        {<LIBCXXFLAGS>}
                        {<QA_CONFIGURE_OPTIONS>}
                        {<QA_DESKTOP_FILE>}
                        {<QA_PREBUILT>}
                        {<PROVIDES_EXCLUDE>}
                        {<REQUIRES_EXCLUDE>}
                      ]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:x)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (C {<echo>} {<-n>} 
                                            {
                                              (braced_var_sub
                                                token: <Id.VSub_Name f>
                                                prefix_op: (Id.VSub_Bang)
                                              )
                                            }
                                          )
                                      )
                                    }
                                  spids: [4606]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Unary
                                      op_id: Id.BoolUnary_n
                                      child: {($ Id.VSub_DollarName '$x')}
                                    )
                                )
                                (command.Simple
                                  words: [{<echo>} {(DQ ($ Id.VSub_DollarName '$x'))}]
                                  redirects: [
                                    (redir
                                      op: <Id.Redir_Great '>'>
                                      loc: (redir_loc.Fd fd:1)
                                      arg: {($ Id.VSub_DollarName '$f')}
                                    )
                                  ]
                                  do_fork: T
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (command.ForEach
                      iter_name: f
                      iter_words: [{<QA_AM_MAINTAINER_MODE>}]
                      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 f>
                                            prefix_op: (Id.VSub_Bang)
                                          )
                                        }
                                    )
                                )
                                (command.Simple
                                  words: [
                                    {<echo>}
                                    {
                                      (DQ 
                                        (braced_var_sub
                                          token: <Id.VSub_Name f>
                                          prefix_op: (Id.VSub_Bang)
                                        )
                                      )
                                    }
                                  ]
                                  redirects: [
                                    (redir
                                      op: <Id.Redir_Great '>'>
                                      loc: (redir_loc.Fd fd:1)
                                      arg: {($ Id.VSub_DollarName '$f')}
                                    )
                                  ]
                                  do_fork: T
                                )
                              ]
                            )
                          ]
                        )
                    )
                  ]
                  spids: [4534 4548]
                )
              ]
            )
            (command.Simple
              words: [{<echo>} {(DQ (${ Id.VSub_Name USE))}]
              redirects: [(redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<USE>})]
              do_fork: T
            )
            (command.Simple
              words: [
                {<echo>}
                {
                  (DQ 
                    (braced_var_sub
                      token: <Id.VSub_Name EAPI>
                      suffix_op: (suffix_op.Unary op_id:Id.VTest_ColonHyphen arg_word:{<0>})
                    )
                  )
                }
              ]
              redirects: [(redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<EAPI>})]
              do_fork: T
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<___eapi_has_prefix_variables>})
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Unary
                                      op_id: Id.BoolUnary_n
                                      child: {(${ Id.VSub_Name EPREFIX)}
                                    )
                                )
                              ]
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.Simple
                      words: [{<echo>} {(DQ (${ Id.VSub_Name EPREFIX))}]
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {<EPREFIX>}
                        )
                      ]
                      do_fork: T
                    )
                  ]
                  spids: [4734 4751]
                )
              ]
            )
            (C {<Id.KW_Set set>} {<Id.Lit_Other '+'> <f>})
            (C {<unset>} {<f>})
            (C {<cd>} {(DQ (${ Id.VSub_Name PORTAGE_PYM_PATH))})
            (command.Pipeline
              children: [
                (C {<__save_ebuild_env>} {<--exclude-init-phases>})
                (command.Simple
                  words: [
                    {<__filter_readonly_variables>}
                    {<--filter-path>}
                    {<--filter-sandbox>}
                    {<--allow-extra-vars>}
                  ]
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {(DQ (${ Id.VSub_Name PORTAGE_BUILDDIR)) <'/build-info/environment'>}
                    )
                  ]
                  do_fork: T
                )
              ]
              negated: F
            )
            (C {<assert>} {(DQ <'__save_ebuild_env failed'>)})
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<cd>} {(DQ (${ Id.VSub_Name PORTAGE_BUILDDIR)) <'/build-info'>})
                (C {<die>})
              ]
            )
            (C {(${ Id.VSub_Name PORTAGE_BZIP2_COMMAND)} {<-f9>} {<environment>})
            (C {<cp>} {(DQ (${ Id.VSub_Name EBUILD))} {(DQ (${ Id.VSub_Name PF) <.ebuild>)})
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {<-n>} {(DQ (${ Id.VSub_Name PORTAGE_REPO_NAME))} 
                  {<Id.Lit_RBracket ']'>}
                )
                (command.Simple
                  words: [{<echo>} {(DQ (${ Id.VSub_Name PORTAGE_REPO_NAME))}]
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {<repository>}
                    )
                  ]
                  do_fork: T
                )
              ]
            )
            (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: [
                    (command.Simple
                      redirects: [
                        (redir
                          op: <Id.Redir_DGreat '>>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {<DEBUGBUILD>}
                        )
                      ]
                      do_fork: F
                    )
                  ]
                  spids: [4904 4929]
                )
              ]
            )
            (C {<trap>} {<->} {<SIGINT>} {<SIGQUIT>})
          ]
        )
    )
    (command.ShFunction
      name: __dyn_help
      body: 
        (BraceGroup
          children: [
            (C {<echo>})
            (C {<echo>} {(DQ <Portage>)})
            (C {<echo>} {(DQ <'Copyright 1999-2010 Gentoo Foundation'>)})
            (C {<echo>})
            (C {<echo>} {(DQ <'How to use the ebuild command:'>)})
            (C {<echo>})
            (C {<echo>} {(DQ <'The first argument to ebuild should be an existing .ebuild file.'>)})
            (C {<echo>})
            (C {<echo>} {(DQ <'One or more of the following options can then be specified.  If more'>)})
            (C {<echo>} {(DQ <'than one option is specified, each will be executed in order.'>)})
            (C {<echo>})
            (C {<echo>} {(DQ <'  help        : show this help screen'>)})
            (C {<echo>} {(DQ <'  pretend     : execute package specific pretend actions'>)})
            (C {<echo>} {(DQ <'  setup       : execute package specific setup actions'>)})
            (C {<echo>} {(DQ <'  fetch       : download source archive(s) and patches'>)})
            (C {<echo>} {(DQ <'  nofetch     : display special fetch instructions'>)})
            (C {<echo>} {(DQ <'  digest      : create a manifest file for the package'>)})
            (C {<echo>} {(DQ <'  manifest    : create a manifest file for the package'>)})
            (C {<echo>} {(DQ <'  unpack      : unpack sources (auto-dependencies if needed)'>)})
            (C {<echo>} {(DQ <'  prepare     : prepare sources (auto-dependencies if needed)'>)})
            (C {<echo>} {(DQ <'  configure   : configure sources (auto-fetch/unpack if needed)'>)})
            (C {<echo>} 
              {(DQ <'  compile     : compile sources (auto-fetch/unpack/configure if needed)'>)}
            )
            (C {<echo>} 
              {(DQ <'  test        : test package (auto-fetch/unpack/configure/compile if needed)'>)}
            )
            (C {<echo>} {(DQ <'  preinst     : execute pre-install instructions'>)})
            (C {<echo>} {(DQ <'  postinst    : execute post-install instructions'>)})
            (C {<echo>} 
              {(DQ <'  install     : install the package to the temporary install directory'>)}
            )
            (C {<echo>} 
              {(DQ <'  qmerge      : merge image into live filesystem, recording files in db'>)}
            )
            (C {<echo>} {(DQ <'  merge       : do fetch, unpack, compile, install and qmerge'>)})
            (C {<echo>} {(DQ <'  prerm       : execute pre-removal instructions'>)})
            (C {<echo>} {(DQ <'  postrm      : execute post-removal instructions'>)})
            (C {<echo>} {(DQ <'  unmerge     : remove package from live filesystem'>)})
            (C {<echo>} {(DQ <'  config      : execute package specific configuration actions'>)})
            (C {<echo>} 
              {
                (DQ <'  package     : create a tarball package in '> (${ Id.VSub_Name PKGDIR) <'/All'>)
              }
            )
            (C {<echo>} {(DQ <'  rpm         : build a RedHat RPM package'>)})
            (C {<echo>} {(DQ <'  clean       : clean up all source and temporary files'>)})
            (C {<echo>})
            (C {<echo>} {(DQ <'The following settings will be used for the ebuild process:'>)})
            (C {<echo>})
            (C {<echo>} {(DQ <'  package     : '> (${ Id.VSub_Name PF))})
            (C {<echo>} {(DQ <'  slot        : '> (${ Id.VSub_Name SLOT))})
            (C {<echo>} {(DQ <'  category    : '> (${ Id.VSub_Name CATEGORY))})
            (C {<echo>} {(DQ <'  description : '> (${ Id.VSub_Name DESCRIPTION))})
            (C {<echo>} {(DQ <'  system      : '> (${ Id.VSub_Name CHOST))})
            (C {<echo>} {(DQ <'  c flags     : '> (${ Id.VSub_Name CFLAGS))})
            (C {<echo>} {(DQ <'  c++ flags   : '> (${ Id.VSub_Name CXXFLAGS))})
            (C {<echo>} {(DQ <'  make flags  : '> (${ Id.VSub_Name MAKEOPTS))})
            (C {<echo>} {<-n>} {(DQ <'  build mode  : '>)})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (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)})
                              ]
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<echo>} {(DQ <'debug (large)'>)})]
                  spids: [5289 5316]
                )
              ]
              else_action: [(C {<echo>} {(DQ <'production (stripped)'>)})]
            )
            (C {<echo>} {(DQ <'  merge to    : '> (${ Id.VSub_Name ROOT))})
            (C {<echo>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {<-n>} {(DQ ($ Id.VSub_DollarName '$USE'))} 
                              {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<echo>} 
                      {
                        (DQ 
                          <
'Additionally, support for the following optional features will be enabled:'
                          >
                        )
                      }
                    )
                    (C {<echo>})
                    (C {<echo>} {(DQ <'  '> (${ Id.VSub_Name USE))})
                  ]
                  spids: [5352 5365]
                )
              ]
            )
            (C {<echo>})
          ]
        )
    )
    (command.ShFunction
      name: __ebuild_arg_to_phase
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {($ Id.VSub_Pound '$#')} {<-ne>} {<1>} {<Id.Lit_RBracket ']'>})
                (C {<die>} 
                  {
                    (DQ <'expected exactly 1 arg, got '> ($ Id.VSub_Pound '$#') <': '> 
                      ($ Id.VSub_Star '$*')
                    )
                  }
                )
              ]
            )
            (C {<local>} {<Id.Lit_VarLike 'arg='> ($ Id.VSub_Number '$1')})
            (C {<local>} {<Id.Lit_VarLike 'phase_func='> (DQ )})
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName '$arg'))}
              arms: [
                (case_arm
                  pat_list: [{<pretend>}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<___eapi_has_pkg_pretend>})
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:phase_func)
                              op: assign_op.Equal
                              rhs: {<pkg_pretend>}
                              spids: [5470]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [5460 5461 5474 -1]
                )
                (case_arm
                  pat_list: [{<setup>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:phase_func)
                          op: assign_op.Equal
                          rhs: {<pkg_setup>}
                          spids: [5481]
                        )
                      ]
                    )
                  ]
                  spids: [5477 5478 5485 -1]
                )
                (case_arm
                  pat_list: [{<nofetch>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:phase_func)
                          op: assign_op.Equal
                          rhs: {<pkg_nofetch>}
                          spids: [5492]
                        )
                      ]
                    )
                  ]
                  spids: [5488 5489 5496 -1]
                )
                (case_arm
                  pat_list: [{<unpack>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:phase_func)
                          op: assign_op.Equal
                          rhs: {<src_unpack>}
                          spids: [5503]
                        )
                      ]
                    )
                  ]
                  spids: [5499 5500 5507 -1]
                )
                (case_arm
                  pat_list: [{<prepare>}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<___eapi_has_src_prepare>})
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:phase_func)
                              op: assign_op.Equal
                              rhs: {<src_prepare>}
                              spids: [5520]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [5510 5511 5524 -1]
                )
                (case_arm
                  pat_list: [{<configure>}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<___eapi_has_src_configure>})
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:phase_func)
                              op: assign_op.Equal
                              rhs: {<src_configure>}
                              spids: [5537]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [5527 5528 5541 -1]
                )
                (case_arm
                  pat_list: [{<compile>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:phase_func)
                          op: assign_op.Equal
                          rhs: {<src_compile>}
                          spids: [5548]
                        )
                      ]
                    )
                  ]
                  spids: [5544 5545 5552 -1]
                )
                (case_arm
                  pat_list: [{<test>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:phase_func)
                          op: assign_op.Equal
                          rhs: {<src_test>}
                          spids: [5559]
                        )
                      ]
                    )
                  ]
                  spids: [5555 5556 5563 -1]
                )
                (case_arm
                  pat_list: [{<install>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:phase_func)
                          op: assign_op.Equal
                          rhs: {<src_install>}
                          spids: [5570]
                        )
                      ]
                    )
                  ]
                  spids: [5566 5567 5574 -1]
                )
                (case_arm
                  pat_list: [{<preinst>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:phase_func)
                          op: assign_op.Equal
                          rhs: {<pkg_preinst>}
                          spids: [5581]
                        )
                      ]
                    )
                  ]
                  spids: [5577 5578 5585 -1]
                )
                (case_arm
                  pat_list: [{<postinst>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:phase_func)
                          op: assign_op.Equal
                          rhs: {<pkg_postinst>}
                          spids: [5592]
                        )
                      ]
                    )
                  ]
                  spids: [5588 5589 5596 -1]
                )
                (case_arm
                  pat_list: [{<prerm>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:phase_func)
                          op: assign_op.Equal
                          rhs: {<pkg_prerm>}
                          spids: [5603]
                        )
                      ]
                    )
                  ]
                  spids: [5599 5600 5607 -1]
                )
                (case_arm
                  pat_list: [{<postrm>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:phase_func)
                          op: assign_op.Equal
                          rhs: {<pkg_postrm>}
                          spids: [5614]
                        )
                      ]
                    )
                  ]
                  spids: [5610 5611 5618 -1]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.Unary
                      op_id: Id.BoolUnary_z
                      child: {($ Id.VSub_DollarName '$phase_func')}
                    )
                )
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {<1>}
                )
              ]
            )
            (C {<echo>} {(DQ ($ Id.VSub_DollarName '$phase_func'))})
            (command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<0>})
          ]
        )
    )
    (command.ShFunction
      name: __ebuild_phase_funcs
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {($ Id.VSub_Pound '$#')} {<-ne>} {<2>} {<Id.Lit_RBracket ']'>})
                (C {<die>} 
                  {
                    (DQ <'expected exactly 2 args, got '> ($ Id.VSub_Pound '$#') <': '> 
                      ($ Id.VSub_Star '$*')
                    )
                  }
                )
              ]
            )
            (C {<local>} {<Id.Lit_VarLike 'eapi='> ($ Id.VSub_Number '$1')})
            (C {<local>} {<Id.Lit_VarLike 'phase_func='> ($ Id.VSub_Number '$2')})
            (C {<local>} 
              {<Id.Lit_VarLike 'all_phases='> 
                (DQ <'src_compile pkg_config src_configure pkg_info\n'> 
                  <'\t\tsrc_install pkg_nofetch pkg_postinst pkg_postrm pkg_preinst\n'> <'\t\tsrc_prepare pkg_prerm pkg_pretend pkg_setup src_test src_unpack'>
                )
              }
            )
            (C {<local>} {<x>})
            (command.ForEach
              iter_name: x
              iter_words: [{(${ Id.VSub_Name all_phases)}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (C {<eval>} 
                      {
                        (DQ <default_> (${ Id.VSub_Name x) <'() {\n'> <'\t\t\tdie '> 
                          (word_part.EscapedLiteral
                            token: <Id.Lit_EscapedChar '\\"'>
                          ) <default_> (${ Id.VSub_Name x) <'() is not supported in EAPI=\''> (${ Id.VSub_Name eapi) <'\' in phase '> 
                          (${ Id.VSub_Name phase_func) (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) <'\n'> <'\t\t}'>
                        )
                      }
                    )
                  ]
                )
            )
            (C {<eval>} 
              {(DQ <'default() {\n'> <'\t\tdefault_'> (${ Id.VSub_Name phase_func) <'\n'> <'\t}'>)}
            )
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName '$eapi'))}
              arms: [
                (case_arm
                  pat_list: [{<0>} {<1>}]
                  action: [
                    (command.ForEach
                      iter_name: x
                      iter_words: [{<pkg_nofetch>} {<src_unpack>} {<src_test>}]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (command.Simple
                                  words: [{<declare>} {<-F>} {($ Id.VSub_DollarName '$x')}]
                                  redirects: [
                                    (redir
                                      op: <Id.Redir_Great '>'>
                                      loc: (redir_loc.Fd fd:1)
                                      arg: {<'/dev/null'>}
                                    )
                                  ]
                                  do_fork: T
                                )
                                (C {<eval>} 
                                  {
                                    (DQ ($ Id.VSub_DollarName '$x') <'() { __eapi0_'> 
                                      ($ Id.VSub_DollarName '$x') <'; }'>
                                    )
                                  }
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.Pipeline
                                      children: [
                                        (command.Simple
                                          words: [{<declare>} {<-F>} {<src_compile>}]
                                          redirects: [
                                            (redir
                                              op: <Id.Redir_Great '>'>
                                              loc: (redir_loc.Fd fd:1)
                                              arg: {<'/dev/null'>}
                                            )
                                          ]
                                          do_fork: T
                                        )
                                      ]
                                      negated: T
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.Case
                              to_match: {(DQ ($ Id.VSub_DollarName '$eapi'))}
                              arms: [
                                (case_arm
                                  pat_list: [{<0>}]
                                  action: [
                                    (command.ShFunction
                                      name: src_compile
                                      body: 
                                        (BraceGroup
                                          children: [
                                            (command.Sentence
                                              child: (C {<__eapi0_src_compile>})
                                              terminator: <Id.Op_Semi _>
                                            )
                                          ]
                                        )
                                    )
                                  ]
                                  spids: [5874 5875 5890 -1]
                                )
                                (case_arm
                                  pat_list: [{<Id.Lit_Star '*'>}]
                                  action: [
                                    (command.ShFunction
                                      name: src_compile
                                      body: 
                                        (BraceGroup
                                          children: [
                                            (command.Sentence
                                              child: (C {<__eapi1_src_compile>})
                                              terminator: <Id.Op_Semi _>
                                            )
                                          ]
                                        )
                                    )
                                  ]
                                  spids: [5893 5894 5909 -1]
                                )
                              ]
                            )
                          ]
                          spids: [5847 5862]
                        )
                      ]
                    )
                  ]
                  spids: [5793 5796 5918 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobDEqual
                              left: {(${ Id.VSub_Name phase_func)}
                              right: {<pkg_nofetch>}
                            )
                        )
                        (command.ShFunction
                          name: default_pkg_nofetch
                          body: 
                            (BraceGroup
                              children: [
                                (command.Sentence
                                  child: (C {<__eapi0_pkg_nofetch>})
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobDEqual
                              left: {(${ Id.VSub_Name phase_func)}
                              right: {<src_unpack>}
                            )
                        )
                        (command.ShFunction
                          name: default_src_unpack
                          body: 
                            (BraceGroup
                              children: [
                                (command.Sentence
                                  child: (C {<__eapi0_src_unpack>})
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobDEqual
                              left: {(${ Id.VSub_Name phase_func)}
                              right: {<src_test>}
                            )
                        )
                        (command.ShFunction
                          name: default_src_test
                          body: 
                            (BraceGroup
                              children: [
                                (command.Sentence
                                  child: (C {<__eapi0_src_test>})
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobDEqual
                              left: {(${ Id.VSub_Name phase_func)}
                              right: {<src_prepare>}
                            )
                        )
                        (command.ShFunction
                          name: default_src_prepare
                          body: 
                            (BraceGroup
                              children: [
                                (command.Sentence
                                  child: (C {<__eapi2_src_prepare>})
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobDEqual
                              left: {(${ Id.VSub_Name phase_func)}
                              right: {<src_configure>}
                            )
                        )
                        (command.ShFunction
                          name: default_src_configure
                          body: 
                            (BraceGroup
                              children: [
                                (command.Sentence
                                  child: (C {<__eapi2_src_configure>})
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_GlobDEqual
                              left: {(${ Id.VSub_Name phase_func)}
                              right: {<src_compile>}
                            )
                        )
                        (command.ShFunction
                          name: default_src_compile
                          body: 
                            (BraceGroup
                              children: [
                                (command.Sentence
                                  child: (C {<__eapi2_src_compile>})
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (command.Simple
                          words: [{<declare>} {<-F>} {<pkg_nofetch>}]
                          redirects: [
                            (redir
                              op: <Id.Redir_Great '>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<'/dev/null'>}
                            )
                          ]
                          do_fork: T
                        )
                        (command.ShFunction
                          name: pkg_nofetch
                          body: 
                            (BraceGroup
                              children: [
                                (command.Sentence
                                  child: (C {<default>})
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (command.Simple
                          words: [{<declare>} {<-F>} {<src_unpack>}]
                          redirects: [
                            (redir
                              op: <Id.Redir_Great '>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<'/dev/null'>}
                            )
                          ]
                          do_fork: T
                        )
                        (command.ShFunction
                          name: src_unpack
                          body: 
                            (BraceGroup
                              children: [
                                (command.Sentence
                                  child: (C {<default>})
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (command.Simple
                          words: [{<declare>} {<-F>} {<src_prepare>}]
                          redirects: [
                            (redir
                              op: <Id.Redir_Great '>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<'/dev/null'>}
                            )
                          ]
                          do_fork: T
                        )
                        (command.ShFunction
                          name: src_prepare
                          body: 
                            (BraceGroup
                              children: [
                                (command.Sentence
                                  child: (C {<default>})
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (command.Simple
                          words: [{<declare>} {<-F>} {<src_configure>}]
                          redirects: [
                            (redir
                              op: <Id.Redir_Great '>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<'/dev/null'>}
                            )
                          ]
                          do_fork: T
                        )
                        (command.ShFunction
                          name: src_configure
                          body: 
                            (BraceGroup
                              children: [
                                (command.Sentence
                                  child: (C {<default>})
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (command.Simple
                          words: [{<declare>} {<-F>} {<src_compile>}]
                          redirects: [
                            (redir
                              op: <Id.Redir_Great '>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<'/dev/null'>}
                            )
                          ]
                          do_fork: T
                        )
                        (command.ShFunction
                          name: src_compile
                          body: 
                            (BraceGroup
                              children: [
                                (command.Sentence
                                  child: (C {<default>})
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (command.Simple
                          words: [{<declare>} {<-F>} {<src_test>}]
                          redirects: [
                            (redir
                              op: <Id.Redir_Great '>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<'/dev/null'>}
                            )
                          ]
                          do_fork: T
                        )
                        (command.ShFunction
                          name: src_test
                          body: 
                            (BraceGroup
                              children: [
                                (command.Sentence
                                  child: (C {<default>})
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.Pipeline
                                      children: [(C {<has>} {(${ Id.VSub_Name eapi)} {<2>} {<3>})]
                                      negated: T
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_GlobDEqual
                                      left: {(${ Id.VSub_Name phase_func)}
                                      right: {<src_install>}
                                    )
                                )
                                (command.ShFunction
                                  name: default_src_install
                                  body: 
                                    (BraceGroup
                                      children: [
                                        (command.Sentence
                                          child: (C {<__eapi4_src_install>})
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (command.Simple
                                  words: [{<declare>} {<-F>} {<src_install>}]
                                  redirects: [
                                    (redir
                                      op: <Id.Redir_Great '>'>
                                      loc: (redir_loc.Fd fd:1)
                                      arg: {<'/dev/null'>}
                                    )
                                  ]
                                  do_fork: T
                                )
                                (command.ShFunction
                                  name: src_install
                                  body: 
                                    (BraceGroup
                                      children: [
                                        (command.Sentence
                                          child: (C {<default>})
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                )
                              ]
                            )
                          ]
                          spids: [6267 6282]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.Pipeline
                                      children: [
                                        (C {<has>} {(${ Id.VSub_Name eapi)} {<2>} {<3>} {<4>} {<4-python>} 
                                          {<4-slot-abi>} {<5>} {<5-progress>} {<5-hdepend>}
                                        )
                                      ]
                                      negated: T
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_GlobDEqual
                                      left: {(${ Id.VSub_Name phase_func)}
                                      right: {<src_prepare>}
                                    )
                                )
                                (command.ShFunction
                                  name: default_src_prepare
                                  body: 
                                    (BraceGroup
                                      children: [
                                        (command.Sentence
                                          child: (C {<__eapi6_src_prepare>})
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_GlobDEqual
                                      left: {(${ Id.VSub_Name phase_func)}
                                      right: {<src_install>}
                                    )
                                )
                                (command.ShFunction
                                  name: default_src_install
                                  body: 
                                    (BraceGroup
                                      children: [
                                        (command.Sentence
                                          child: (C {<__eapi6_src_install>})
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (command.Simple
                                  words: [{<declare>} {<-F>} {<src_prepare>}]
                                  redirects: [
                                    (redir
                                      op: <Id.Redir_Great '>'>
                                      loc: (redir_loc.Fd fd:1)
                                      arg: {<'/dev/null'>}
                                    )
                                  ]
                                  do_fork: T
                                )
                                (command.ShFunction
                                  name: src_prepare
                                  body: 
                                    (BraceGroup
                                      children: [
                                        (command.Sentence
                                          child: (C {<default>})
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                )
                              ]
                            )
                          ]
                          spids: [6347 6374]
                        )
                      ]
                    )
                  ]
                  spids: [5922 5923 6462 -1]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: __ebuild_main
      body: 
        (BraceGroup
          children: [
            (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.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.DBracket
                  expr: (bool_expr.Unary op_id:Id.BoolUnary_z child:{(${ Id.VSub_Name S)})
                )
                (C {<export>} 
                  {<Id.Lit_VarLike 'S='> (${ Id.VSub_Name WORKDIR) <'/'> (${ Id.VSub_Name P)}
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_s
                                  child: {($ Id.VSub_DollarName '$SANDBOX_LOG')}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<local>} {<Id.Lit_VarLike 'x='>})
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: (bool_expr.Unary op_id:Id.BoolUnary_n child:{<SANDBOX_ON>})
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:x)
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_DollarName '$SANDBOX_ON')}
                                  spids: [6596]
                                )
                              ]
                            )
                            (C {<export>} {<Id.Lit_VarLike 'SANDBOX_ON='> <0>})
                          ]
                          spids: [6581 6593]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<rm>} {<-f>} {(DQ ($ Id.VSub_DollarName '$SANDBOX_LOG'))})
                        (C {<die>} 
                          {
                            (DQ <'failed to remove stale sandbox log: \''> 
                              ($ Id.VSub_DollarName '$SANDBOX_LOG') <'\''>
                            )
                          }
                        )
                      ]
                    )
                    (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 '$x')}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<export>} {<Id.Lit_VarLike 'SANDBOX_ON='> ($ Id.VSub_DollarName '$x')})
                          ]
                          spids: [6632 6644]
                        )
                      ]
                    )
                    (C {<unset>} {<x>})
                  ]
                  spids: [6549 6561]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<has>} {<ccache>} {($ Id.VSub_DollarName '$FEATURES')})
                (C {<export>} {<Id.Lit_VarLike 'CCACHE_DISABLE='> <1>})
              ]
            )
            (C {<local>} 
              {<Id.Lit_VarLike 'phase_func='> 
                (command_sub
                  left_token: <Id.Left_DollarParen '$('>
                  child: (C {<__ebuild_arg_to_phase>} {(DQ ($ Id.VSub_DollarName '$EBUILD_PHASE'))})
                )
              }
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.Unary
                      op_id: Id.BoolUnary_n
                      child: {($ Id.VSub_DollarName '$phase_func')}
                    )
                )
                (C {<__ebuild_phase_funcs>} {(DQ ($ Id.VSub_DollarName '$EAPI'))} 
                  {(DQ ($ Id.VSub_DollarName '$phase_func'))}
                )
              ]
            )
            (C {<unset>} {<phase_func>})
            (C {<__source_all_bashrcs>})
            (command.Case
              to_match: {(${ Id.VSub_Number 1)}
              arms: [
                (case_arm
                  pat_list: [{<nofetch>}]
                  action: [(C {<__ebuild_phase_with_hooks>} {<pkg_nofetch>})]
                  spids: [6740 6741 6749 -1]
                )
                (case_arm
                  pat_list: [{<prerm>} {<postrm>} {<preinst>} {<postinst>} {<config>} {<info>}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.AndOr
                                      ops: [Id.Op_DAmp]
                                      children: [
                                        (C {<has>} {(DQ (${ Id.VSub_Number 1))} {<config>} {<info>})
                                        (command.Pipeline
                                          children: [
                                            (command.Simple
                                              words: [
                                                {<declare>}
                                                {<-F>}
                                                {(DQ <pkg_> (${ Id.VSub_Number 1))}
                                              ]
                                              redirects: [
                                                (redir
                                                  op: <Id.Redir_Great '>'>
                                                  loc: (redir_loc.Fd fd:1)
                                                  arg: {<'/dev/null'>}
                                                )
                                              ]
                                              do_fork: T
                                            )
                                          ]
                                          negated: T
                                        )
                                      ]
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<ewarn>} 
                              {
                                (DQ <pkg_> (${ Id.VSub_Number 1) <'() is not defined: \''> 
                                  (braced_var_sub
                                    token: <Id.VSub_Name EBUILD>
                                    suffix_op: 
                                      (suffix_op.Unary
                                        op_id: Id.VOp1_DPound
                                        arg_word: {<'*'> <Id.Lit_Slash '/'>}
                                      )
                                  ) <'\''>
                                )
                              }
                            )
                          ]
                          spids: [6766 6802]
                        )
                      ]
                    )
                    (C {<export>} {<Id.Lit_VarLike 'SANDBOX_ON='> (DQ <0>)})
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.AndOr
                                      ops: [Id.Op_DPipe]
                                      children: [
                                        (C {<Id.Lit_LBracket '['>} 
                                          {(DQ (${ Id.VSub_Name PORTAGE_DEBUG))} {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ <1>)} {<Id.Lit_RBracket ']'>}
                                        )
                                        (C {<Id.Lit_LBracket '['>} 
                                          {
                                            (DQ 
                                              (braced_var_sub
                                                token: <Id.VSub_Hyphen ->
                                                suffix_op: 
                                                  (suffix_op.PatSub
                                                    pat: {<x>}
                                                    replace: {}
                                                    replace_mode: Id.Undefined_Tok
                                                  )
                                              )
                                            )
                                          } {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ ($ Id.VSub_Hyphen '$-'))} {<Id.Lit_RBracket ']'>}
                                        )
                                      ]
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [(C {<__ebuild_phase_with_hooks>} {<pkg_> (${ Id.VSub_Number 1)})]
                          spids: [6834 6876]
                        )
                      ]
                      else_action: [
                        (C {<Id.KW_Set set>} {<-x>})
                        (C {<__ebuild_phase_with_hooks>} {<pkg_> (${ Id.VSub_Number 1)})
                        (C {<Id.KW_Set set>} {<Id.Lit_Other '+'> <x>})
                      ]
                    )
                    (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 '$PORTAGE_UPDATE_ENV')}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<cd>} {(DQ (${ Id.VSub_Name PORTAGE_PYM_PATH))})
                            (command.Pipeline
                              children: [
                                (C {<__save_ebuild_env>} {<--exclude-init-phases>})
                                (C {<__filter_readonly_variables>} {<--filter-path>} 
                                  {<--filter-sandbox>} {<--allow-extra-vars>}
                                )
                                (command.Simple
                                  words: [{(${ Id.VSub_Name PORTAGE_BZIP2_COMMAND)} {<-c>} {<-f9>}]
                                  redirects: [
                                    (redir
                                      op: <Id.Redir_Great '>'>
                                      loc: (redir_loc.Fd fd:1)
                                      arg: {(DQ ($ Id.VSub_DollarName '$PORTAGE_UPDATE_ENV'))}
                                    )
                                  ]
                                  do_fork: T
                                )
                              ]
                              negated: F
                            )
                            (C {<assert>} {(DQ <'__save_ebuild_env failed'>)})
                          ]
                          spids: [6912 6924]
                        )
                      ]
                    )
                  ]
                  spids: [6752 6763 6995 -1]
                )
                (case_arm
                  pat_list: [{<unpack>} {<prepare>} {<configure>} {<compile>} {<test>} {<clean>} {<install>}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobEqual
                                          left: 
                                            {
                                              (braced_var_sub
                                                token: <Id.VSub_Name SANDBOX_DISABLED>
                                                suffix_op: 
                                                  (suffix_op.Unary
                                                    op_id: Id.VTest_ColonHyphen
                                                    arg_word: {<0>}
                                                  )
                                              )
                                            }
                                          right: {<0>}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [(C {<export>} {<Id.Lit_VarLike 'SANDBOX_ON='> (DQ <1>)})]
                          spids: [7014 7032]
                        )
                      ]
                      else_action: [(C {<export>} {<Id.Lit_VarLike 'SANDBOX_ON='> (DQ <0>)})]
                    )
                    (command.Case
                      to_match: {(DQ (${ Id.VSub_Number 1))}
                      arms: [
                        (case_arm
                          pat_list: [{<configure>} {<compile>}]
                          action: [
                            (C {<local>} {<x>})
                            (command.ForEach
                              iter_name: x
                              iter_words: [
                                {<ASFLAGS>}
                                {<CCACHE_DIR>}
                                {<CCACHE_SIZE>}
                                {<CFLAGS>}
                                {<CXXFLAGS>}
                                {<LDFLAGS>}
                                {<LIBCFLAGS>}
                                {<LIBCXXFLAGS>}
                              ]
                              do_arg_iter: F
                              body: 
                                (command.DoGroup
                                  children: [
                                    (command.AndOr
                                      ops: [Id.Op_DAmp]
                                      children: [
                                        (command.DBracket
                                          expr: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobEqual
                                              left: 
                                                {
                                                  (braced_var_sub
                                                    token: <Id.VSub_Name x>
                                                    prefix_op: (Id.VSub_Bang)
                                                    suffix_op: 
                                                      (suffix_op.Unary
                                                        op_id: Id.VTest_Plus
                                                        arg_word: {<set>}
                                                      )
                                                  )
                                                }
                                              right: {<set>}
                                            )
                                        )
                                        (C {<export>} {($ Id.VSub_DollarName '$x')})
                                      ]
                                    )
                                  ]
                                )
                            )
                            (C {<unset>} {<x>})
                            (command.AndOr
                              ops: [Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp]
                              children: [
                                (C {<has>} {<distcc>} {($ Id.VSub_DollarName '$FEATURES')})
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Unary
                                      op_id: Id.BoolUnary_n
                                      child: {($ Id.VSub_DollarName '$DISTCC_DIR')}
                                    )
                                )
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_GlobEqual
                                      left: 
                                        {
                                          (braced_var_sub
                                            token: <Id.VSub_Name SANDBOX_WRITE>
                                            suffix_op: 
                                              (suffix_op.PatSub
                                                pat: {($ Id.VSub_DollarName '$DISTCC_DIR')}
                                                replace_mode: Id.Undefined_Tok
                                              )
                                          )
                                        }
                                      right: {($ Id.VSub_DollarName '$SANDBOX_WRITE')}
                                    )
                                )
                                (C {<addwrite>} {(DQ ($ Id.VSub_DollarName '$DISTCC_DIR'))})
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:x)
                                  op: assign_op.Equal
                                  rhs: {<LIBDIR_> ($ Id.VSub_DollarName '$ABI')}
                                  spids: [7187]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<Id.Lit_LBracket '['>} {<-z>} 
                                  {(DQ ($ Id.VSub_DollarName '$PKG_CONFIG_PATH'))} {<-a>} {<-n>} {(DQ ($ Id.VSub_DollarName '$ABI'))} {<-a>} {<-n>} 
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name x>
                                        prefix_op: (Id.VSub_Bang)
                                      )
                                    )
                                  } {<Id.Lit_RBracket ']'>}
                                )
                                (C {<export>} 
                                  {<Id.Lit_VarLike 'PKG_CONFIG_PATH='> (${ Id.VSub_Name EPREFIX) 
                                    <'/usr/'> (braced_var_sub token:<Id.VSub_Name x> prefix_op:(Id.VSub_Bang)) <'/pkgconfig'>
                                  }
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (command.AndOr
                                              ops: [Id.Op_DAmp]
                                              children: [
                                                (C {<has>} {<noauto>} 
                                                  {($ Id.VSub_DollarName '$FEATURES')}
                                                )
                                                (command.DBracket
                                                  expr: 
                                                    (bool_expr.LogicalNot
                                                      child: 
                                                        (bool_expr.Unary
                                                          op_id: Id.BoolUnary_f
                                                          child: 
                                                            {
                                                              ($ Id.VSub_DollarName 
'$PORTAGE_BUILDDIR'
                                                              ) <'/.unpacked'>
                                                            }
                                                        )
                                                    )
                                                )
                                              ]
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (C {<echo>})
                                    (C {<echo>} {(DQ <'!!! We apparently haven\'t unpacked...'>)} 
                                      {(DQ <'This is probably not what you'>)}
                                    )
                                    (C {<echo>} {(DQ <'!!! want to be doing... You are using'>)} 
                                      {(DQ <'FEATURES=noauto so I\'ll assume'>)}
                                    )
                                    (C {<echo>} {(DQ <'!!! that you know what you are doing...'>)} 
                                      {(DQ <'You have 5 seconds to abort...'>)}
                                    )
                                    (C {<echo>})
                                    (C {<sleep>} {<5>})
                                  ]
                                  spids: [7240 7265]
                                )
                              ]
                            )
                            (C {<cd>} {(DQ ($ Id.VSub_DollarName '$PORTAGE_BUILDDIR'))})
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<Id.Lit_LBracket '['>} {<Id.KW_Bang '!'>} {<-d>} 
                                              {<build-info>} {<Id.Lit_RBracket ']'>}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (C {<mkdir>} {<build-info>})
                                    (C {<cp>} {(DQ ($ Id.VSub_DollarName '$EBUILD'))} 
                                      {(DQ <'build-info/'> ($ Id.VSub_DollarName '$PF') <.ebuild>)}
                                    )
                                  ]
                                  spids: [7330 7344]
                                )
                              ]
                            )
                            (C {<export>} {<S>} {<D>})
                          ]
                          spids: [7069 7072 7385 -1]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.AndOr
                                      ops: [Id.Op_DPipe]
                                      children: [
                                        (C {<Id.Lit_LBracket '['>} 
                                          {(DQ (${ Id.VSub_Name PORTAGE_DEBUG))} {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ <1>)} {<Id.Lit_RBracket ']'>}
                                        )
                                        (C {<Id.Lit_LBracket '['>} 
                                          {
                                            (DQ 
                                              (braced_var_sub
                                                token: <Id.VSub_Hyphen ->
                                                suffix_op: 
                                                  (suffix_op.PatSub
                                                    pat: {<x>}
                                                    replace: {}
                                                    replace_mode: Id.Undefined_Tok
                                                  )
                                              )
                                            )
                                          } {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ ($ Id.VSub_Hyphen '$-'))} {<Id.Lit_RBracket ']'>}
                                        )
                                      ]
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [(C {<__dyn_> (${ Id.VSub_Number 1)})]
                          spids: [7392 7434]
                        )
                      ]
                      else_action: [
                        (C {<Id.KW_Set set>} {<-x>})
                        (C {<__dyn_> (${ Id.VSub_Number 1)})
                        (C {<Id.KW_Set set>} {<Id.Lit_Other '+'> <x>})
                      ]
                    )
                    (C {<export>} {<Id.Lit_VarLike 'SANDBOX_ON='> (DQ <0>)})
                  ]
                  spids: [6998 7011 7474 -1]
                )
                (case_arm
                  pat_list: [{<help>} {<pretend>} {<setup>}]
                  action: [
                    (C {<export>} {<Id.Lit_VarLike 'SANDBOX_ON='> (DQ <0>)})
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.AndOr
                                      ops: [Id.Op_DPipe]
                                      children: [
                                        (C {<Id.Lit_LBracket '['>} 
                                          {(DQ (${ Id.VSub_Name PORTAGE_DEBUG))} {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ <1>)} {<Id.Lit_RBracket ']'>}
                                        )
                                        (C {<Id.Lit_LBracket '['>} 
                                          {
                                            (DQ 
                                              (braced_var_sub
                                                token: <Id.VSub_Hyphen ->
                                                suffix_op: 
                                                  (suffix_op.PatSub
                                                    pat: {<x>}
                                                    replace: {}
                                                    replace_mode: Id.Undefined_Tok
                                                  )
                                              )
                                            )
                                          } {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ ($ Id.VSub_Hyphen '$-'))} {<Id.Lit_RBracket ']'>}
                                        )
                                      ]
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [(C {<__dyn_> (${ Id.VSub_Number 1)})]
                          spids: [7505 7547]
                        )
                      ]
                      else_action: [
                        (C {<Id.KW_Set set>} {<-x>})
                        (C {<__dyn_> (${ Id.VSub_Number 1)})
                        (C {<Id.KW_Set set>} {<Id.Lit_Other '+'> <x>})
                      ]
                    )
                  ]
                  spids: [7477 7482 7579 -1]
                )
                (case_arm pat_list:[{<_internal_test>}] spids:[7582 7583 7586 -1])
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (C {<export>} {<Id.Lit_VarLike 'SANDBOX_ON='> (DQ <1>)})
                    (C {<echo>} {(DQ <'Unrecognized arg \''> (${ Id.VSub_Number 1) <'\''>)})
                    (C {<echo>})
                    (C {<__dyn_help>})
                    (command.ControlFlow
                      token: <Id.ControlFlow_Exit exit>
                      arg_word: {<1>}
                    )
                  ]
                  spids: [7589 7590 7623 -1]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.Pipeline
                              children: [
                                (C {<has>} {(DQ (${ Id.VSub_Number 1))} {<clean>} {<help>} {<info>} 
                                  {<nofetch>}
                                )
                              ]
                              negated: T
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<umask>} {<002>})
                    (C {<cd>} {(DQ (${ Id.VSub_Name PORTAGE_PYM_PATH))})
                    (command.Pipeline
                      children: [
                        (C {<__save_ebuild_env>})
                        (command.Simple
                          words: [{<__filter_readonly_variables>} {<--filter-features>}]
                          redirects: [
                            (redir
                              op: <Id.Redir_Great '>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {(DQ ($ Id.VSub_DollarName '$T') <'/environment'>)}
                            )
                          ]
                          do_fork: T
                        )
                      ]
                      negated: F
                    )
                    (C {<assert>} {(DQ <'__save_ebuild_env failed'>)})
                    (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_DollarName '$T') <'/environment'>)}
                    )
                    (C {<chmod>} {<g> <Id.Lit_Other '+'> <w>} 
                      {(DQ ($ Id.VSub_DollarName '$T') <'/environment'>)}
                    )
                  ]
                  spids: [7634 7656]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.Unary
                      op_id: Id.BoolUnary_n
                      child: {($ Id.VSub_DollarName '$PORTAGE_EBUILD_EXIT_FILE')}
                    )
                )
                (command.Simple
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {(DQ ($ Id.VSub_DollarName '$PORTAGE_EBUILD_EXIT_FILE'))}
                    )
                  ]
                  do_fork: 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: {($ Id.VSub_DollarName '$PORTAGE_IPC_DAEMON')}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.DBracket
                      expr: 
                        (bool_expr.LogicalNot
                          child: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_s
                              child: {($ Id.VSub_DollarName '$SANDBOX_LOG')}
                            )
                        )
                    )
                    (C {(DQ ($ Id.VSub_DollarName '$PORTAGE_BIN_PATH')) <'/ebuild-ipc'>} 
                      {<Id.ControlFlow_Exit exit>} {($ Id.VSub_QMark '$?')}
                    )
                  ]
                  spids: [7750 7762]
                )
              ]
            )
          ]
        )
    )
  ]
)