(command.CommandList
  children: [
    (C {<.>} {<'./build.conf'>})
    (C {<export>} {<MKFLG>})
    (C {<export>} 
      {<Id.Lit_VarLike 'MWD='> (command_sub left_token:<Id.Left_Backtick '`'> child:(C {<pwd>}))}
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:ARCH_LIST)
          op: assign_op.Equal
          rhs: {(DQ <'default i686 x86_64 arm'>)}
          spids: [28]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:ARCH_LIST_EX)
          op: assign_op.Equal
          rhs: 
            {
              (DQ 
                <
'i486 i586 i686 x86_64 armv4l armv4tl armv5l armv6l m68k mips mips64 mipsel powerpc powerpc-440fp sh2eb sh2elf sh4 sparc'
                >
              )
            }
          spids: [36]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:DEFAULT_x86)
          op: assign_op.Equal
          rhs: {<i686>}
          spids: [42]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:DEFAULT_ARM)
          op: assign_op.Equal
          rhs: {<armv6l>}
          spids: [45]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:PREBUILT_BINARIES)
          op: assign_op.Equal
          rhs: {(DQ <'http://01micko.com/wdlkmpx/woof-CE/initrd_progs-20170322-static.tar.xz'>)}
          spids: [52]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:ARCH)
          op: assign_op.Equal
          rhs: {(command_sub left_token:<Id.Left_Backtick '`'> child:(C {<uname>} {<-m>}))}
          spids: [58]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:OS_ARCH)
          op: assign_op.Equal
          rhs: {($ Id.VSub_DollarName '$ARCH')}
          spids: [67]
        )
      ]
    )
    (command.ShFunction
      name: get_initrd_progs
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'var='> <INITRD_PROGS>})
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_Number '$1'))} {<Id.Lit_Equals '='>} 
                  {(DQ <-pkg>)} {<Id.Lit_RBracket ']'>}
                )
                (BraceGroup
                  children: [
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:var)
                              op: assign_op.Equal
                              rhs: {<PACKAGES>}
                              spids: [104]
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (command.Sentence
                      child: (C {<shift>})
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              ]
            )
            (C {<local>} {<Id.Lit_VarLike 'arch='> ($ Id.VSub_Number '$1')})
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$arch'))} {<Id.Lit_Equals '='>} {(DQ )} 
                  {<Id.Lit_RBracket ']'>}
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:arch)
                      op: assign_op.Equal
                      rhs: {(command_sub left_token:<Id.Left_Backtick '`'> child:(C {<uname>} {<-m>}))}
                      spids: [137]
                    )
                  ]
                )
              ]
            )
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName '$arch'))}
              arms: [
                (case_arm
                  pat_list: [{<i> <Id.Lit_QMark '?'> <86>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:arch)
                          op: assign_op.Equal
                          rhs: {(DQ <x86>)}
                          spids: [160]
                        )
                      ]
                    )
                  ]
                  spids: [155 158 165 -1]
                )
              ]
            )
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName '$arch'))}
              arms: [
                (case_arm
                  pat_list: [{<arm> <Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:arch)
                          op: assign_op.Equal
                          rhs: {(SQ <arm>)}
                          spids: [182]
                        )
                      ]
                    )
                  ]
                  spids: [178 180 187 -1]
                )
              ]
            )
            (C {<eval>} {<echo>} 
              {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) 
                ($ Id.VSub_DollarName '$var')
              } 
              {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) (${ Id.VSub_Name var) 
                <Id.Lit_Underscore _> (${ Id.VSub_Name arch)
              }
            )
          ]
        )
    )
    (command.Case
      to_match: {(DQ ($ Id.VSub_Number '$1'))}
      arms: [
        (case_arm
          pat_list: [{<release>} {<tarball>}]
          action: [
            (C {<echo>} 
              {(DQ <'If you made changes then don\'t forget to remove all 00_* directories first'>)}
            )
            (C {<sleep>} {<4>})
            (command.ForEach
              iter_name: a
              iter_words: [
                {
                  (braced_var_sub
                    token: <Id.VSub_Name ARCH_LIST>
                    suffix_op: (suffix_op.Unary tok:<Id.VOp1_Pound '#'> arg_word:{<'default '>})
                  )
                }
              ]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.Sentence
                      child: 
                        (C {($ Id.VSub_Number '$0')} {<-nord>} {<-auto>} {<-arch>} 
                          {($ Id.VSub_DollarName '$a')}
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:pkgx)
                  op: assign_op.Equal
                  rhs: 
                    {<initrd_progs-> 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<date>} {(DQ <'+%Y%m%d'>)})
                      ) <-static.tar.xz>
                    }
                  spids: [274]
                )
              ]
            )
            (C {<echo>} {<-e>} 
              {
                (DQ <Id.Lit_BadBackslash '\\'> <n> <Id.Lit_BadBackslash '\\'> <n> 
                  <Id.Lit_BadBackslash '\\'> <'n*** Creating '> ($ Id.VSub_DollarName '$pkgx')
                )
              }
            )
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [(command.Sentence child:(C {<read>} {<ARCH>}) terminator:<Id.Op_Semi _>)]
                )
              body: 
                (command.DoGroup
                  children: [
                    (command.ForEach
                      iter_name: PROG
                      iter_words: [
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (C {<get_initrd_progs>} 
                                {
                                  (braced_var_sub
                                    token: <Id.VSub_Name ARCH>
                                    suffix_op: 
                                      (suffix_op.Unary
                                        tok: <Id.VOp1_Pound '#'>
                                        arg_word: {<00_>}
                                      )
                                  )
                                }
                              )
                          )
                        }
                      ]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.Case
                              to_match: {($ Id.VSub_DollarName '$PROG')}
                              arms: [
                                (case_arm
                                  pat_list: [{(DQ )} {(SQ <'#'>) <Id.Lit_Star '*'>}]
                                  action: [
                                    (command.ControlFlow
                                      token: <Id.ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [339 346 350 -1]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:progs2tar)
                                  op: assign_op.PlusEqual
                                  rhs: 
                                    {
                                      (DQ <' '> (${ Id.VSub_Name ARCH) <'/bin/'> (${ Id.VSub_Name PROG))
                                    }
                                  spids: [355]
                                )
                              ]
                            )
                          ]
                        )
                    )
                  ]
                )
              redirects: [
                (redir
                  op: <Id.Redir_TLess '<<<'>
                  loc: (redir_loc.Fd fd:0)
                  arg: 
                    {
                      (DQ 
                        (command_sub
                          left_token: <Id.Left_DollarParen '$('>
                          child: (C {<ls>} {<-d>} {<00_> <Id.Lit_Star '*'>})
                        )
                      )
                    }
                )
              ]
            )
            (C {<tar>} {<-Jcf>} {($ Id.VSub_DollarName '$pkgx')} {(${ Id.VSub_Name progs2tar)})
            (C {<echo>} {(DQ <Done.>)})
            (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
          ]
          spids: [222 225 -1 407]
        )
      ]
    )
    (command.Case
      to_match: {(DQ ($ Id.VSub_Number '$1'))}
      arms: [
        (case_arm
          pat_list: [{<w>} {<w_apps>} {<c>}]
          action: [
            (command.ForEach
              iter_name: a
              iter_words: [
                {
                  (braced_var_sub
                    token: <Id.VSub_Name ARCH_LIST>
                    suffix_op: (suffix_op.Unary tok:<Id.VOp1_Pound '#'> arg_word:{<'default '>})
                  )
                }
              ]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.Sentence
                      child: 
                        (C {($ Id.VSub_Number '$0')} {<-nord>} {<-auto>} {<-arch>} 
                          {($ Id.VSub_DollarName '$a')} {<-pkg>} {<w_apps>}
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
            )
            (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
          ]
          spids: [418 423 -1 463]
        )
      ]
    )
    (command.ShFunction
      name: fatal_error
      body: 
        (BraceGroup
          children: [
            (command.Sentence
              child: (C {<echo>} {<-e>} {(DQ ($ Id.VSub_At '$@'))})
              terminator: <Id.Op_Semi _>
            )
            (command.Sentence
              child: (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
              terminator: <Id.Op_Semi _>
            )
          ]
        )
    )
    (command.ShFunction
      name: help_msg
      body: 
        (BraceGroup
          children: [
            (C {<echo>} 
              {
                (DQ <'Build static apps in the queue defined in build.conf\n'> <'\n'> <'Usage:\n'> 
                  <'  '> ($ Id.VSub_Number '$0') <' [options]\n'> <'\n'> <'Options:\n'> 
                  <'  -pkg pkg    : compile specific pkg only\n'> <'  -all        : force building all *_static pkgs\n'> <'  -arch target: compile for target arch\n'> 
                  <'  -sysgcc     : use system gcc\n'> <'  -cross      : use the cross compilers from Aboriginal Linux\n'> 
                  <'  -download   : download pkgs only, this overrides other options\n'> <'  -specs file : DISTRO_SPECS file to use\n'> <'  -prebuilt   : use prebuilt binaries\n'> 
                  <'  -lang locale: set locale\n'> <'  -keymap km  : set keyboard layout\n'> <'  -auto       : don\'t prompt for input\n'> 
                  <'  -gz|-xz     : compression method for the initrd\n'> <'  -help       : show help and exit\n'> <'\n'> <'  Valid <targets> for -arch:\n'> <'      '> 
                  ($ Id.VSub_DollarName '$ARCH_LIST_EX') <'\n'> <'\n'> <'  The most relevant <targets> for Puppy are:\n'> <'      '> 
                  (braced_var_sub
                    token: <Id.VSub_Name ARCH_LIST>
                    suffix_op: (suffix_op.Unary tok:<Id.VOp1_Pound '#'> arg_word:{<'default '>})
                  ) <'\n'> <'\n'> <'  Note that one target not yet supported by musl is aarch64 (arm64)\n'>
                )
              }
            )
          ]
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:USE_SYS_GCC)
          op: assign_op.Equal
          rhs: {<no>}
          spids: [552]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:CROSS_COMPILE)
          op: assign_op.Equal
          rhs: {<no>}
          spids: [555]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:FORCE_BUILD_ALL)
          op: assign_op.Equal
          rhs: {<no>}
          spids: [558]
        )
      ]
    )
    (C {<export>} {<Id.Lit_VarLike 'DLD_ONLY='> <no>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:INITRD_CREATE)
          op: assign_op.Equal
          rhs: {<yes>}
          spids: [566]
        )
      ]
    )
    (command.Case
      to_match: {(${ Id.VSub_Name INITRD_COMP)}
      arms: [
        (case_arm
          pat_list: [{<gz>} {<xz>}]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:ok)
                  op: assign_op.Equal
                  rhs: {<yes>}
                  spids: [583]
                )
              ]
            )
          ]
          spids: [578 581 586 -1]
        )
        (case_arm
          pat_list: [{<Id.Lit_Star '*'>}]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:INITRD_COMP)
                  op: assign_op.Equal
                  rhs: {(DQ <gz>)}
                  spids: [592]
                )
              ]
            )
          ]
          spids: [589 590 597 -1]
        )
      ]
    )
    (command.WhileUntil
      keyword: <Id.KW_While while>
      cond: 
        (condition.Shell
          commands: [
            (command.Sentence
              child: (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_Number '$1'))} {<Id.Lit_RBracket ']'>})
              terminator: <Id.Op_Semi _>
            )
          ]
        )
      body: 
        (command.DoGroup
          children: [
            (command.Case
              to_match: {($ Id.VSub_Number '$1')}
              arms: [
                (case_arm
                  pat_list: [{<-sysgcc>}]
                  action: [
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:USE_SYS_GCC)
                              op: assign_op.Equal
                              rhs: {<yes>}
                              spids: [630]
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:USE_PREBUILT)
                              op: assign_op.Equal
                              rhs: {<no>}
                              spids: [635]
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (C {<shift>})
                  ]
                  spids: [627 628 641 -1]
                )
                (case_arm
                  pat_list: [{<-cross>}]
                  action: [
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:CROSS_COMPILE)
                              op: assign_op.Equal
                              rhs: {<yes>}
                              spids: [647]
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:USE_PREBUILT)
                              op: assign_op.Equal
                              rhs: {<no>}
                              spids: [652]
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (C {<shift>})
                  ]
                  spids: [644 645 658 -1]
                )
                (case_arm
                  pat_list: [{<-all>}]
                  action: [
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:FORCE_BUILD_ALL)
                              op: assign_op.Equal
                              rhs: {<yes>}
                              spids: [664]
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (C {<shift>})
                  ]
                  spids: [661 662 671 -1]
                )
                (case_arm
                  pat_list: [{<-gz>} {<-xz>} {<gz>} {<xz>}]
                  action: [
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:INITRD_COMP)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (braced_var_sub
                                    token: <Id.VSub_Number 1>
                                    suffix_op: (suffix_op.Unary tok:<Id.VOp1_Pound '#'> arg_word:{<->})
                                  )
                                }
                              spids: [683]
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (C {<shift>})
                  ]
                  spids: [674 681 694 -1]
                )
                (case_arm
                  pat_list: [{<-download>}]
                  action: [
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:DLD_ONLY)
                              op: assign_op.Equal
                              rhs: {<yes>}
                              spids: [700]
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (C {<shift>})
                  ]
                  spids: [697 698 707 -1]
                )
                (case_arm
                  pat_list: [{<-prebuilt>}]
                  action: [
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:USE_PREBUILT)
                              op: assign_op.Equal
                              rhs: {<yes>}
                              spids: [713]
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (C {<shift>})
                  ]
                  spids: [710 711 720 -1]
                )
                (case_arm
                  pat_list: [{<-nord>}]
                  action: [
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:INITRD_CREATE)
                              op: assign_op.Equal
                              rhs: {<no>}
                              spids: [726]
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (C {<shift>})
                  ]
                  spids: [723 724 733 -1]
                )
                (case_arm
                  pat_list: [{<-auto>}]
                  action: [
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:PROMPT)
                              op: assign_op.Equal
                              rhs: {<no>}
                              spids: [739]
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (C {<shift>})
                  ]
                  spids: [736 737 746 -1]
                )
                (case_arm
                  pat_list: [{<-v>}]
                  action: [
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:V)
                              op: assign_op.Equal
                              rhs: {<-v>}
                              spids: [752]
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (C {<shift>})
                  ]
                  spids: [749 750 759 -1]
                )
                (case_arm
                  pat_list: [{<-lang>}]
                  action: [
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:LOCALE)
                              op: assign_op.Equal
                              rhs: {(DQ ($ Id.VSub_Number '$2'))}
                              spids: [765]
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (C {<shift>} {<2>})
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$LOCALE'))} 
                          {<Id.Lit_Equals '='>} {(DQ )} {<Id.Lit_RBracket ']'>}
                        )
                        (C {<fatal_error>} 
                          {(DQ ($ Id.VSub_Number '$0') <' -locale: No locale specified'>)}
                        )
                      ]
                    )
                  ]
                  spids: [762 763 799 -1]
                )
                (case_arm
                  pat_list: [{<-keymap>}]
                  action: [
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:KEYMAP)
                              op: assign_op.Equal
                              rhs: {(DQ ($ Id.VSub_Number '$2'))}
                              spids: [805]
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (C {<shift>} {<2>})
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$KEYMAP'))} 
                          {<Id.Lit_Equals '='>} {(DQ )} {<Id.Lit_RBracket ']'>}
                        )
                        (C {<fatal_error>} 
                          {(DQ ($ Id.VSub_Number '$0') <' -locale: No keymap specified'>)}
                        )
                      ]
                    )
                  ]
                  spids: [802 803 839 -1]
                )
                (case_arm
                  pat_list: [{<-pkg>}]
                  action: [
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:BUILD_PKG)
                              op: assign_op.Equal
                              rhs: {(DQ ($ Id.VSub_Number '$2'))}
                              spids: [845]
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (C {<shift>} {<2>})
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$BUILD_PKG'))} 
                          {<Id.Lit_Equals '='>} {(DQ )} {<Id.Lit_RBracket ']'>}
                        )
                        (C {<fatal_error>} 
                          {(DQ ($ Id.VSub_Number '$0') <' -pkg: Specify a pkg to compile'>)}
                        )
                      ]
                    )
                  ]
                  spids: [842 843 879 -1]
                )
                (case_arm
                  pat_list: [{<-arch>}]
                  action: [
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:TARGET_ARCH)
                              op: assign_op.Equal
                              rhs: {(DQ ($ Id.VSub_Number '$2'))}
                              spids: [885]
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (C {<shift>} {<2>})
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$TARGET_ARCH'))} 
                          {<Id.Lit_Equals '='>} {(DQ )} {<Id.Lit_RBracket ']'>}
                        )
                        (C {<fatal_error>} 
                          {(DQ ($ Id.VSub_Number '$0') <' -arch: Specify a target arch'>)}
                        )
                      ]
                    )
                  ]
                  spids: [882 883 919 -1]
                )
                (case_arm
                  pat_list: [{<-specs>}]
                  action: [
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:DISTRO_SPECS)
                              op: assign_op.Equal
                              rhs: {(DQ ($ Id.VSub_Number '$2'))}
                              spids: [925]
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (C {<shift>} {<2>})
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<Id.Lit_LBracket '['>} {<Id.KW_Bang '!'>} {<-f>} 
                          {(DQ ($ Id.VSub_DollarName '$DISTRO_SPECS'))} {<Id.Lit_RBracket ']'>}
                        )
                        (C {<fatal_error>} 
                          {
                            (DQ ($ Id.VSub_Number '$0') <' -specs: \''> (${ Id.VSub_Name DISTRO_SPECS) 
                              <'\' is not a regular file'>
                            )
                          }
                        )
                      ]
                    )
                  ]
                  spids: [922 923 962 -1]
                )
                (case_arm
                  pat_list: [{<-h>} {<-help>} {<--help>}]
                  action: [
                    (command.Sentence
                      child: (C {<help_msg>})
                      terminator: <Id.Op_Semi _>
                    )
                    (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
                  ]
                  spids: [965 970 978 -1]
                )
                (case_arm
                  pat_list: [{<-clean>}]
                  action: [
                    (command.Sentence
                      child: 
                        (C {<echo>} {<-e>} 
                          {
                            (DQ 
                              <
'Press P and hit enter to proceed, any other combination to cancel..'
                              >
                            )
                          }
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (C {<read>} {<zz>})
                    (command.Case
                      to_match: {($ Id.VSub_DollarName '$zz')}
                      arms: [
                        (case_arm
                          pat_list: [{<p>} {<P>}]
                          action: [
                            (C {<echo>} {<rm>} {<-rf>} 
                              {<initrd.> <Id.Lit_LBracket '['> <gx> <Id.Lit_RBracket ']'> <z>} {<initrd_progs-> <Id.Lit_Star '*'> <.tar.> <Id.Lit_Star '*'>} {<ZZ_initrd-expanded>} 
                              {<00_> <Id.Lit_Star '*'>} {<0sources>} {<cross-compiler> <Id.Lit_Star '*'>}
                            )
                          ]
                          spids: [1006 1009 1038 -1]
                        )
                      ]
                    )
                    (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
                  ]
                  spids: [981 982 1046 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (C {<echo>} {(DQ <'Unrecognized option: '> ($ Id.VSub_Number '$1'))})
                    (C {<shift>})
                  ]
                  spids: [1049 1050 1064 -1]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: use_prebuilt_binaries
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {<Id.KW_Bang '!'>} 
                  {(DQ ($ Id.VSub_DollarName '$PREBUILT_BINARIES'))} {<Id.Lit_RBracket ']'>}
                )
                (BraceGroup
                  children: [
                    (command.Sentence
                      child: (C {<echo>} {(DQ <ERROR>)})
                      terminator: <Id.Op_Semi _>
                    )
                    (command.Sentence
                      child: (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:zfile)
                  op: assign_op.Equal
                  rhs: 
                    {<'0sources/'> 
                      (braced_var_sub
                        token: <Id.VSub_Name PREBUILT_BINARIES>
                        suffix_op: 
                          (suffix_op.Unary
                            tok: <Id.VOp1_DPound '##'>
                            arg_word: {<Id.Lit_Other '*'> <Id.Lit_Slash '/'>}
                          )
                      )
                    }
                  spids: [1115]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {<-f>} {(DQ ($ Id.VSub_DollarName '$zfile'))} 
                              {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (command.Simple
                          words: [{<tar>} {<-taf>} {(DQ ($ Id.VSub_DollarName '$zfile'))}]
                          redirects: [
                            (redir
                              op: <Id.Redir_AndGreat '&>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<'/dev/null'>}
                            )
                          ]
                          do_fork: T
                        )
                        (C {<rm>} {<-f>} {(DQ ($ Id.VSub_DollarName '$zfile'))})
                      ]
                    )
                  ]
                  spids: [1125 1139]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {<Id.KW_Bang '!'>} {<-f>} 
                              {(DQ ($ Id.VSub_DollarName '$zfile'))} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<mkdir>} {<-p>} {<0sources>})
                    (C {<wget>} {<-P>} {<0sources>} {<--no-check-certificate>} 
                      {(DQ ($ Id.VSub_DollarName '$PREBUILT_BINARIES'))}
                    )
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<Id.Lit_LBracket '['>} {($ Id.VSub_QMark '$?')} {<-eq>} {<0>} 
                          {<Id.Lit_RBracket ']'>}
                        )
                        (BraceGroup
                          children: [
                            (command.Sentence
                              child: (C {<rm>} {<-f>} {(DQ ($ Id.VSub_DollarName '$zfile'))})
                              terminator: <Id.Op_Semi _>
                            )
                            (command.Sentence
                              child: (C {<echo>} {(DQ <ERROR>)})
                              terminator: <Id.Op_Semi _>
                            )
                            (command.Sentence
                              child: 
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Exit exit>
                                  arg_word: {<1>}
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [1171 1187]
                )
              ]
            )
            (C {<echo>} 
              {
                (DQ <'* Extracting '> 
                  (braced_var_sub
                    token: <Id.VSub_Name zfile>
                    suffix_op: 
                      (suffix_op.Unary
                        tok: <Id.VOp1_DPound '##'>
                        arg_word: {<Id.Lit_Other '*'> <Id.Lit_Slash '/'>}
                      )
                  ) <...>
                )
              }
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<tar>} {<-xaf>} {(DQ ($ Id.VSub_DollarName '$zfile'))})
                (BraceGroup
                  children: [
                    (command.Sentence
                      child: (C {<rm>} {<-f>} {(DQ ($ Id.VSub_DollarName '$zfile'))})
                      terminator: <Id.Op_Semi _>
                    )
                    (command.Sentence
                      child: (C {<echo>} {(DQ <ERROR>)})
                      terminator: <Id.Op_Semi _>
                    )
                    (command.Sentence
                      child: (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: set_compiler
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.Simple
                  words: [{<which>} {<make>}]
                  redirects: [
                    (redir
                      op: <Id.Redir_AndGreat '&>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {<'/dev/null'>}
                    )
                  ]
                  do_fork: T
                )
                (C {<fatal_error>} {<echo>} 
                  {(DQ <'It looks like development tools are not installed.. stopping'>)}
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$USE_SYS_GCC'))} 
                              {<Id.Lit_Equals '='>} {(DQ <no>)} {<-a>} {(DQ ($ Id.VSub_DollarName '$CROSS_COMPILE'))} {<Id.Lit_Equals '='>} {(DQ <no>)} 
                              {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.Case
                      to_match: {($ Id.VSub_DollarName '$ARCH')}
                      arms: [
                        (case_arm
                          pat_list: [{<i> <Id.Lit_QMark '?'> <86>} {<x86_64>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:CROSS_COMPILE)
                                  op: assign_op.Equal
                                  rhs: {<yes>}
                                  spids: [1399]
                                )
                              ]
                            )
                          ]
                          spids: [1392 1397 1402 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:USE_SYS_GCC)
                                  op: assign_op.Equal
                                  rhs: {<yes>}
                                  spids: [1408]
                                )
                              ]
                            )
                          ]
                          spids: [1405 1406 1411 -1]
                        )
                      ]
                    )
                  ]
                  spids: [1336 1366]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$USE_SYS_GCC'))} 
                              {<Id.Lit_Equals '='>} {(DQ <yes>)} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (command.Simple
                          words: [{<which>} {<gcc>}]
                          redirects: [
                            (redir
                              op: <Id.Redir_AndGreat '&>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<'/dev/null'>}
                            )
                          ]
                          do_fork: T
                        )
                        (C {<fatal_error>} {(DQ <'No gcc, aborting...'>)})
                      ]
                    )
                    (C {<echo>} {<-e>} 
                      {
                        (DQ <Id.Lit_BadBackslash '\\'> <'nBuilding in: '> 
                          ($ Id.VSub_DollarName '$ARCH')
                        )
                      }
                    )
                    (C {<echo>} {<-e>} 
                      {
                        (DQ <Id.Lit_BadBackslash '\\'> <'n* Using system gcc'> 
                          <Id.Lit_BadBackslash '\\'> <n>
                        )
                      }
                    )
                    (C {<sleep>} {<1.5>})
                  ]
                  spids: [1420 1438]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:CROSS_COMPILE)
                      op: assign_op.Equal
                      rhs: {<yes>}
                      spids: [1492]
                    )
                  ]
                )
                (command.Case
                  to_match: {($ Id.VSub_DollarName '$ARCH')}
                  arms: [
                    (case_arm
                      pat_list: [{<i> <Id.Lit_QMark '?'> <86>} {<x86_64>}]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:ok)
                              op: assign_op.Equal
                              rhs: {<yes>}
                              spids: [1513]
                            )
                          ]
                        )
                      ]
                      spids: [1506 1511 1516 -1]
                    )
                    (case_arm
                      pat_list: [{<Id.Lit_Star '*'>}]
                      action: [
                        (C {<fatal_error>} 
                          {
                            (DQ <'*** Only use x86 systems to cross-compile'> 
                              <Id.Lit_BadBackslash '\\'> <'n* Run '> ($ Id.VSub_Number '$0') <' -sysgcc to use the system gcc ... '> <Id.Lit_BadBackslash '\\'> 
                              <n>
                            )
                          }
                        )
                      ]
                      spids: [1519 1520 1534 -1]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: select_target_arch
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$CROSS_COMPILE'))} 
                  {<Id.Lit_Equals '='>} {(DQ <no>)} {<-a>} {(DQ ($ Id.VSub_DollarName '$USE_PREBUILT'))} {<Id.Lit_Equals '='>} {(DQ <no>)} 
                  {<Id.Lit_RBracket ']'>}
                )
                (command.ControlFlow token:<Id.ControlFlow_Return return>)
              ]
            )
            (command.Case
              to_match: {($ Id.VSub_DollarName '$TARGET_ARCH')}
              arms: [
                (case_arm
                  pat_list: [{<default>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:TARGET_ARCH)
                          op: assign_op.Equal
                          rhs: {(${ Id.VSub_Name ARCH)}
                          spids: [1603]
                        )
                      ]
                    )
                  ]
                  spids: [1600 1601 1608 -1]
                )
                (case_arm
                  pat_list: [{<x86>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:TARGET_ARCH)
                          op: assign_op.Equal
                          rhs: {(${ Id.VSub_Name DEFAULT_x86)}
                          spids: [1614]
                        )
                      ]
                    )
                  ]
                  spids: [1611 1612 1619 -1]
                )
                (case_arm
                  pat_list: [{<arm>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:TARGET_ARCH)
                          op: assign_op.Equal
                          rhs: {(${ Id.VSub_Name DEFAULT_ARM)}
                          spids: [1625]
                        )
                      ]
                    )
                  ]
                  spids: [1622 1623 1630 -1]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:VALID_TARGET_ARCH)
                  op: assign_op.Equal
                  rhs: {<no>}
                  spids: [1640]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$TARGET_ARCH'))} 
                              {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ )} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ForEach
                      iter_name: a
                      iter_words: [{($ Id.VSub_DollarName '$ARCH_LIST_EX')}]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.AndOr
                              ops: [Id.Op_DAmp Id.Op_DAmp]
                              children: [
                                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$TARGET_ARCH'))} 
                                  {<Id.Lit_Equals '='>} {(DQ ($ Id.VSub_DollarName '$a'))} {<Id.Lit_RBracket ']'>}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:VALID_TARGET_ARCH)
                                      op: assign_op.Equal
                                      rhs: {<yes>}
                                      spids: [1697]
                                    )
                                  ]
                                )
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Break break>
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<Id.Lit_LBracket '['>} 
                                      {(DQ ($ Id.VSub_DollarName '$VALID_TARGET_ARCH'))} {<Id.Lit_Equals '='>} {(DQ <no>)} {<Id.Lit_RBracket ']'>}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<echo>} 
                              {(DQ <'Invalid target arch: '> ($ Id.VSub_DollarName '$TARGET_ARCH'))}
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Exit exit>
                              arg_word: {<1>}
                            )
                          ]
                          spids: [1708 1726]
                        )
                      ]
                      else_action: [
                        (command.AndOr
                          ops: [Id.Op_DAmp]
                          children: [
                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$TARGET_ARCH'))} 
                              {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ <default>)} {<Id.Lit_RBracket ']'>}
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:ARCH)
                                  op: assign_op.Equal
                                  rhs: {(${ Id.VSub_Name TARGET_ARCH)}
                                  spids: [1762]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [1644 1662]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} 
                              {(DQ ($ Id.VSub_DollarName '$VALID_TARGET_ARCH'))} {<Id.Lit_Equals '='>} {(DQ <no>)} {<-a>} {(DQ ($ Id.VSub_DollarName '$PROMPT'))} {<Id.Lit_Equals '='>} 
                              {(DQ <yes>)} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<echo>} {<-e>} 
                      {
                        (DQ <Id.Lit_BadBackslash '\\'> 
                          <'nWe\'re going to compile apps for the init ram disk'>
                        )
                      }
                    )
                    (C {<echo>} {<-e>} 
                      {(DQ <'Select the arch you want to compile to'> <Id.Lit_BadBackslash '\\'> <n>)}
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:x)
                          op: assign_op.Equal
                          rhs: {<1>}
                          spids: [1832]
                        )
                      ]
                    )
                    (command.ForEach
                      iter_name: a
                      iter_words: [{($ Id.VSub_DollarName '$ARCH_LIST')}]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.Case
                              to_match: {($ Id.VSub_DollarName '$a')}
                              arms: [
                                (case_arm
                                  pat_list: [{<default>}]
                                  action: [
                                    (C {<echo>} 
                                      {
                                        (DQ <'\t'> (${ Id.VSub_Name x) <') default ['> 
                                          (${ Id.VSub_Name ARCH) <']'>
                                        )
                                      }
                                    )
                                  ]
                                  spids: [1856 1857 1873 -1]
                                )
                                (case_arm
                                  pat_list: [{<Id.Lit_Star '*'>}]
                                  action: [
                                    (C {<echo>} 
                                      {
                                        (DQ <'\t'> (${ Id.VSub_Name x) <') '> 
                                          ($ Id.VSub_DollarName '$a')
                                        )
                                      }
                                    )
                                  ]
                                  spids: [1876 1877 1890 -1]
                                )
                              ]
                            )
                            (C {<let>} {<x> <Id.Lit_Other '+'> <Id.Lit_Other '+'>})
                          ]
                        )
                    )
                    (C {<echo>} {(DQ <'\t*) default ['> (${ Id.VSub_Name ARCH) <']'>)})
                    (command.Sentence
                      child: 
                        (C {<echo>} {<-en>} {(DQ <Id.Lit_BadBackslash '\\'> <'nEnter your choice: '>)})
                      terminator: <Id.Op_Semi _>
                    )
                    (C {<read>} {<choice>})
                    (C {<echo>})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:x)
                          op: assign_op.Equal
                          rhs: {<1>}
                          spids: [1936]
                        )
                      ]
                    )
                    (command.ForEach
                      iter_name: a
                      iter_words: [{($ Id.VSub_DollarName '$ARCH_LIST')}]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.Sentence
                              child: 
                                (command.AndOr
                                  ops: [Id.Op_DAmp Id.Op_DAmp]
                                  children: [
                                    (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$x'))} 
                                      {<Id.Lit_Equals '='>} {(DQ ($ Id.VSub_DollarName '$choice'))} {<Id.Lit_RBracket ']'>}
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:selected_arch)
                                          op: assign_op.Equal
                                          rhs: {($ Id.VSub_DollarName '$a')}
                                          spids: [1968]
                                        )
                                      ]
                                    )
                                    (command.ControlFlow
                                      token: <Id.ControlFlow_Break break>
                                    )
                                  ]
                                )
                              terminator: <Id.Op_Semi _>
                            )
                            (command.Sentence
                              child: (C {<let>} {<x> <Id.Lit_Other '+'> <Id.Lit_Other '+'>})
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                    )
                    (command.ForEach
                      iter_name: a
                      iter_words: [{($ Id.VSub_DollarName '$ARCH_LIST_EX')}]
                      do_arg_iter: F
                      body: 
                        (command.DoGroup
                          children: [
                            (command.Sentence
                              child: 
                                (command.AndOr
                                  ops: [Id.Op_DAmp]
                                  children: [
                                    (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$a'))} 
                                      {<Id.Lit_Equals '='>} {(DQ ($ Id.VSub_DollarName '$choice'))} {<Id.Lit_RBracket ']'>}
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:selected_arch)
                                          op: assign_op.Equal
                                          rhs: {($ Id.VSub_DollarName '$a')}
                                          spids: [2016]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                    )
                    (command.Case
                      to_match: {($ Id.VSub_DollarName '$selected_arch')}
                      arms: [
                        (case_arm
                          pat_list: [{<default>} {(DQ )}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:ok)
                                  op: assign_op.Equal
                                  rhs: {<yes>}
                                  spids: [2036]
                                )
                              ]
                            )
                          ]
                          spids: [2031 2035 2039 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:ARCH)
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_DollarName '$selected_arch')}
                                  spids: [2045]
                                )
                              ]
                            )
                          ]
                          spids: [2042 2043 2048 -1]
                        )
                      ]
                    )
                  ]
                  spids: [1778 1808]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$USE_PREBUILT'))} 
                  {<Id.Lit_Equals '='>} {(DQ <yes>)} {<Id.Lit_RBracket ']'>}
                )
                (C {<echo>} {(DQ <'Arch: '> ($ Id.VSub_DollarName '$ARCH'))})
                (command.ControlFlow token:<Id.ControlFlow_Return return>)
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$DLD_ONLY'))} 
                              {<Id.Lit_Equals '='>} {(DQ <no>)} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.Case
                      to_match: {($ Id.VSub_DollarName '$OS_ARCH')}
                      arms: [
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'> <64>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:ok)
                                  op: assign_op.Equal
                                  rhs: {<yes>}
                                  spids: [2125]
                                )
                              ]
                            )
                          ]
                          spids: [2121 2123 2128 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [
                            (command.Case
                              to_match: {($ Id.VSub_DollarName '$ARCH')}
                              arms: [
                                (case_arm
                                  pat_list: [{<Id.Lit_Star '*'> <64>}]
                                  action: [
                                    (C {<fatal_error>} 
                                      {
                                        (DQ <Id.Lit_BadBackslash '\\'> 
                                          <
'n*** Trying to compile for a 64bit arch in a 32bit system?'
                                          > <Id.Lit_BadBackslash '\\'> <'n*** That\'s not possible.. exiting..'>
                                        )
                                      }
                                    )
                                  ]
                                  spids: [2140 2142 2153 -1]
                                )
                              ]
                            )
                          ]
                          spids: [2131 2132 2157 -1]
                        )
                      ]
                    )
                  ]
                  spids: [2093 2111]
                )
              ]
            )
            (C {<echo>} {(DQ <'Arch: '> ($ Id.VSub_DollarName '$ARCH'))})
            (C {<sleep>} {<1.5>})
          ]
        )
    )
    (command.ShFunction
      name: setup_cross_compiler
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$CROSS_COMPILE'))} 
                  {<Id.Lit_Equals '='>} {(DQ <no>)} {<Id.Lit_RBracket ']'>}
                )
                (command.ControlFlow token:<Id.ControlFlow_Return return>)
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:CCOMP_DIR)
                  op: assign_op.Equal
                  rhs: {<cross-compiler-> (${ Id.VSub_Name ARCH)}
                  spids: [2217]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:URL)
                  op: assign_op.Equal
                  rhs: {<http> <Id.Lit_Colon ':'> <'//landley.net/aboriginal/downloads/binaries'>}
                  spids: [2224]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:PACKAGE)
                  op: assign_op.Equal
                  rhs: {(${ Id.VSub_Name CCOMP_DIR) <.tar.gz>}
                  spids: [2230]
                )
              ]
            )
            (C {<echo>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {<Id.KW_Bang '!'>} {<-f>} 
                              {(DQ <'0sources/'> (${ Id.VSub_Name PACKAGE))} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<echo>} {(DQ <'Download cross compiler from Aboriginal Linux'>)})
                    (command.AndOr
                      ops: [Id.Op_DAmp Id.Op_DAmp]
                      children: [
                        (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$PROMPT'))} 
                          {<Id.Lit_Equals '='>} {(DQ <yes>)} {<Id.Lit_RBracket ']'>}
                        )
                        (C {<echo>} {<-n>} {(DQ <'Press enter to continue, CTRL-C to cancel...'>)})
                        (C {<read>} {<zzz>})
                      ]
                    )
                    (C {<wget>} {<-c>} {<-P>} {<0sources>} 
                      {(${ Id.VSub_Name URL) <'/'> (${ Id.VSub_Name PACKAGE)}
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<Id.Lit_LBracket '['>} {($ Id.VSub_QMark '$?')} {<-ne>} {<0>} 
                                      {<Id.Lit_RBracket ']'>}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<rm>} {<-rf>} {(${ Id.VSub_Name CCOMP_DIR)})
                            (C {<echo>} {(DQ <'failed to download '> (${ Id.VSub_Name PACKAGE))})
                            (command.ControlFlow
                              token: <Id.ControlFlow_Exit exit>
                              arg_word: {<1>}
                            )
                          ]
                          spids: [2319 2333]
                        )
                      ]
                    )
                  ]
                  spids: [2244 2261]
                )
              ]
              else_action: [
                (command.AndOr
                  ops: [Id.Op_DAmp]
                  children: [
                    (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$DLD_ONLY'))} 
                      {<Id.Lit_Equals '='>} {(DQ <yes>)} {<Id.Lit_RBracket ']'>}
                    )
                    (C {<echo>} {(DQ <'Already downloaded '> (${ Id.VSub_Name PACKAGE))})
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$DLD_ONLY'))} 
                  {<Id.Lit_Equals '='>} {(DQ <yes>)} {<Id.Lit_RBracket ']'>}
                )
                (command.ControlFlow token:<Id.ControlFlow_Return return>)
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {<Id.KW_Bang '!'>} {<-d>} 
                              {(DQ ($ Id.VSub_DollarName '$CCOMP_DIR'))} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<tar>} {<--directory> <Id.Lit_Equals '='> ($ Id.VSub_DollarName '$PWD')} 
                      {<-xaf>} {<'0sources/'> (${ Id.VSub_Name PACKAGE)}
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<Id.Lit_LBracket '['>} {($ Id.VSub_QMark '$?')} {<-ne>} {<0>} 
                                      {<Id.Lit_RBracket ']'>}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<rm>} {<-rf>} {(${ Id.VSub_Name CCOMP_DIR)})
                            (C {<rm>} {<-fv>} {<'0sources/'> (${ Id.VSub_Name PACKAGE)})
                            (C {<echo>} {(DQ <'failed to extract '> (${ Id.VSub_Name PACKAGE))})
                            (command.ControlFlow
                              token: <Id.ControlFlow_Exit exit>
                              arg_word: {<1>}
                            )
                          ]
                          spids: [2451 2465]
                        )
                      ]
                    )
                  ]
                  spids: [2418 2434]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {<Id.KW_Bang '!'>} {<-d>} 
                  {(DQ ($ Id.VSub_DollarName '$CCOMP_DIR'))} {<Id.Lit_RBracket ']'>}
                )
                (BraceGroup
                  children: [
                    (command.Sentence
                      child: (C {<echo>} {(DQ ($ Id.VSub_DollarName '$CCOMP_DIR') <' not found'>)})
                      terminator: <Id.Op_Semi _>
                    )
                    (command.Sentence
                      child: (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {<-d>} 
                              {<cross-compiler-> (${ Id.VSub_Name ARCH) <'/cc/lib'>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<cp>} {<cross-compiler-> (${ Id.VSub_Name ARCH) <'/cc/lib/'> <Id.Lit_Star '*'>} 
                      {<cross-compiler-> (${ Id.VSub_Name ARCH) <'/lib'>}
                    )
                  ]
                  spids: [2544 2560]
                )
              ]
            )
            (C {<echo>} {<-e>} 
              {
                (DQ <Id.Lit_BadBackslash '\\'> <'nUsing cross compiler from Aboriginal Linux'> 
                  <Id.Lit_BadBackslash '\\'> <n>
                )
              }
            )
            (C {<export>} {<Id.Lit_VarLike 'OVERRIDE_ARCH='> (${ Id.VSub_Name ARCH)})
            (C {<export>} 
              {<Id.Lit_VarLike 'XPATH='> (${ Id.VSub_Name PWD) <'/'> (${ Id.VSub_Name CCOMP_DIR)}
            )
          ]
        )
    )
    (command.ShFunction
      name: check_bin
      body: 
        (BraceGroup
          children: [
            (command.Case
              to_match: {($ Id.VSub_DollarName '$init_pkg')}
              arms: [
                (case_arm
                  pat_list: [{(DQ )} {(SQ <'#'>) <Id.Lit_Star '*'>}]
                  action: [(command.ControlFlow token:<Id.ControlFlow_Continue continue>)]
                  spids: [2642 2649 2653 -1]
                )
                (case_arm
                  pat_list: [{<coreutils_static>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:static_bins)
                          op: assign_op.Equal
                          rhs: {(SQ <cp>)}
                          spids: [2659]
                        )
                      ]
                    )
                  ]
                  spids: [2656 2657 2664 -1]
                )
                (case_arm
                  pat_list: [{<dosfstools_static>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:static_bins)
                          op: assign_op.Equal
                          rhs: {(SQ <fsck.fat>)}
                          spids: [2670]
                        )
                      ]
                    )
                  ]
                  spids: [2667 2668 2675 -1]
                )
                (case_arm
                  pat_list: [{<e2fsprogs_static>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:static_bins)
                          op: assign_op.Equal
                          rhs: {(SQ <'e2fsck resize2fs'>)}
                          spids: [2681]
                        )
                      ]
                    )
                  ]
                  spids: [2678 2679 2686 -1]
                )
                (case_arm
                  pat_list: [{<exfat-utils_static>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:static_bins)
                          op: assign_op.Equal
                          rhs: {(SQ <exfatfsck>)}
                          spids: [2692]
                        )
                      ]
                    )
                  ]
                  spids: [2689 2690 2697 -1]
                )
                (case_arm
                  pat_list: [{<fuse-exfat_static>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:static_bins)
                          op: assign_op.Equal
                          rhs: {(SQ <mount.exfat-fuse>)}
                          spids: [2703]
                        )
                      ]
                    )
                  ]
                  spids: [2700 2701 2708 -1]
                )
                (case_arm
                  pat_list: [{<findutils_static>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:static_bins)
                          op: assign_op.Equal
                          rhs: {(SQ <find>)}
                          spids: [2714]
                        )
                      ]
                    )
                  ]
                  spids: [2711 2712 2719 -1]
                )
                (case_arm
                  pat_list: [{<util-linux_static>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:static_bins)
                          op: assign_op.Equal
                          rhs: {(SQ <losetup>)}
                          spids: [2725]
                        )
                      ]
                    )
                  ]
                  spids: [2722 2723 2730 -1]
                )
                (case_arm
                  pat_list: [{<util-linux-222_static>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:static_bins)
                          op: assign_op.Equal
                          rhs: {(SQ <losetup-222>)}
                          spids: [2736]
                        )
                      ]
                    )
                  ]
                  spids: [2733 2734 2741 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:static_bins)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (braced_var_sub
                                token: <Id.VSub_Name init_pkg>
                                suffix_op: 
                                  (suffix_op.Unary
                                    tok: <Id.VOp1_Percent '%'>
                                    arg_word: {<_> <Id.Lit_Other '*'>}
                                  )
                              )
                            }
                          spids: [2747]
                        )
                      ]
                    )
                  ]
                  spids: [2744 2745 2755 -1]
                )
              ]
            )
            (command.ForEach
              iter_name: sbin
              iter_words: [{(${ Id.VSub_Name static_bins)}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<Id.Lit_LBracket '['>} {<-f>} 
                          {<'./00_'> (${ Id.VSub_Name ARCH) <'/bin/'> (${ Id.VSub_Name sbin)} {<Id.Lit_RBracket ']'>}
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {<1>}
                        )
                      ]
                    )
                  ]
                )
            )
          ]
        )
    )
    (command.ShFunction
      name: build_pkgs
      body: 
        (BraceGroup
          children: [
            (C {<rm>} {<-f>} {<.fatal>})
            (C {<mkdir>} {<-p>} {<00_> (${ Id.VSub_Name ARCH) <'/bin'>} 
              {<00_> (${ Id.VSub_Name ARCH) <'/log'>} {<0sources>}
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$DLD_ONLY'))} 
                              {<Id.Lit_Equals '='>} {(DQ <no>)} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<echo>} 
                      {
                        (DQ 
                          <
'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++'
                          >
                        )
                      }
                    )
                    (C {<echo>} {<-e>} 
                      {
                        (DQ <Id.Lit_BadBackslash '\\'> <'nbuilding packages for the initial ram disk'> 
                          <Id.Lit_BadBackslash '\\'> <n>
                        )
                      }
                    )
                    (C {<sleep>} {<1>})
                  ]
                  spids: [2838 2856]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$BUILD_PKG'))} 
                  {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ )} {<Id.Lit_RBracket ']'>}
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:PACKAGES)
                      op: assign_op.Equal
                      rhs: {(DQ ($ Id.VSub_DollarName '$BUILD_PKG'))}
                      spids: [2906]
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$FORCE_BUILD_ALL'))} 
                              {<Id.Lit_Equals '='>} {(DQ <yes>)} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:PACKAGES)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (command.Pipeline
                                    children: [
                                      (C {<find>} {<pkg>} {<-maxdepth>} {<1>} {<-type>} {<d>} {<-name>} 
                                        {(SQ <'*_static'>)}
                                      )
                                      (C {<sed>} {(SQ <'s|.*/||'>)})
                                      (C {<sort>})
                                    ]
                                    negated: F
                                  )
                              )
                            }
                          spids: [2933]
                        )
                      ]
                    )
                  ]
                  spids: [2912 2930]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:PACKAGES)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: (C {<get_initrd_progs>} {<-pkg>} {($ Id.VSub_DollarName '$ARCH')})
                          )
                        }
                      spids: [2970]
                    )
                  ]
                )
              ]
            )
            (command.ForEach
              iter_name: init_pkg
              iter_words: [{(${ Id.VSub_Name PACKAGES)}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {($ Id.VSub_DollarName '$init_pkg')}
                      arms: [
                        (case_arm
                          pat_list: [{(DQ )} {(SQ <'#'>) <Id.Lit_Star '*'>}]
                          action: [(command.ControlFlow token:<Id.ControlFlow_Continue continue>)]
                          spids: [3008 3015 3019 -1]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<Id.Lit_LBracket '['>} {<-f>} {<.fatal>} {<Id.Lit_RBracket ']'>})
                        (BraceGroup
                          children: [
                            (command.Sentence
                              child: (C {<echo>} {(DQ <Exiting..>)})
                              terminator: <Id.Op_Semi _>
                            )
                            (command.Sentence
                              child: (C {<rm>} {<-f>} {<.fatal>})
                              terminator: <Id.Op_Semi _>
                            )
                            (command.Sentence
                              child: 
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Exit exit>
                                  arg_word: {<1>}
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<Id.Lit_LBracket '['>} {<-d>} 
                          {<'pkg/'> (DQ (${ Id.VSub_Name init_pkg) <_static>)} {<Id.Lit_RBracket ']'>}
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:init_pkg)
                              op: assign_op.Equal
                              rhs: {(${ Id.VSub_Name init_pkg) <_static>}
                              spids: [3077]
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$DLD_ONLY'))} 
                                      {<Id.Lit_Equals '='>} {(DQ <no>)} {<Id.Lit_RBracket ']'>}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<check_bin>} {($ Id.VSub_DollarName '$init_pkg')})
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<Id.Lit_LBracket '['>} {($ Id.VSub_QMark '$?')} {<-eq>} {<0>} 
                                  {<Id.Lit_RBracket ']'>}
                                )
                                (BraceGroup
                                  children: [
                                    (command.Sentence
                                      child: 
                                        (C {<echo>} 
                                          {
                                            (DQ ($ Id.VSub_DollarName '$init_pkg') 
                                              <' exists ... skipping'>
                                            )
                                          }
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                    (command.Sentence
                                      child: 
                                        (command.ControlFlow
                                          token: <Id.ControlFlow_Continue continue>
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                )
                              ]
                            )
                            (C {<echo>} {<-e>} 
                              {
                                (DQ <Id.Lit_BadBackslash '\\'> 
                                  <
'n+=============================================================================+'
                                  >
                                )
                              }
                            )
                            (C {<echo>} {<-e>} 
                              {
                                (DQ <Id.Lit_BadBackslash '\\'> <'nbuilding '> 
                                  ($ Id.VSub_DollarName '$init_pkg')
                                )
                              }
                            )
                            (C {<sleep>} {<1>})
                          ]
                          spids: [3084 3102]
                        )
                      ]
                    )
                    (C {<cd>} {<'pkg/'> (${ Id.VSub_Name init_pkg)})
                    (C {<mkdir>} {<-p>} {(${ Id.VSub_Name MWD) <'/00_'> (${ Id.VSub_Name ARCH) <'/log'>})
                    (command.Pipeline
                      children: [
                        (command.Simple
                          words: [{<sh>} {(${ Id.VSub_Name init_pkg) <.petbuild>}]
                          redirects: [
                            (redir
                              op: <Id.Redir_GreatAnd '2>&'>
                              loc: (redir_loc.Fd fd:2)
                              arg: {<1>}
                            )
                          ]
                          do_fork: T
                        )
                        (C {<tee>} 
                          {(${ Id.VSub_Name MWD) <'/00_'> (${ Id.VSub_Name ARCH) <'/log/'> 
                            (${ Id.VSub_Name init_pkg) <build.log>
                          }
                        )
                      ]
                      negated: F
                    )
                    (C {<cd>} {(${ Id.VSub_Name MWD)})
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$DLD_ONLY'))} 
                          {<Id.Lit_Equals '='>} {(DQ <yes>)} {<Id.Lit_RBracket ']'>}
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Continue continue>
                        )
                      ]
                    )
                    (C {<check_bin>} {($ Id.VSub_DollarName '$init_pkg')})
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<Id.Lit_LBracket '['>} {($ Id.VSub_QMark '$?')} {<-ne>} {<0>} 
                          {<Id.Lit_RBracket ']'>}
                        )
                        (BraceGroup
                          children: [
                            (command.Sentence
                              child: (C {<echo>} {(DQ <'target binary does not exist...'>)})
                              terminator: <Id.Op_Semi _>
                            )
                            (command.Sentence
                              child: 
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Exit exit>
                                  arg_word: {<1>}
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
            )
            (C {<rm>} {<-f>} {<.fatal>})
          ]
        )
    )
    (command.ShFunction
      name: set_lang
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} 
                  {
                    (DQ 
                      (braced_var_sub
                        token: <Id.VSub_Name LOCALE>
                        suffix_op: 
                          (suffix_op.Unary
                            tok: <Id.VOp1_Percent '%'>
                            arg_word: {<_> <Id.Lit_Other '*'>}
                          )
                      )
                    )
                  } {<Id.Lit_Equals '='>} {(DQ <en>)} {<Id.Lit_RBracket ']'>}
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:LOCALE)
                      op: assign_op.Equal
                      rhs: {(DQ )}
                      spids: [3332]
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {<Id.KW_Bang '!'>} {(DQ ($ Id.VSub_DollarName '$LOCALE'))} 
                  {<Id.Lit_RBracket ']'>}
                )
                (BraceGroup
                  children: [
                    (command.Sentence
                      child: 
                        (C {<echo>} {<-e>} {(DQ <Id.Lit_BadBackslash '\\'> <'n* Using default locale'>)})
                      terminator: <Id.Op_Semi _>
                    )
                    (command.Sentence
                      child: (C {<rm>} {<-f>} {<'ZZ_initrd-expanded/PUPPYLANG'>})
                      terminator: <Id.Op_Semi _>
                    )
                    (command.Sentence
                      child: (command.ControlFlow token:<Id.ControlFlow_Return return>)
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              ]
            )
            (C {<echo>} {<-e>} 
              {
                (DQ <'* LANG set to: '> ($ Id.VSub_DollarName '$LOCALE') <Id.Lit_BadBackslash '\\'> <n>)
              }
            )
            (command.Simple
              words: [{<echo>} {<-n>} {(DQ ($ Id.VSub_DollarName '$LOCALE'))}]
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {<'ZZ_initrd-expanded/PUPPYLANG'>}
                )
              ]
              do_fork: T
            )
          ]
        )
    )
    (command.ShFunction
      name: set_keymap
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {<Id.KW_Bang '!'>} {<-f>} 
                  {<'0initrd/lib/keymaps/'> (${ Id.VSub_Name KEYMAP) <.gz>} {<Id.Lit_RBracket ']'>}
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:KEYMAP)
                      op: assign_op.Equal
                      rhs: {(DQ )}
                      spids: [3431]
                    )
                  ]
                )
              ]
            )
            (command.Case
              to_match: {($ Id.VSub_DollarName '$KEYMAP')}
              arms: [
                (case_arm
                  pat_list: [{<default>} {<en>} {<us>} {(DQ )}]
                  action: [
                    (command.Sentence
                      child: (C {<echo>} {(DQ <'* Using default keymap'>)})
                      terminator: <Id.Op_Semi _>
                    )
                    (command.Sentence
                      child: (C {<rm>} {<-f>} {<'ZZ_initrd-expanded/PUPPYKEYMAP'>})
                      terminator: <Id.Op_Semi _>
                    )
                    (command.ControlFlow token:<Id.ControlFlow_Return return>)
                  ]
                  spids: [3442 3450 3469 -1]
                )
              ]
            )
            (C {<echo>} {<-e>} {(DQ <'* Keymap set to: \''> (${ Id.VSub_Name KEYMAP) <'\''>)})
            (command.Simple
              words: [{<echo>} {<-n>} {(DQ ($ Id.VSub_DollarName '$KEYMAP'))}]
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {<'ZZ_initrd-expanded/PUPPYKEYMAP'>}
                )
              ]
              do_fork: T
            )
          ]
        )
    )
    (command.ShFunction
      name: generate_initrd
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$DLD_ONLY'))} 
                  {<Id.Lit_Equals '='>} {(DQ <yes>)} {<Id.Lit_RBracket ']'>}
                )
                (command.ControlFlow token:<Id.ControlFlow_Return return>)
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$INITRD_CREATE'))} 
                  {<Id.Lit_Equals '='>} {(DQ <no>)} {<Id.Lit_RBracket ']'>}
                )
                (command.ControlFlow token:<Id.ControlFlow_Return return>)
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:INITRD_FILE)
                  op: assign_op.Equal
                  rhs: {(DQ <initrd.> (${ Id.VSub_Name INITRD_COMP))}
                  spids: [3549]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$INITRD_GZ'))} 
                  {<Id.Lit_Equals '='>} {(DQ <yes>)} {<Id.Lit_RBracket ']'>}
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:INITRD_FILE)
                      op: assign_op.Equal
                      rhs: {(DQ <initrd.gz>)}
                      spids: [3574]
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$USE_PREBUILT'))} 
                              {<Id.Lit_Equals '='>} {(DQ <no>)} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp Id.Op_DAmp]
                      children: [
                        (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$PROMPT'))} 
                          {<Id.Lit_Equals '='>} {(DQ <yes>)} {<Id.Lit_RBracket ']'>}
                        )
                        (C {<echo>} {<-en>} 
                          {
                            (DQ <Id.Lit_BadBackslash '\\'> <'nPress enter to create '> 
                              (${ Id.VSub_Name INITRD_FILE) <', CTRL-C to end here..'>
                            )
                          }
                        )
                        (C {<read>} {<zzz>})
                      ]
                    )
                    (C {<echo>} {<-e>} 
                      {
                        (DQ <Id.Lit_BadBackslash '\\'> 
                          <'n============================================'>
                        )
                      }
                    )
                    (C {<echo>} 
                      {
                        (DQ <'Now creating the initial ramdisk ('> (${ Id.VSub_Name INITRD_FILE) <')'>)
                      }
                    )
                    (C {<echo>} {<-e>} 
                      {
                        (DQ <'============================================='> 
                          <Id.Lit_BadBackslash '\\'> <n>
                        )
                      }
                    )
                  ]
                  spids: [3581 3599]
                )
              ]
            )
            (C {<rm>} {<-rf>} {<ZZ_initrd-expanded>})
            (C {<mkdir>} {<-p>} {<ZZ_initrd-expanded>})
            (C {<cp>} {<-rf>} {<'0initrd/'> <Id.Lit_Star '*'>} {<ZZ_initrd-expanded>})
            (C {<find>} {<ZZ_initrd-expanded>} {<-type>} {<f>} {<-name>} {(SQ <'*MARKER'>)} {<-delete>})
            (C {<set_lang>})
            (C {<set_keymap>})
            (C {<cd>} {<ZZ_initrd-expanded>})
            (command.ForEach
              iter_name: PROG
              iter_words: [
                {
                  (command_sub
                    left_token: <Id.Left_DollarParen '$('>
                    child: (C {<get_initrd_progs>} {(${ Id.VSub_Name ARCH)})
                  )
                }
              ]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {($ Id.VSub_DollarName '$PROG')}
                      arms: [
                        (case_arm
                          pat_list: [{(DQ )} {(SQ <'#'>) <Id.Lit_Star '*'>}]
                          action: [(command.ControlFlow token:<Id.ControlFlow_Continue continue>)]
                          spids: [3760 3767 3771 -1]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<Id.Lit_LBracket '['>} {<-f>} 
                                      {<'../00_'> (${ Id.VSub_Name ARCH) <'/bin/'> 
                                        (${ Id.VSub_Name PROG)
                                      } {<Id.Lit_RBracket ']'>}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (command.Pipeline
                                  children: [
                                    (C {<file>} 
                                      {<'../00_'> (${ Id.VSub_Name ARCH) <'/bin/'> 
                                        (${ Id.VSub_Name PROG)
                                      }
                                    )
                                    (C {<grep>} {<-E>} {(SQ <'dynamically|shared'>)})
                                  ]
                                  negated: F
                                )
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Exit exit>
                                  arg_word: {<1>}
                                )
                              ]
                            )
                            (C {<cp>} {<-a>} {(${ Id.VSub_Name V)} {<--remove-destination>} 
                              {<'../00_'> (${ Id.VSub_Name ARCH) <'/bin/'> (${ Id.VSub_Name PROG)} {<bin>}
                            )
                          ]
                          spids: [3776 3795]
                        )
                      ]
                      else_action: [
                        (C {<echo>} 
                          {
                            (DQ <00_> (${ Id.VSub_Name ARCH) <'/bin/'> (${ Id.VSub_Name PROG) 
                              <' not found'>
                            )
                          }
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Exit exit>
                          arg_word: {<1>}
                        )
                      ]
                    )
                  ]
                )
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {<Id.KW_Bang '!'>} {<-f>} {<'bin/nano'>} 
                  {<Id.Lit_RBracket ']'>}
                )
                (C {<rm>} {<-rf>} {<usr>} {<'lib/terminfo'>})
              ]
            )
            (C {<echo>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {<Id.KW_Bang '!'>} {<-f>} 
                              {(DQ ($ Id.VSub_DollarName '$DISTRO_SPECS'))} {<-a>} {<-f>} {<'../DISTRO_SPECS'>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:DISTRO_SPECS)
                          op: assign_op.Equal
                          rhs: {(SQ <'../DISTRO_SPECS'>)}
                          spids: [3928]
                        )
                      ]
                    )
                  ]
                  spids: [3903 3925]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {<Id.KW_Bang '!'>} {<-f>} 
                              {(DQ ($ Id.VSub_DollarName '$DISTRO_SPECS'))} {<-a>} {<Id.KW_Bang '!'>} {<-f>} {<'../0initrd/DISTRO_SPECS'>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<Id.Lit_LBracket '['>} {<-f>} {<'/etc/DISTRO_SPECS'>} {<Id.Lit_RBracket ']'>})
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:DISTRO_SPECS)
                              op: assign_op.Equal
                              rhs: {(SQ <'/etc/DISTRO_SPECS'>)}
                              spids: [3974]
                            )
                          ]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<Id.Lit_LBracket '['>} {<-f>} {<'/initrd/DISTRO_SPECS'>} 
                          {<Id.Lit_RBracket ']'>}
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:DISTRO_SPECS)
                              op: assign_op.Equal
                              rhs: {(SQ <'/initrd/DISTRO_SPECS'>)}
                              spids: [3990]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [3937 3961]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {<-f>} {(DQ ($ Id.VSub_DollarName '$DISTRO_SPECS'))} 
                  {<Id.Lit_RBracket ']'>}
                )
                (C {<cp>} {<-f>} {(${ Id.VSub_Name V)} {(DQ (${ Id.VSub_Name DISTRO_SPECS))} {<.>})
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {<-x>} {<'../init'>} {<Id.Lit_RBracket ']'>})
                (C {<cp>} {<-f>} {(${ Id.VSub_Name V)} {<'../init'>} {<.>})
              ]
            )
            (C {<.>} {<'./DISTRO_SPECS'>})
            (C {<cp>} {<-f>} {(${ Id.VSub_Name V)} 
              {<'../pkg/busybox_static/bb-'> <Id.Lit_Star '*'> <-symlinks>} {<bin>}
            )
            (command.Subshell
              child: 
                (command.CommandList
                  children: [
                    (command.Sentence
                      child: (C {<cd>} {<bin>})
                      terminator: <Id.Op_Semi _>
                    )
                    (command.Simple
                      words: [{<sh>} {<bb-create-symlinks>}]
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '2>'>
                          loc: (redir_loc.Fd fd:2)
                          arg: {<'/dev/null'>}
                        )
                      ]
                      do_fork: T
                    )
                  ]
                )
            )
            (C {<sed>} {<-i>} {(SQ <'s|^PUPDESKFLG=.*|PUPDESKFLG=0|'>)} {<init>})
            (command.Pipeline
              children: [
                (C {<find>} {<.>})
                (command.Simple
                  words: [{<cpio>} {<-o>} {<-H>} {<newc>}]
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {<'../initrd'>}
                    )
                    (redir
                      op: <Id.Redir_Great '2>'>
                      loc: (redir_loc.Fd fd:2)
                      arg: {<'/dev/null'>}
                    )
                  ]
                  do_fork: T
                )
              ]
              negated: F
            )
            (C {<cd>} {<..>})
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {<-f>} 
                  {<initrd.> <Id.Lit_LBracket '['> <gx> <Id.Lit_RBracket ']'> <z>} {<Id.Lit_RBracket ']'>}
                )
                (C {<rm>} {<-f>} {<initrd.> <Id.Lit_LBracket '['> <gx> <Id.Lit_RBracket ']'> <z>})
              ]
            )
            (command.Case
              to_match: {(${ Id.VSub_Name INITRD_COMP)}
              arms: [
                (case_arm
                  pat_list: [{<gz>}]
                  action: [(C {<gzip>} {<-f>} {<initrd>})]
                  spids: [4167 4168 4176 -1]
                )
                (case_arm
                  pat_list: [{<xz>}]
                  action: [(C {<xz>} {<--check> <Id.Lit_Equals '='> <crc32>} {<--lzma2>} {<initrd>})]
                  spids: [4179 4180 4192 -1]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<Id.Lit_LBracket '['>} {($ Id.VSub_QMark '$?')} {<-eq>} {<0>} {<Id.Lit_RBracket ']'>})
                (BraceGroup
                  children: [
                    (command.Sentence
                      child: (C {<echo>} {(DQ <ERROR>)})
                      terminator: <Id.Op_Semi _>
                    )
                    (command.Sentence
                      child: (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$INITRD_GZ'))} 
                  {<Id.Lit_Equals '='>} {(DQ <yes>)} {<-a>} {<-f>} {<initrd.xz>} {<Id.Lit_RBracket ']'>}
                )
                (C {<mv>} {<-f>} {<initrd.xz>} {<initrd.gz>})
              ]
            )
            (C {<echo>} {<-e>} 
              {
                (DQ <Id.Lit_BadBackslash '\\'> <'n***        INITRD: '> (${ Id.VSub_Name INITRD_FILE) 
                  <' ['> (${ Id.VSub_Name ARCH) <']'>
                )
              }
            )
            (C {<echo>} {<-e>} 
              {
                (DQ <'*** /DISTRO_SPECS: '> (${ Id.VSub_Name DISTRO_NAME) <' '> 
                  (${ Id.VSub_Name DISTRO_VERSION) <' '> (${ Id.VSub_Name DISTRO_TARGETARCH)
                )
              }
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$USE_PREBUILT'))} 
                  {<Id.Lit_Equals '='>} {(DQ <yes>)} {<Id.Lit_RBracket ']'>}
                )
                (command.ControlFlow token:<Id.ControlFlow_Return return>)
              ]
            )
            (C {<echo>} {<-e>} 
              {
                (DQ <Id.Lit_BadBackslash '\\'> 
                  <'n@@ -- You can inspect ZZ_initrd-expanded to see the final results -- @@'>
                )
              }
            )
            (C {<echo>} {<-e>} {(DQ <Finished.> <Id.Lit_BadBackslash '\\'> <n>)})
          ]
        )
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$USE_PREBUILT'))} 
                      {<Id.Lit_Equals '='>} {(DQ <yes>)} {<Id.Lit_RBracket ']'>}
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [(C {<use_prebuilt_binaries>}) (C {<select_target_arch>})]
          spids: [4352 4370]
        )
      ]
      else_action: [
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:V)
              op: assign_op.Equal
              rhs: {(DQ <-v>)}
              spids: [4381]
            )
          ]
        )
        (C {<set_compiler>})
        (C {<select_target_arch>})
        (C {<setup_cross_compiler>})
        (C {<build_pkgs>})
        (C {<cd>} {(${ Id.VSub_Name MWD)})
      ]
    )
    (C {<generate_initrd>})
  ]
)