(command.CommandList
  children: [
    (C {<set>} {<-e>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:VERSION)
          op: assign_op.Equal
          rhs: {(SQ <'@VERSION@'>)}
          spids: [8]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DPipe]
      children: [(C {<unset>} {<TMP>} {<TEMP>} {<TMPDIR>}) (C {<true>})]
    )
    (C {<export>} {<PATH>})
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (C {<Id.Lit_LBracket '['>} {<-z>} {(DQ ($ Id.VSub_DollarName '$DEBOOTSTRAP_DIR'))} 
                      {<Id.Lit_RBracket ']'>}
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {<-x>} {<'/debootstrap/debootstrap'>} 
                              {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:DEBOOTSTRAP_DIR)
                          op: assign_op.Equal
                          rhs: {<'/debootstrap'>}
                          spids: [69]
                        )
                      ]
                    )
                  ]
                  spids: [55 66]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:DEBOOTSTRAP_DIR)
                      op: assign_op.Equal
                      rhs: {<'/usr/share/debootstrap'>}
                      spids: [76]
                    )
                  ]
                )
              ]
            )
          ]
          spids: [39 52]
        )
      ]
    )
    (C {<.>} {($ Id.VSub_DollarName '$DEBOOTSTRAP_DIR') <'/functions'>})
    (command.Simple
      words: [{<exec>}]
      redirects: [(redir op:<Id.Redir_GreatAnd '4>&'> loc:(redir_loc.Fd fd:4) arg:{<1>})]
      do_fork: T
    )
    (command.ShAssignment
      pairs: [(assign_pair lhs:(sh_lhs_expr.Name name:LANG) op:assign_op.Equal rhs:{<C>} spids:[96])]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:USE_COMPONENTS)
          op: assign_op.Equal
          rhs: {<main>}
          spids: [99]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:KEYRING)
          op: assign_op.Equal
          rhs: {(DQ )}
          spids: [102]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:DISABLE_KEYRING)
          op: assign_op.Equal
          rhs: {(DQ )}
          spids: [106]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:FORCE_KEYRING)
          op: assign_op.Equal
          rhs: {(DQ )}
          spids: [110]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:VARIANT)
          op: assign_op.Equal
          rhs: {(DQ )}
          spids: [114]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:MERGED_USR)
          op: assign_op.Equal
          rhs: {(DQ <no>)}
          spids: [118]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:ARCH)
          op: assign_op.Equal
          rhs: {(DQ )}
          spids: [123]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:HOST_ARCH)
          op: assign_op.Equal
          rhs: {(DQ )}
          spids: [127]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:HOST_OS)
          op: assign_op.Equal
          rhs: {(DQ )}
          spids: [131]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:KEEP_DEBOOTSTRAP_DIR)
          op: assign_op.Equal
          rhs: {(DQ )}
          spids: [135]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:USE_DEBIANINSTALLER_INTERACTION)
          op: assign_op.Equal
          rhs: {(DQ )}
          spids: [139]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:SECOND_STAGE_ONLY)
          op: assign_op.Equal
          rhs: {(DQ )}
          spids: [143]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:PRINT_DEBS)
          op: assign_op.Equal
          rhs: {(DQ )}
          spids: [147]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:CHROOTDIR)
          op: assign_op.Equal
          rhs: {(DQ )}
          spids: [151]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:MAKE_TARBALL)
          op: assign_op.Equal
          rhs: {(DQ )}
          spids: [155]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:EXTRACTOR_OVERRIDE)
          op: assign_op.Equal
          rhs: {(DQ )}
          spids: [159]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:UNPACK_TARBALL)
          op: assign_op.Equal
          rhs: {(DQ )}
          spids: [163]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:ADDITIONAL)
          op: assign_op.Equal
          rhs: {(DQ )}
          spids: [167]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:EXCLUDE)
          op: assign_op.Equal
          rhs: {(DQ )}
          spids: [171]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:VERBOSE)
          op: assign_op.Equal
          rhs: {(DQ )}
          spids: [175]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:CERTIFICATE)
          op: assign_op.Equal
          rhs: {(DQ )}
          spids: [179]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:CHECKCERTIF)
          op: assign_op.Equal
          rhs: {(DQ )}
          spids: [183]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:PRIVATEKEY)
          op: assign_op.Equal
          rhs: {(DQ )}
          spids: [187]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:DEF_MIRROR)
          op: assign_op.Equal
          rhs: {(DQ <'http://deb.debian.org/debian'>)}
          spids: [192]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:DEF_HTTPS_MIRROR)
          op: assign_op.Equal
          rhs: {(DQ <'https://deb.debian.org/debian'>)}
          spids: [197]
        )
      ]
    )
    (C {<export>} {<LANG>} {<USE_COMPONENTS>})
    (C {<umask>} {<022>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:RESOLVE_DEPS)
          op: assign_op.Equal
          rhs: {<true>}
          spids: [225]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:WHAT_TO_DO)
          op: assign_op.Equal
          rhs: {(DQ <'finddebs dldebs first_stage second_stage'>)}
          spids: [229]
        )
      ]
    )
    (command.ShFunction
      name: am_doing_phase
      body: 
        (BraceGroup
          children: [
            (command.Sentence child:(C {<local>} {<x>}) terminator:<Id.Op_Semi _>)
            (command.ForEach
              iter_name: x
              iter_words: [{(DQ ($ Id.VSub_At '$@'))}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.Pipeline
                                      children: [
                                        (C {<echo>} 
                                          {(DQ <' '> ($ Id.VSub_DollarName '$WHAT_TO_DO') <' '>)}
                                        )
                                        (C {<grep>} {<-q>} {(DQ <' '> ($ Id.VSub_DollarName '$x') <' '>)})
                                      ]
                                      negated: F
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.Sentence
                              child: 
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Return return>
                                  arg_word: {<0>}
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                          spids: [266 289]
                        )
                      ]
                    )
                  ]
                )
            )
            (command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<1>})
          ]
        )
    )
    (command.ShFunction
      name: usage_err
      body: 
        (BraceGroup
          children: [
            (C {<info>} {<USAGE1>} {(DQ <'usage: [OPTION]... <suite> <target> [<mirror> [<script>]]'>)})
            (C {<info>} {<USAGE2>} 
              {
                (DQ <'Try '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\`'>) 
                  (braced_var_sub
                    token: <Id.VSub_Number 0>
                    suffix_op: 
                      (suffix_op.Unary
                        tok: <Id.VOp1_DPound '##'>
                        arg_word: {<Id.Lit_Other '*'> <Id.Lit_Slash '/'>}
                      )
                  ) <' --help\' for more information.'>
                )
              }
            )
            (C {<error>} {(DQ ($ Id.VSub_At '$@'))})
          ]
        )
    )
    (command.ShFunction
      name: usage
      body: 
        (BraceGroup
          children: [
            (C {<echo>} 
              {
                (DQ <'Usage: '> 
                  (braced_var_sub
                    token: <Id.VSub_Number 0>
                    suffix_op: 
                      (suffix_op.Unary
                        tok: <Id.VOp1_DPound '##'>
                        arg_word: {<Id.Lit_Other '*'> <Id.Lit_Slash '/'>}
                      )
                  ) <' [OPTION]... <suite> <target> [<mirror> [<script>]]'>
                )
              }
            )
            (C {<echo>} {(DQ <'Bootstrap a Debian base system into a target directory.'>)})
            (C {<echo>})
            (command.Simple
              words: [{<cat>}]
              redirects: [
                (redir
                  op: <Id.Redir_DLess '<<'>
                  loc: (redir_loc.Fd fd:0)
                  arg: 
                    (redir_param.HereDoc
                      here_begin: {<EOF>}
                      here_end_span_id: 431
                      stdin_parts: [
                        <'      --help                 display this help and exit\n'>
                        <'      --version              display version information and exit\n'>
                        <'      --verbose              don\'t turn off the output of wget\n'>
                        <'\n'>
                        <
'      --download-only        download packages, but don\'t perform installation\n'
                        >
                        <
'      --print-debs           print the packages to be installed, and exit\n'
                        >
                        <'\n'>
                        <
'      --arch=A               set the architecture to install (use if no dpkg)\n'
                        >
                        <'                               [ --arch=powerpc ]\n'>
                        <'\n'>
                        <
'      --include=A,B,C        adds specified names to the list of base packages\n'
                        >
                        <'      --exclude=A,B,C        removes specified packages from the list\n'>
                        <
'      --components=A,B,C     use packages from the listed components of the\n'
                        >
                        <'                             archive\n'>
                        <'      --variant=X            use variant X of the bootstrap scripts\n'>
                        <
'                             (currently supported variants: buildd, fakechroot,\n'
                        >
                        <'                              minbase)\n'>
                        <'      --merged-usr           make /{bin,sbin,lib}/ symlinks to /usr/\n'>
                        <'      --keyring=K            check Release files against keyring K\n'>
                        <'      --no-check-gpg         avoid checking Release file signatures\n'>
                        <'      --force-check-gpg      force checking Release file signatures\n'>
                        <
'                             (also disables automatic fallback to HTTPS in case\n'
                        >
                        <'                             of a missing keyring), aborting otherwise\n'>
                        <
'      --no-resolve-deps      don\'t try to resolve dependencies automatically\n'
                        >
                        <'\n'>
                        <
'      --unpack-tarball=T     acquire .debs from a tarball instead of http\n'
                        >
                        <
'      --make-tarball=T       download .debs and create a tarball (tgz format)\n'
                        >
                        <'      --second-stage-target=DIR\n'>
                        <
'                             Run second stage in a subdirectory instead of root\n'
                        >
                        <
'                               (can be used to create a foreign chroot)\n'
                        >
                        <'                               (requires --second-stage)\n'>
                        <
'      --extractor=TYPE       override automatic .deb extractor selection\n'
                        >
                        <'                               (supported: '>
                        ($ Id.VSub_DollarName '$EXTRACTORS_SUPPORTED')
                        <')\n'>
                        <
'      --debian-installer     used for internal purposes by debian-installer\n'
                        >
                        <'      --private-key=file     read the private key from file\n'>
                        <
'      --certificate=file     use the client certificate stored in file (PEM)\n'
                        >
                        <
'      --no-check-certificate do not check certificate against certificate authorities\n'
                        >
                      ]
                    )
                )
              ]
              do_fork: T
            )
          ]
        )
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (C {<Id.Lit_LBracket '['>} {<-z>} {(DQ ($ Id.VSub_DollarName '$PKGDETAILS'))} 
                      {<Id.Lit_RBracket ']'>}
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (C {<error>} {<1>} {<NO_PKGDETAILS>} 
              {
                (DQ 
                  <
'No pkgdetails available; either install perl, or build pkgdetails.c from the base-installer source package'
                  >
                )
              }
            )
          ]
          spids: [439 452]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (C {<Id.Lit_LBracket '['>} {($ Id.VSub_Pound '$#')} 
                      {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<0>} {<Id.Lit_RBracket ']'>}
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [(command.Sentence child:(C {<true>}) terminator:<Id.Op_Semi _>)]
                )
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_Number '$1'))}
                      arms: [
                        (case_arm
                          pat_list: [{<--help>}]
                          action: [
                            (C {<usage>})
                            (command.ControlFlow
                              token: <Id.ControlFlow_Exit exit>
                              arg_word: {<0>}
                            )
                          ]
                          spids: [508 509 520 -1]
                        )
                        (case_arm
                          pat_list: [{<--version>}]
                          action: [
                            (C {<echo>} {(DQ <'debootstrap '> ($ Id.VSub_DollarName '$VERSION'))})
                            (command.ControlFlow
                              token: <Id.ControlFlow_Exit exit>
                              arg_word: {<0>}
                            )
                          ]
                          spids: [523 524 540 -1]
                        )
                        (case_arm
                          pat_list: [{<--debian-installer>}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (command.Pipeline
                                              children: [
                                                (command.Subshell
                                                  child: 
                                                    (command.Simple
                                                      words: [{<echo>} {<-n>} {(DQ )}]
                                                      redirects: [
                                                        (redir
                                                          op: <Id.Redir_GreatAnd '>&'>
                                                          loc: (redir_loc.Fd fd:1)
                                                          arg: {<3>}
                                                        )
                                                      ]
                                                      do_fork: T
                                                    )
                                                  redirects: [
                                                    (redir
                                                      op: <Id.Redir_Great '2>'>
                                                      loc: (redir_loc.Fd fd:2)
                                                      arg: {<'/dev/null'>}
                                                    )
                                                  ]
                                                )
                                              ]
                                              negated: T
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (C {<error>} {<1>} {<ARG_DIBYHAND>} 
                                      {
                                        (DQ 
                                          <
'If running debootstrap by hand, don\'t use --debian-installer'
                                          >
                                        )
                                      }
                                    )
                                  ]
                                  spids: [547 567]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:USE_DEBIANINSTALLER_INTERACTION)
                                  op: assign_op.Equal
                                  rhs: {<yes>}
                                  spids: [584]
                                )
                              ]
                            )
                            (C {<shift>})
                          ]
                          spids: [543 544 591 -1]
                        )
                        (case_arm
                          pat_list: [{<--foreign>}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<Id.Lit_LBracket '['>} 
                                              {(DQ ($ Id.VSub_DollarName '$PRINT_DEBS'))} {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ <true>)} {<Id.Lit_RBracket ']'>}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:WHAT_TO_DO)
                                          op: assign_op.Equal
                                          rhs: {(DQ <'finddebs dldebs first_stage'>)}
                                          spids: [619]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [598 616]
                                )
                              ]
                            )
                            (C {<shift>})
                          ]
                          spids: [594 595 631 -1]
                        )
                        (case_arm
                          pat_list: [{<--second-stage>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:WHAT_TO_DO)
                                  op: assign_op.Equal
                                  rhs: {(DQ <second_stage>)}
                                  spids: [638]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:SECOND_STAGE_ONLY)
                                  op: assign_op.Equal
                                  rhs: {<true>}
                                  spids: [644]
                                )
                              ]
                            )
                            (C {<shift>})
                          ]
                          spids: [634 635 651 -1]
                        )
                        (case_arm
                          pat_list: [
                            {<--second-stage-target>}
                            {<--second-stage-target> <Id.Lit_Equals '='> <Id.Lit_QMark '?'> 
                              <Id.Lit_Star '*'>
                            }
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<Id.Lit_LBracket '['>} 
                                              {(DQ ($ Id.VSub_DollarName '$SECOND_STAGE_ONLY'))} {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ <true>)} {<Id.Lit_RBracket ']'>}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (C {<error>} {<1>} {<STAGE2ONLY>} 
                                      {(DQ <'option %s only applies in the second stage'>)} {(DQ ($ Id.VSub_Number '$1'))}
                                    )
                                  ]
                                  spids: [663 682]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {(DQ <--second-stage-target>)} {<-a>} {<-n>} {(DQ ($ Id.VSub_Number '$2'))} {<Id.Lit_RBracket ']'>}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:CHROOTDIR)
                                          op: assign_op.Equal
                                          rhs: {(DQ ($ Id.VSub_Number '$2'))}
                                          spids: [732]
                                        )
                                      ]
                                    )
                                    (C {<shift>} {<2>})
                                  ]
                                  spids: [703 729]
                                )
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} 
                                              {
                                                (DQ 
                                                  (braced_var_sub
                                                    token: <Id.VSub_Number 1>
                                                    suffix_op: 
                                                      (suffix_op.Unary
                                                        tok: <Id.VOp1_Pound '#'>
                                                        arg_word: {<'--second-stage-target='>}
                                                      )
                                                  )
                                                )
                                              } {<Id.Lit_RBracket ']'>}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:CHROOTDIR)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (braced_var_sub
                                                  token: <Id.VSub_Number 1>
                                                  suffix_op: 
                                                    (suffix_op.Unary
                                                      tok: <Id.VOp1_Pound '#'>
                                                      arg_word: {<'--second-stage-target='>}
                                                    )
                                                )
                                              )
                                            }
                                          spids: [768]
                                        )
                                      ]
                                    )
                                    (C {<shift>})
                                  ]
                                  spids: [743 765]
                                )
                              ]
                              else_action: [
                                (C {<error>} {<1>} {<NEEDARG>} {(DQ <'option requires an argument: %s'>)} 
                                  {(DQ ($ Id.VSub_Number '$1'))}
                                )
                              ]
                            )
                          ]
                          spids: [654 660 802 -1]
                        )
                        (case_arm
                          pat_list: [{<--print-debs>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:WHAT_TO_DO)
                                  op: assign_op.Equal
                                  rhs: {(DQ <'finddebs printdebs kill_target'>)}
                                  spids: [809]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:PRINT_DEBS)
                                  op: assign_op.Equal
                                  rhs: {<true>}
                                  spids: [815]
                                )
                              ]
                            )
                            (C {<shift>})
                          ]
                          spids: [805 806 822 -1]
                        )
                        (case_arm
                          pat_list: [{<--download-only>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:WHAT_TO_DO)
                                  op: assign_op.Equal
                                  rhs: {(DQ <'finddebs dldebs'>)}
                                  spids: [829]
                                )
                              ]
                            )
                            (C {<shift>})
                          ]
                          spids: [825 826 838 -1]
                        )
                        (case_arm
                          pat_list: [
                            {<--make-tarball>}
                            {<--make-tarball> <Id.Lit_Equals '='> <Id.Lit_QMark '?'> <Id.Lit_Star '*'>}
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:WHAT_TO_DO)
                                  op: assign_op.Equal
                                  rhs: {(DQ <'finddebs dldebs maketarball kill_target'>)}
                                  spids: [850]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {(DQ <--make-tarball>)} {<-a>} {<-n>} {(DQ ($ Id.VSub_Number '$2'))} {<Id.Lit_RBracket ']'>}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:MAKE_TARBALL)
                                          op: assign_op.Equal
                                          rhs: {(DQ ($ Id.VSub_Number '$2'))}
                                          spids: [885]
                                        )
                                      ]
                                    )
                                    (C {<shift>} {<2>})
                                  ]
                                  spids: [856 882]
                                )
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} 
                                              {
                                                (DQ 
                                                  (braced_var_sub
                                                    token: <Id.VSub_Number 1>
                                                    suffix_op: 
                                                      (suffix_op.Unary
                                                        tok: <Id.VOp1_Pound '#'>
                                                        arg_word: {<'--make-tarball='>}
                                                      )
                                                  )
                                                )
                                              } {<Id.Lit_RBracket ']'>}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:MAKE_TARBALL)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (braced_var_sub
                                                  token: <Id.VSub_Number 1>
                                                  suffix_op: 
                                                    (suffix_op.Unary
                                                      tok: <Id.VOp1_Pound '#'>
                                                      arg_word: {<'--make-tarball='>}
                                                    )
                                                )
                                              )
                                            }
                                          spids: [921]
                                        )
                                      ]
                                    )
                                    (C {<shift>})
                                  ]
                                  spids: [896 918]
                                )
                              ]
                              else_action: [
                                (C {<error>} {<1>} {<NEEDARG>} {(DQ <'option requires an argument %s'>)} 
                                  {(DQ ($ Id.VSub_Number '$1'))}
                                )
                              ]
                            )
                          ]
                          spids: [841 847 955 -1]
                        )
                        (case_arm
                          pat_list: [{<--resolve-deps>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:RESOLVE_DEPS)
                                  op: assign_op.Equal
                                  rhs: {<true>}
                                  spids: [966]
                                )
                              ]
                            )
                            (C {<shift>})
                          ]
                          spids: [958 959 973 -1]
                        )
                        (case_arm
                          pat_list: [{<--no-resolve-deps>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:RESOLVE_DEPS)
                                  op: assign_op.Equal
                                  rhs: {<false>}
                                  spids: [980]
                                )
                              ]
                            )
                            (C {<shift>})
                          ]
                          spids: [976 977 987 -1]
                        )
                        (case_arm
                          pat_list: [{<--keep-debootstrap-dir>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:KEEP_DEBOOTSTRAP_DIR)
                                  op: assign_op.Equal
                                  rhs: {<true>}
                                  spids: [994]
                                )
                              ]
                            )
                            (C {<shift>})
                          ]
                          spids: [990 991 1001 -1]
                        )
                        (case_arm
                          pat_list: [
                            {<--arch>}
                            {<--arch> <Id.Lit_Equals '='> <Id.Lit_QMark '?'> <Id.Lit_Star '*'>}
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {(DQ <--arch>)} {<-a>} {<-n>} {(DQ ($ Id.VSub_Number '$2'))} {<Id.Lit_RBracket ']'>}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:ARCH)
                                          op: assign_op.Equal
                                          rhs: {(DQ ($ Id.VSub_Number '$2'))}
                                          spids: [1042]
                                        )
                                      ]
                                    )
                                    (C {<shift>} {<2>})
                                  ]
                                  spids: [1013 1039]
                                )
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} 
                                              {
                                                (DQ 
                                                  (braced_var_sub
                                                    token: <Id.VSub_Number 1>
                                                    suffix_op: 
                                                      (suffix_op.Unary
                                                        tok: <Id.VOp1_Pound '#'>
                                                        arg_word: {<'--arch='>}
                                                      )
                                                  )
                                                )
                                              } {<Id.Lit_RBracket ']'>}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:ARCH)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (braced_var_sub
                                                  token: <Id.VSub_Number 1>
                                                  suffix_op: 
                                                    (suffix_op.Unary
                                                      tok: <Id.VOp1_Pound '#'>
                                                      arg_word: {<'--arch='>}
                                                    )
                                                )
                                              )
                                            }
                                          spids: [1078]
                                        )
                                      ]
                                    )
                                    (C {<shift>})
                                  ]
                                  spids: [1053 1075]
                                )
                              ]
                              else_action: [
                                (C {<error>} {<1>} {<NEEDARG>} {(DQ <'option requires an argument %s'>)} 
                                  {(DQ ($ Id.VSub_Number '$1'))}
                                )
                              ]
                            )
                          ]
                          spids: [1004 1010 1112 -1]
                        )
                        (case_arm
                          pat_list: [
                            {<--extractor>}
                            {<--extractor> <Id.Lit_Equals '='> <Id.Lit_QMark '?'> <Id.Lit_Star '*'>}
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {(DQ <--extractor>)} {<-a>} {<-n>} {(DQ ($ Id.VSub_Number '$2'))} {<Id.Lit_RBracket ']'>}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:EXTRACTOR_OVERRIDE)
                                          op: assign_op.Equal
                                          rhs: {(DQ ($ Id.VSub_Number '$2'))}
                                          spids: [1153]
                                        )
                                      ]
                                    )
                                    (C {<shift>} {<2>})
                                  ]
                                  spids: [1124 1150]
                                )
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} 
                                              {
                                                (DQ 
                                                  (braced_var_sub
                                                    token: <Id.VSub_Number 1>
                                                    suffix_op: 
                                                      (suffix_op.Unary
                                                        tok: <Id.VOp1_Pound '#'>
                                                        arg_word: {<'--extractor='>}
                                                      )
                                                  )
                                                )
                                              } {<Id.Lit_RBracket ']'>}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:EXTRACTOR_OVERRIDE)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (braced_var_sub
                                                  token: <Id.VSub_Number 1>
                                                  suffix_op: 
                                                    (suffix_op.Unary
                                                      tok: <Id.VOp1_Pound '#'>
                                                      arg_word: {<'--extractor='>}
                                                    )
                                                )
                                              )
                                            }
                                          spids: [1189]
                                        )
                                      ]
                                    )
                                    (C {<shift>})
                                  ]
                                  spids: [1164 1186]
                                )
                              ]
                              else_action: [
                                (C {<error>} {<1>} {<NEEDARG>} {(DQ <'option requires an argument %s'>)} 
                                  {(DQ ($ Id.VSub_Number '$1'))}
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<valid_extractor>} 
                                              {(DQ ($ Id.VSub_DollarName '$EXTRACTOR_OVERRIDE'))}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: 
                                            (condition.Shell
                                              commands: [
                                                (command.Sentence
                                                  child: 
                                                    (command.Pipeline
                                                      children: [
                                                        (command.Simple
                                                          words: [
                                                            {<type>}
                                                            {
                                                              (DQ 
                                                                ($ Id.VSub_DollarName 
'$EXTRACTOR_OVERRIDE'
                                                                )
                                                              )
                                                            }
                                                          ]
                                                          redirects: [
                                                            (redir
                                                              op: <Id.Redir_Great '>'>
                                                              loc: (redir_loc.Fd fd:1)
                                                              arg: {<'/dev/null'>}
                                                            )
                                                            (redir
                                                              op: <Id.Redir_GreatAnd '2>&'>
                                                              loc: (redir_loc.Fd fd:2)
                                                              arg: {<1>}
                                                            )
                                                          ]
                                                          do_fork: T
                                                        )
                                                      ]
                                                      negated: T
                                                    )
                                                  terminator: <Id.Op_Semi _>
                                                )
                                              ]
                                            )
                                          action: [
                                            (C {<error>} {<1>} {<MISSINGEXTRACTOR>} 
                                              {(DQ <'The selected extractor cannot be found: %s'>)} {(DQ ($ Id.VSub_DollarName '$EXTRACTOR_OVERRIDE'))}
                                            )
                                          ]
                                          spids: [1235 1252]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [1223 1232]
                                )
                              ]
                              else_action: [
                                (C {<error>} {<1>} {<BADEXTRACTOR>} {(DQ <'%s: unknown extractor'>)} 
                                  {(DQ ($ Id.VSub_DollarName '$EXTRACTOR_OVERRIDE'))}
                                )
                              ]
                            )
                          ]
                          spids: [1115 1121 1294 -1]
                        )
                        (case_arm
                          pat_list: [
                            {<--unpack-tarball>}
                            {<--unpack-tarball> <Id.Lit_Equals '='> <Id.Lit_QMark '?'> 
                              <Id.Lit_Star '*'>
                            }
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {(DQ <--unpack-tarball>)} {<-a>} {<-n>} {(DQ ($ Id.VSub_Number '$2'))} {<Id.Lit_RBracket ']'>}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:UNPACK_TARBALL)
                                          op: assign_op.Equal
                                          rhs: {(DQ ($ Id.VSub_Number '$2'))}
                                          spids: [1335]
                                        )
                                      ]
                                    )
                                    (C {<shift>} {<2>})
                                  ]
                                  spids: [1306 1332]
                                )
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} 
                                              {
                                                (DQ 
                                                  (braced_var_sub
                                                    token: <Id.VSub_Number 1>
                                                    suffix_op: 
                                                      (suffix_op.Unary
                                                        tok: <Id.VOp1_Pound '#'>
                                                        arg_word: {<'--unpack-tarball='>}
                                                      )
                                                  )
                                                )
                                              } {<Id.Lit_RBracket ']'>}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:UNPACK_TARBALL)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (braced_var_sub
                                                  token: <Id.VSub_Number 1>
                                                  suffix_op: 
                                                    (suffix_op.Unary
                                                      tok: <Id.VOp1_Pound '#'>
                                                      arg_word: {<'--unpack-tarball='>}
                                                    )
                                                )
                                              )
                                            }
                                          spids: [1371]
                                        )
                                      ]
                                    )
                                    (C {<shift>})
                                  ]
                                  spids: [1346 1368]
                                )
                              ]
                              else_action: [
                                (C {<error>} {<1>} {<NEEDARG>} {(DQ <'option requires an argument %s'>)} 
                                  {(DQ ($ Id.VSub_Number '$1'))}
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<Id.Lit_LBracket '['>} {<Id.KW_Bang '!'>} {<-f>} 
                                              {(DQ ($ Id.VSub_DollarName '$UNPACK_TARBALL'))} {<Id.Lit_RBracket ']'>}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (C {<error>} {<1>} {<NOTARBALL>} 
                                      {(DQ <'%s: No such file or directory'>)} {(DQ ($ Id.VSub_DollarName '$UNPACK_TARBALL'))}
                                    )
                                  ]
                                  spids: [1405 1421]
                                )
                              ]
                            )
                          ]
                          spids: [1297 1303 1442 -1]
                        )
                        (case_arm
                          pat_list: [
                            {<--include>}
                            {<--include> <Id.Lit_Equals '='> <Id.Lit_QMark '?'> <Id.Lit_Star '*'>}
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {(DQ <--include>)} {<-a>} {<-n>} {(DQ ($ Id.VSub_Number '$2'))} {<Id.Lit_RBracket ']'>}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:ADDITIONAL)
                                          op: assign_op.Equal
                                          rhs: {(DQ ($ Id.VSub_Number '$2'))}
                                          spids: [1482]
                                        )
                                      ]
                                    )
                                    (C {<shift>} {<2>})
                                  ]
                                  spids: [1454 1479]
                                )
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} 
                                              {
                                                (DQ 
                                                  (braced_var_sub
                                                    token: <Id.VSub_Number 1>
                                                    suffix_op: 
                                                      (suffix_op.Unary
                                                        tok: <Id.VOp1_Pound '#'>
                                                        arg_word: {<'--include='>}
                                                      )
                                                  )
                                                )
                                              } {<Id.Lit_RBracket ']'>}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:ADDITIONAL)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (braced_var_sub
                                                  token: <Id.VSub_Number 1>
                                                  suffix_op: 
                                                    (suffix_op.Unary
                                                      tok: <Id.VOp1_Pound '#'>
                                                      arg_word: {<'--include='>}
                                                    )
                                                )
                                              )
                                            }
                                          spids: [1518]
                                        )
                                      ]
                                    )
                                    (C {<shift>} {<1>})
                                  ]
                                  spids: [1493 1515]
                                )
                              ]
                              else_action: [
                                (C {<error>} {<1>} {<NEEDARG>} {(DQ <'option requires an argument %s'>)} 
                                  {(DQ ($ Id.VSub_Number '$1'))}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:ADDITIONAL)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.Pipeline
                                              children: [
                                                (C {<echo>} {(DQ ($ Id.VSub_DollarName '$ADDITIONAL'))})
                                                (C {<tr>} {<Id.Lit_Comma ','>} {(DQ <' '>)})
                                              ]
                                              negated: F
                                            )
                                        )
                                      )
                                    }
                                  spids: [1554]
                                )
                              ]
                            )
                          ]
                          spids: [1445 1451 1576 -1]
                        )
                        (case_arm
                          pat_list: [
                            {<--exclude>}
                            {<--exclude> <Id.Lit_Equals '='> <Id.Lit_QMark '?'> <Id.Lit_Star '*'>}
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {(DQ <--exclude>)} {<-a>} {<-n>} {(DQ ($ Id.VSub_Number '$2'))} {<Id.Lit_RBracket ']'>}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:EXCLUDE)
                                          op: assign_op.Equal
                                          rhs: {(DQ ($ Id.VSub_Number '$2'))}
                                          spids: [1616]
                                        )
                                      ]
                                    )
                                    (C {<shift>} {<2>})
                                  ]
                                  spids: [1588 1613]
                                )
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} 
                                              {
                                                (DQ 
                                                  (braced_var_sub
                                                    token: <Id.VSub_Number 1>
                                                    suffix_op: 
                                                      (suffix_op.Unary
                                                        tok: <Id.VOp1_Pound '#'>
                                                        arg_word: {<'--exclude='>}
                                                      )
                                                  )
                                                )
                                              } {<Id.Lit_RBracket ']'>}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:EXCLUDE)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (braced_var_sub
                                                  token: <Id.VSub_Number 1>
                                                  suffix_op: 
                                                    (suffix_op.Unary
                                                      tok: <Id.VOp1_Pound '#'>
                                                      arg_word: {<'--exclude='>}
                                                    )
                                                )
                                              )
                                            }
                                          spids: [1652]
                                        )
                                      ]
                                    )
                                    (C {<shift>} {<1>})
                                  ]
                                  spids: [1627 1649]
                                )
                              ]
                              else_action: [
                                (C {<error>} {<1>} {<NEEDARG>} {(DQ <'option requires an argument %s'>)} 
                                  {(DQ ($ Id.VSub_Number '$1'))}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:EXCLUDE)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.Pipeline
                                              children: [
                                                (C {<echo>} {(DQ ($ Id.VSub_DollarName '$EXCLUDE'))})
                                                (C {<tr>} {<Id.Lit_Comma ','>} {(DQ <' '>)})
                                              ]
                                              negated: F
                                            )
                                        )
                                      )
                                    }
                                  spids: [1688]
                                )
                              ]
                            )
                          ]
                          spids: [1579 1585 1710 -1]
                        )
                        (case_arm
                          pat_list: [{<--verbose>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:VERBOSE)
                                  op: assign_op.Equal
                                  rhs: {<true>}
                                  spids: [1717]
                                )
                              ]
                            )
                            (C {<export>} {<VERBOSE>})
                            (C {<shift>} {<1>})
                          ]
                          spids: [1713 1714 1731 -1]
                        )
                        (case_arm
                          pat_list: [
                            {<--components>}
                            {<--components> <Id.Lit_Equals '='> <Id.Lit_QMark '?'> <Id.Lit_Star '*'>}
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {(DQ <--components>)} {<-a>} {<-n>} {(DQ ($ Id.VSub_Number '$2'))} {<Id.Lit_RBracket ']'>}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:USE_COMPONENTS)
                                          op: assign_op.Equal
                                          rhs: {(DQ ($ Id.VSub_Number '$2'))}
                                          spids: [1771]
                                        )
                                      ]
                                    )
                                    (C {<shift>} {<2>})
                                  ]
                                  spids: [1743 1768]
                                )
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} 
                                              {
                                                (DQ 
                                                  (braced_var_sub
                                                    token: <Id.VSub_Number 1>
                                                    suffix_op: 
                                                      (suffix_op.Unary
                                                        tok: <Id.VOp1_Pound '#'>
                                                        arg_word: {<'--components='>}
                                                      )
                                                  )
                                                )
                                              } {<Id.Lit_RBracket ']'>}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:USE_COMPONENTS)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (braced_var_sub
                                                  token: <Id.VSub_Number 1>
                                                  suffix_op: 
                                                    (suffix_op.Unary
                                                      tok: <Id.VOp1_Pound '#'>
                                                      arg_word: {<'--components='>}
                                                    )
                                                )
                                              )
                                            }
                                          spids: [1807]
                                        )
                                      ]
                                    )
                                    (C {<shift>} {<1>})
                                  ]
                                  spids: [1782 1804]
                                )
                              ]
                              else_action: [
                                (C {<error>} {<1>} {<NEEDARG>} {(DQ <'option requires an argument %s'>)} 
                                  {(DQ ($ Id.VSub_Number '$1'))}
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:USE_COMPONENTS)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.Pipeline
                                              children: [
                                                (C {<echo>} 
                                                  {(DQ ($ Id.VSub_DollarName '$USE_COMPONENTS'))}
                                                )
                                                (C {<tr>} {<Id.Lit_Comma ','>} {(DQ <'|'>)})
                                              ]
                                              negated: F
                                            )
                                        )
                                      )
                                    }
                                  spids: [1843]
                                )
                              ]
                            )
                          ]
                          spids: [1734 1740 1865 -1]
                        )
                        (case_arm
                          pat_list: [
                            {<--variant>}
                            {<--variant> <Id.Lit_Equals '='> <Id.Lit_QMark '?'> <Id.Lit_Star '*'>}
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {(DQ <--variant>)} {<-a>} {<-n>} {(DQ ($ Id.VSub_Number '$2'))} {<Id.Lit_RBracket ']'>}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:VARIANT)
                                          op: assign_op.Equal
                                          rhs: {(DQ ($ Id.VSub_Number '$2'))}
                                          spids: [1905]
                                        )
                                      ]
                                    )
                                    (C {<shift>} {<2>})
                                  ]
                                  spids: [1877 1902]
                                )
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} 
                                              {
                                                (DQ 
                                                  (braced_var_sub
                                                    token: <Id.VSub_Number 1>
                                                    suffix_op: 
                                                      (suffix_op.Unary
                                                        tok: <Id.VOp1_Pound '#'>
                                                        arg_word: {<'--variant='>}
                                                      )
                                                  )
                                                )
                                              } {<Id.Lit_RBracket ']'>}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:VARIANT)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (braced_var_sub
                                                  token: <Id.VSub_Number 1>
                                                  suffix_op: 
                                                    (suffix_op.Unary
                                                      tok: <Id.VOp1_Pound '#'>
                                                      arg_word: {<'--variant='>}
                                                    )
                                                )
                                              )
                                            }
                                          spids: [1941]
                                        )
                                      ]
                                    )
                                    (C {<shift>} {<1>})
                                  ]
                                  spids: [1916 1938]
                                )
                              ]
                              else_action: [
                                (C {<error>} {<1>} {<NEEDARG>} {(DQ <'option requires an argument %s'>)} 
                                  {(DQ ($ Id.VSub_Number '$1'))}
                                )
                              ]
                            )
                          ]
                          spids: [1868 1874 1977 -1]
                        )
                        (case_arm
                          pat_list: [{<--merged-usr>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:MERGED_USR)
                                  op: assign_op.Equal
                                  rhs: {<yes>}
                                  spids: [1984]
                                )
                              ]
                            )
                            (C {<shift>})
                          ]
                          spids: [1980 1981 1991 -1]
                        )
                        (case_arm
                          pat_list: [{<--no-merged-usr>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:MERGED_USR)
                                  op: assign_op.Equal
                                  rhs: {<no>}
                                  spids: [1998]
                                )
                              ]
                            )
                            (C {<shift>})
                          ]
                          spids: [1994 1995 2005 -1]
                        )
                        (case_arm
                          pat_list: [
                            {<--keyring>}
                            {<--keyring> <Id.Lit_Equals '='> <Id.Lit_QMark '?'> <Id.Lit_Star '*'>}
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (command.Pipeline
                                              children: [
                                                (command.Simple
                                                  words: [{<gpgv>} {<--version>}]
                                                  redirects: [
                                                    (redir
                                                      op: <Id.Redir_Great '>'>
                                                      loc: (redir_loc.Fd fd:1)
                                                      arg: {<'/dev/null'>}
                                                    )
                                                    (redir
                                                      op: <Id.Redir_GreatAnd '2>&'>
                                                      loc: (redir_loc.Fd fd:2)
                                                      arg: {<1>}
                                                    )
                                                  ]
                                                  do_fork: T
                                                )
                                              ]
                                              negated: T
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (C {<error>} {<1>} {<NEEDGPGV>} 
                                      {
                                        (DQ 
                                          <
'gpgv not installed, but required for Release verification'
                                          >
                                        )
                                      }
                                    )
                                  ]
                                  spids: [2017 2032]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {(DQ <--keyring>)} {<-a>} {<-n>} {(DQ ($ Id.VSub_Number '$2'))} {<Id.Lit_RBracket ']'>}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:KEYRING)
                                          op: assign_op.Equal
                                          rhs: {(DQ ($ Id.VSub_Number '$2'))}
                                          spids: [2077]
                                        )
                                      ]
                                    )
                                    (C {<shift>} {<2>})
                                  ]
                                  spids: [2049 2074]
                                )
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} 
                                              {
                                                (DQ 
                                                  (braced_var_sub
                                                    token: <Id.VSub_Number 1>
                                                    suffix_op: 
                                                      (suffix_op.Unary
                                                        tok: <Id.VOp1_Pound '#'>
                                                        arg_word: {<'--keyring='>}
                                                      )
                                                  )
                                                )
                                              } {<Id.Lit_RBracket ']'>}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:KEYRING)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (braced_var_sub
                                                  token: <Id.VSub_Number 1>
                                                  suffix_op: 
                                                    (suffix_op.Unary
                                                      tok: <Id.VOp1_Pound '#'>
                                                      arg_word: {<'--keyring='>}
                                                    )
                                                )
                                              )
                                            }
                                          spids: [2113]
                                        )
                                      ]
                                    )
                                    (C {<shift>} {<1>})
                                  ]
                                  spids: [2088 2110]
                                )
                              ]
                              else_action: [
                                (C {<error>} {<1>} {<NEEDARG>} {(DQ <'option requires an argument %s'>)} 
                                  {(DQ ($ Id.VSub_Number '$1'))}
                                )
                              ]
                            )
                          ]
                          spids: [2008 2014 2149 -1]
                        )
                        (case_arm
                          pat_list: [{<--no-check-gpg>}]
                          action: [
                            (C {<shift>} {<1>})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:DISABLE_KEYRING)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [2161]
                                )
                              ]
                            )
                          ]
                          spids: [2152 2153 2165 -1]
                        )
                        (case_arm
                          pat_list: [{<--force-check-gpg>}]
                          action: [
                            (C {<shift>} {<1>})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:FORCE_KEYRING)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [2177]
                                )
                              ]
                            )
                          ]
                          spids: [2168 2169 2181 -1]
                        )
                        (case_arm
                          pat_list: [
                            {<--certificate>}
                            {<--certificate> <Id.Lit_Equals '='> <Id.Lit_QMark '?'> <Id.Lit_Star '*'>}
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {(DQ <--certificate>)} {<-a>} {<-n>} {(DQ ($ Id.VSub_Number '$2'))} {<Id.Lit_RBracket ']'>}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:CERTIFICATE)
                                          op: assign_op.Equal
                                          rhs: {(DQ <'--certificate='> ($ Id.VSub_Number '$2'))}
                                          spids: [2221]
                                        )
                                      ]
                                    )
                                    (C {<shift>} {<2>})
                                  ]
                                  spids: [2193 2218]
                                )
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} 
                                              {
                                                (DQ 
                                                  (braced_var_sub
                                                    token: <Id.VSub_Number 1>
                                                    suffix_op: 
                                                      (suffix_op.Unary
                                                        tok: <Id.VOp1_Pound '#'>
                                                        arg_word: {<'--certificate='>}
                                                      )
                                                  )
                                                )
                                              } {<Id.Lit_RBracket ']'>}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:CERTIFICATE)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (DQ <'--certificate='> 
                                                (braced_var_sub
                                                  token: <Id.VSub_Number 1>
                                                  suffix_op: 
                                                    (suffix_op.Unary
                                                      tok: <Id.VOp1_Pound '#'>
                                                      arg_word: {<'--certificate='>}
                                                    )
                                                )
                                              )
                                            }
                                          spids: [2258]
                                        )
                                      ]
                                    )
                                    (C {<shift>} {<1>})
                                  ]
                                  spids: [2233 2255]
                                )
                              ]
                              else_action: [
                                (C {<error>} {<1>} {<NEEDARG>} {(DQ <'option requires an argument %s'>)} 
                                  {(DQ ($ Id.VSub_Number '$1'))}
                                )
                              ]
                            )
                          ]
                          spids: [2184 2190 2297 -1]
                        )
                        (case_arm
                          pat_list: [
                            {<--private-key>}
                            {<--private-key> <Id.Lit_Equals '='> <Id.Lit_QMark '?'> <Id.Lit_Star '*'>}
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.Lit_Equals '='>} {(DQ <--private-key>)} {<-a>} {<-n>} {(DQ ($ Id.VSub_Number '$2'))} {<Id.Lit_RBracket ']'>}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:PRIVATEKEY)
                                          op: assign_op.Equal
                                          rhs: {(DQ <'--private-key='> ($ Id.VSub_Number '$2'))}
                                          spids: [2337]
                                        )
                                      ]
                                    )
                                    (C {<shift>} {<2>})
                                  ]
                                  spids: [2309 2334]
                                )
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_Number '$1'))} 
                                              {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} 
                                              {
                                                (DQ 
                                                  (braced_var_sub
                                                    token: <Id.VSub_Number 1>
                                                    suffix_op: 
                                                      (suffix_op.Unary
                                                        tok: <Id.VOp1_Pound '#'>
                                                        arg_word: {<'--private-key='>}
                                                      )
                                                  )
                                                )
                                              } {<Id.Lit_RBracket ']'>}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:PRIVATEKEY)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (DQ <'--private-key='> 
                                                (braced_var_sub
                                                  token: <Id.VSub_Number 1>
                                                  suffix_op: 
                                                    (suffix_op.Unary
                                                      tok: <Id.VOp1_Pound '#'>
                                                      arg_word: {<'--private-key='>}
                                                    )
                                                )
                                              )
                                            }
                                          spids: [2374]
                                        )
                                      ]
                                    )
                                    (C {<shift>} {<1>})
                                  ]
                                  spids: [2349 2371]
                                )
                              ]
                              else_action: [
                                (C {<error>} {<1>} {<NEEDARG>} {(DQ <'option requires an argument %s'>)} 
                                  {(DQ ($ Id.VSub_Number '$1'))}
                                )
                              ]
                            )
                          ]
                          spids: [2300 2306 2413 -1]
                        )
                        (case_arm
                          pat_list: [{<--no-check-certificate>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:CHECKCERTIF)
                                  op: assign_op.Equal
                                  rhs: {(DQ <--no-check-certificate>)}
                                  spids: [2420]
                                )
                              ]
                            )
                            (C {<shift>})
                          ]
                          spids: [2416 2417 2429 -1]
                        )
                        (case_arm
                          pat_list: [{<-> <Id.Lit_Star '*'>}]
                          action: [
                            (C {<error>} {<1>} {<BADARG>} {(DQ <'unrecognized or invalid option %s'>)} 
                              {(DQ ($ Id.VSub_Number '$1'))}
                            )
                          ]
                          spids: [2432 2434 2452 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [(command.ControlFlow token:<Id.ControlFlow_Break break>)]
                          spids: [2455 2456 2462 -1]
                        )
                      ]
                    )
                  ]
                )
            )
          ]
          spids: [472 487]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (C {<Id.Lit_LBracket '['>} {<-n>} {(DQ ($ Id.VSub_DollarName '$DISABLE_KEYRING'))} 
                      {<-a>} {<-n>} {(DQ ($ Id.VSub_DollarName '$FORCE_KEYRING'))} {<Id.Lit_RBracket ']'>}
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (C {<error>} {<1>} {<BADARG>} 
              {
                (DQ 
                  <'Both --no-check-gpg and --force-check-gpg specified, please pick one (at most)'>
                )
              }
            )
          ]
          spids: [2477 2498]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$SECOND_STAGE_ONLY'))} 
                      {<Id.Lit_Equals '='>} {(DQ <true>)} {<Id.Lit_RBracket ']'>}
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:SUITE)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<cat>} {($ Id.VSub_DollarName '$DEBOOTSTRAP_DIR') <'/suite'>})
                      )
                    }
                  spids: [2538]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:ARCH)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<cat>} {($ Id.VSub_DollarName '$DEBOOTSTRAP_DIR') <'/arch'>})
                      )
                    }
                  spids: [2547]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {<-e>} 
                              {($ Id.VSub_DollarName '$DEBOOTSTRAP_DIR') <'/variant'>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:VARIANT)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<cat>} {($ Id.VSub_DollarName '$DEBOOTSTRAP_DIR') <'/variant'>})
                              )
                            }
                          spids: [2571]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:SUPPORTED_VARIANTS)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_DollarName '$VARIANT'))}
                          spids: [2580]
                        )
                      ]
                    )
                  ]
                  spids: [2556 2568]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {<-z>} {(DQ ($ Id.VSub_DollarName '$CHROOTDIR'))} 
                              {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:TARGET)
                          op: assign_op.Equal
                          rhs: {<'/'>}
                          spids: [2605]
                        )
                      ]
                    )
                  ]
                  spids: [2589 2602]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:TARGET)
                      op: assign_op.Equal
                      rhs: {($ Id.VSub_DollarName '$CHROOTDIR')}
                      spids: [2612]
                    )
                  ]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:SCRIPT)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_DollarName '$DEBOOTSTRAP_DIR') <'/suite-script'>}
                  spids: [2619]
                )
              ]
            )
          ]
          spids: [2518 2535]
        )
      ]
      else_action: [
        (command.If
          arms: [
            (if_arm
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: 
                        (command.AndOr
                          ops: [Id.Op_DPipe]
                          children: [
                            (C {<Id.Lit_LBracket '['>} {<-z>} {(DQ ($ Id.VSub_Number '$1'))} 
                              {<Id.Lit_RBracket ']'>}
                            )
                            (C {<Id.Lit_LBracket '['>} {<-z>} {(DQ ($ Id.VSub_Number '$2'))} 
                              {<Id.Lit_RBracket ']'>}
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              action: [
                (C {<usage_err>} {<1>} {<NEEDSUITETARGET>} 
                  {(DQ <'You must specify a suite and a target.'>)}
                )
              ]
              spids: [2626 2651]
            )
          ]
        )
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:SUITE)
              op: assign_op.Equal
              rhs: {(DQ ($ Id.VSub_Number '$1'))}
              spids: [2668]
            )
          ]
        )
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:TARGET)
              op: assign_op.Equal
              rhs: {(DQ ($ Id.VSub_Number '$2'))}
              spids: [2674]
            )
          ]
        )
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:USER_MIRROR)
              op: assign_op.Equal
              rhs: {(DQ ($ Id.VSub_Number '$3'))}
              spids: [2680]
            )
          ]
        )
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:TARGET)
              op: assign_op.Equal
              rhs: 
                {
                  (DQ 
                    (braced_var_sub
                      token: <Id.VSub_Name TARGET>
                      suffix_op: 
                        (suffix_op.Unary
                          tok: <Id.VOp1_Percent '%'>
                          arg_word: {<Id.Lit_Slash '/'>}
                        )
                    )
                  )
                }
              spids: [2686]
            )
          ]
        )
        (command.If
          arms: [
            (if_arm
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: 
                        (C {<Id.Lit_LBracket '['>} 
                          {
                            (DQ 
                              (braced_var_sub
                                token: <Id.VSub_Name TARGET>
                                suffix_op: 
                                  (suffix_op.Unary
                                    tok: <Id.VOp1_Pound '#'>
                                    arg_word: {<Id.Lit_Slash '/'>}
                                  )
                              )
                            )
                          } {<Id.Lit_Equals '='>} {(DQ (${ Id.VSub_Name TARGET))} {<Id.Lit_RBracket ']'>}
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              action: [
                (command.If
                  arms: [
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (command.Sentence
                              child: 
                                (C {<Id.Lit_LBracket '['>} 
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name TARGET>
                                        suffix_op: 
                                          (suffix_op.Unary
                                            tok: <Id.VOp1_Percent '%'>
                                            arg_word: {<Id.Lit_Slash '/'> <Id.Lit_Other '*'>}
                                          )
                                      )
                                    )
                                  } {<Id.Lit_Equals '='>} {(DQ ($ Id.VSub_DollarName '$TARGET'))} {<Id.Lit_RBracket ']'>}
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:TARGET)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (DQ 
                                    (command_sub
                                      left_token: <Id.Left_DollarParen '$('>
                                      child: 
                                        (C {<echo>} 
                                          {
                                            (DQ 
                                              (command_sub
                                                left_token: <Id.Left_Backtick '`'>
                                                child: (C {<pwd>})
                                              ) <'/'> ($ Id.VSub_DollarName '$TARGET')
                                            )
                                          }
                                        )
                                    )
                                  )
                                }
                              spids: [2748]
                            )
                          ]
                        )
                      ]
                      spids: [2722 2745]
                    )
                  ]
                  else_action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:TARGET)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (command_sub
                                  left_token: <Id.Left_DollarParen '$('>
                                  child: 
                                    (command.CommandList
                                      children: [
                                        (command.Sentence
                                          child: 
                                            (C {<cd>} 
                                              {
                                                (DQ 
                                                  (braced_var_sub
                                                    token: <Id.VSub_Name TARGET>
                                                    suffix_op: 
                                                      (suffix_op.Unary
                                                        tok: <Id.VOp1_Percent '%'>
                                                        arg_word: 
                                                          {<Id.Lit_Slash '/'> <Id.Lit_Other '*'>}
                                                      )
                                                  )
                                                )
                                              }
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                        (C {<echo>} 
                                          {
                                            (DQ 
                                              (command_sub
                                                left_token: <Id.Left_Backtick '`'>
                                                child: (C {<pwd>})
                                              ) <'/'> 
                                              (braced_var_sub
                                                token: <Id.VSub_Name TARGET>
                                                suffix_op: 
                                                  (suffix_op.Unary
                                                    tok: <Id.VOp1_DPound '##'>
                                                    arg_word: {<Id.Lit_Other '*'> <Id.Lit_Slash '/'>}
                                                  )
                                              )
                                            )
                                          }
                                        )
                                      ]
                                    )
                                )
                              )
                            }
                          spids: [2769]
                        )
                      ]
                    )
                  ]
                )
              ]
              spids: [2696 2719]
            )
          ]
        )
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:SCRIPT)
              op: assign_op.Equal
              rhs: 
                {(DQ ($ Id.VSub_DollarName '$DEBOOTSTRAP_DIR') <'/scripts/'> ($ Id.VSub_Number '$1'))}
              spids: [2811]
            )
          ]
        )
        (command.If
          arms: [
            (if_arm
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: 
                        (command.AndOr
                          ops: [Id.Op_DAmp]
                          children: [
                            (C {<Id.Lit_LBracket '['>} {<-n>} {(DQ ($ Id.VSub_DollarName '$VARIANT'))} 
                              {<Id.Lit_RBracket ']'>}
                            )
                            (C {<Id.Lit_LBracket '['>} {<-e>} 
                              {(DQ (${ Id.VSub_Name SCRIPT) <.> (${ Id.VSub_Name VARIANT))} {<Id.Lit_RBracket ']'>}
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:SCRIPT)
                      op: assign_op.Equal
                      rhs: {(DQ (${ Id.VSub_Name SCRIPT) <.> (${ Id.VSub_Name VARIANT))}
                      spids: [2853]
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:SUPPORTED_VARIANTS)
                      op: assign_op.Equal
                      rhs: {(DQ ($ Id.VSub_DollarName '$VARIANT'))}
                      spids: [2865]
                    )
                  ]
                )
              ]
              spids: [2819 2850]
            )
          ]
        )
        (command.If
          arms: [
            (if_arm
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: 
                        (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_Number '$4'))} 
                          {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ )} {<Id.Lit_RBracket ']'>}
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:SCRIPT)
                      op: assign_op.Equal
                      rhs: {(DQ ($ Id.VSub_Number '$4'))}
                      spids: [2894]
                    )
                  ]
                )
              ]
              spids: [2874 2891]
            )
          ]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<in_path>} {<dpkg>})
                        (command.Simple
                          words: [{<dpkg>} {<--print-architecture>}]
                          redirects: [
                            (redir
                              op: <Id.Redir_Great '>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<'/dev/null'>}
                            )
                            (redir
                              op: <Id.Redir_GreatAnd '2>&'>
                              loc: (redir_loc.Fd fd:2)
                              arg: {<1>}
                            )
                          ]
                          do_fork: T
                        )
                      ]
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:HOST_ARCH)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_Backtick '`'>
                        child: (C {<'/usr/bin/dpkg'>} {<--print-architecture>})
                      )
                    }
                  spids: [2933]
                )
              ]
            )
          ]
          spids: [2909 2930]
        )
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<in_path>} {<udpkg>})
                        (command.Simple
                          words: [{<udpkg>} {<--print-architecture>}]
                          redirects: [
                            (redir
                              op: <Id.Redir_Great '>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<'/dev/null'>}
                            )
                            (redir
                              op: <Id.Redir_GreatAnd '2>&'>
                              loc: (redir_loc.Fd fd:2)
                              arg: {<1>}
                            )
                          ]
                          do_fork: T
                        )
                      ]
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:HOST_ARCH)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_Backtick '`'>
                        child: (C {<'/usr/bin/udpkg'>} {<--print-architecture>})
                      )
                    }
                  spids: [2966]
                )
              ]
            )
          ]
          spids: [2942 2963]
        )
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (C {<Id.Lit_LBracket '['>} {<-e>} 
                      {($ Id.VSub_DollarName '$DEBOOTSTRAP_DIR') <'/arch'>} {<Id.Lit_RBracket ']'>}
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:HOST_ARCH)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_Backtick '`'>
                        child: (C {<cat>} {($ Id.VSub_DollarName '$DEBOOTSTRAP_DIR') <'/arch'>})
                      )
                    }
                  spids: [2990]
                )
              ]
            )
          ]
          spids: [2975 2987]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:HOST_OS)
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_DollarName '$HOST_ARCH'))}
          spids: [3002]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (C {<Id.Lit_LBracket '['>} {<-z>} {(DQ ($ Id.VSub_DollarName '$HOST_OS'))} 
                      {<Id.Lit_RBracket ']'>}
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.Case
              to_match: {(command_sub left_token:<Id.Left_Backtick '`'> child:(C {<uname>}))}
              arms: [
                (case_arm
                  pat_list: [{<Linux>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:HOST_OS)
                          op: assign_op.Equal
                          rhs: {<linux>}
                          spids: [3041]
                        )
                      ]
                    )
                  ]
                  spids: [3037 3038 3045 -1]
                )
                (case_arm
                  pat_list: [{<'GNU/kFreeBSD'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:HOST_OS)
                          op: assign_op.Equal
                          rhs: {<kfreebsd>}
                          spids: [3052]
                        )
                      ]
                    )
                  ]
                  spids: [3048 3049 3056 -1]
                )
                (case_arm
                  pat_list: [{<GNU>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:HOST_OS)
                          op: assign_op.Equal
                          rhs: {<hurd>}
                          spids: [3063]
                        )
                      ]
                    )
                  ]
                  spids: [3059 3060 3067 -1]
                )
                (case_arm
                  pat_list: [{<FreeBSD> <Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:HOST_OS)
                          op: assign_op.Equal
                          rhs: {<freebsd>}
                          spids: [3075]
                        )
                      ]
                    )
                  ]
                  spids: [3070 3072 3079 -1]
                )
              ]
            )
          ]
          spids: [3010 3023]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (C {<Id.Lit_LBracket '['>} {<-z>} {(DQ ($ Id.VSub_DollarName '$ARCH'))} 
                      {<Id.Lit_RBracket ']'>}
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:ARCH)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_DollarName '$HOST_ARCH')}
                  spids: [3103]
                )
              ]
            )
          ]
          spids: [3087 3100]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<Id.Lit_LBracket '['>} {<-z>} {(DQ ($ Id.VSub_DollarName '$ARCH'))} 
                          {<Id.Lit_RBracket ']'>}
                        )
                        (C {<Id.Lit_LBracket '['>} {<-z>} {(DQ ($ Id.VSub_DollarName '$HOST_OS'))} 
                          {<Id.Lit_RBracket ']'>}
                        )
                      ]
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [(C {<error>} {<1>} {<WHATARCH>} {(DQ <'Couldn\'t work out current architecture'>)})]
          spids: [3109 3134]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$HOST_OS'))} 
                          {<Id.Lit_Equals '='>} {(DQ <kfreebsd>)} {<Id.Lit_RBracket ']'>}
                        )
                        (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$HOST_OS'))} 
                          {<Id.Lit_Equals '='>} {(DQ <freebsd>)} {<Id.Lit_RBracket ']'>}
                        )
                      ]
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.ForEach
              iter_name: module
              iter_words: [{<linprocfs>} {<fdescfs>} {<tmpfs>} {<linsysfs>}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (command.Simple
                          words: [{<kldstat>} {<-m>} {(DQ ($ Id.VSub_DollarName '$module'))}]
                          redirects: [
                            (redir
                              op: <Id.Redir_Great '>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<'/dev/null'>}
                            )
                            (redir
                              op: <Id.Redir_GreatAnd '2>&'>
                              loc: (redir_loc.Fd fd:2)
                              arg: {<1>}
                            )
                          ]
                          do_fork: T
                        )
                        (C {<warning>} {<SANITYCHECK>} 
                          {(DQ <'Probably required module %s is not loaded'>)} {(DQ ($ Id.VSub_DollarName '$module'))}
                        )
                      ]
                    )
                  ]
                )
            )
          ]
          spids: [3151 3184]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$TARGET'))} 
                      {<Id.Lit_Equals '='>} {(DQ <'/'>)} {<Id.Lit_RBracket ']'>}
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:CHROOT_CMD)
                  op: assign_op.Equal
                  rhs: {(DQ )}
                  spids: [3260]
                )
              ]
            )
          ]
          spids: [3240 3257]
        )
      ]
      else_action: [
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:CHROOT_CMD)
              op: assign_op.Equal
              rhs: {(DQ <'chroot '> ($ Id.VSub_DollarName '$TARGET'))}
              spids: [3267]
            )
          ]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (C {<Id.Lit_LBracket '['>} {<-z>} {(DQ ($ Id.VSub_DollarName '$SHA_SIZE'))} 
                      {<Id.Lit_RBracket ']'>}
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:SHA_SIZE)
                  op: assign_op.Equal
                  rhs: {<256>}
                  spids: [3292]
                )
              ]
            )
          ]
          spids: [3276 3289]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.Pipeline
                          children: [(C {<in_path>} {(DQ <sha> (${ Id.VSub_Name SHA_SIZE) <sum>)})]
                          negated: T
                        )
                        (command.Pipeline
                          children: [(C {<in_path>} {(DQ <sha> (${ Id.VSub_Name SHA_SIZE))})]
                          negated: T
                        )
                      ]
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:SHA_SIZE)
                  op: assign_op.Equal
                  rhs: {<1>}
                  spids: [3328]
                )
              ]
            )
          ]
          spids: [3297 3325]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:DEBOOTSTRAP_CHECKSUM_FIELD)
          op: assign_op.Equal
          rhs: {(DQ <SHA> ($ Id.VSub_DollarName '$SHA_SIZE'))}
          spids: [3333]
        )
      ]
    )
    (C {<export>} {<ARCH>} {<SUITE>} {<TARGET>} {<CHROOT_CMD>} {<SHA_SIZE>} {<DEBOOTSTRAP_CHECKSUM_FIELD>})
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: (C {<am_doing_phase>} {<first_stage>} {<second_stage>})
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<in_path>} {<id>})
                                (C {<Id.Lit_LBracket '['>} 
                                  {
                                    (command_sub
                                      left_token: <Id.Left_Backtick '`'>
                                      child: (C {<id>} {<-u>})
                                    )
                                  } {<-ne>} {<0>} {<Id.Lit_RBracket ']'>}
                                )
                              ]
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<error>} {<1>} {<NEEDROOT>} {(DQ <'debootstrap can only run as root'>)})]
                  spids: [3367 3392]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.Pipeline
                              children: [
                                (C {<check_sane_mount>} {(DQ ($ Id.VSub_DollarName '$TARGET'))})
                              ]
                              negated: T
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<error>} {<1>} {<NOEXEC>} 
                      {
                        (DQ <'Cannot install into target \''> ($ Id.VSub_DollarName '$TARGET') 
                          <'\' mounted with noexec or nodev'>
                        )
                      }
                    )
                  ]
                  spids: [3413 3424]
                )
              ]
            )
          ]
          spids: [3355 3364]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (C {<Id.Lit_LBracket '['>} {<Id.KW_Bang '!'>} {<-e>} 
                      {(DQ ($ Id.VSub_DollarName '$SCRIPT'))} {<Id.Lit_RBracket ']'>}
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (C {<error>} {<1>} {<NOSCRIPT>} {(DQ <'No such script: %s'>)} 
              {(DQ ($ Id.VSub_DollarName '$SCRIPT'))}
            )
          ]
          spids: [3445 3460]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$TARGET'))} 
                      {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ )} {<Id.Lit_RBracket ']'>}
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [(C {<mkdir>} {<-p>} {(DQ ($ Id.VSub_DollarName '$TARGET') <'/debootstrap'>)})]
          spids: [3484 3501]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (C {<Id.Lit_LBracket '['>} 
                      {(DQ ($ Id.VSub_DollarName '$USE_DEBIANINSTALLER_INTERACTION'))} {<Id.Lit_Equals '='>} {<yes>} {<Id.Lit_RBracket ']'>}
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.Simple
              words: [{<exec>}]
              redirects: [(redir op:<Id.Redir_GreatAnd '4>&'> loc:(redir_loc.Fd fd:4) arg:{<3>})]
              do_fork: T
            )
          ]
          spids: [3539 3554]
        )
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: (C {<am_doing_phase>} {<printdebs>})
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.Simple
              words: [{<exec>}]
              redirects: [(redir op:<Id.Redir_GreatAnd '4>&'> loc:(redir_loc.Fd fd:4) arg:{<2>})]
              do_fork: T
            )
          ]
          spids: [3570 3577]
        )
      ]
      else_action: [
        (command.Simple
          words: [{<exec>}]
          redirects: [(redir op:<Id.Redir_GreatAnd '4>&'> loc:(redir_loc.Fd fd:4) arg:{<1>})]
          do_fork: T
        )
        (command.Simple
          words: [{<exec>}]
          redirects: [
            (redir
              op: <Id.Redir_DGreat '>>'>
              loc: (redir_loc.Fd fd:1)
              arg: {(DQ ($ Id.VSub_DollarName '$TARGET') <'/debootstrap/debootstrap.log'>)}
            )
          ]
          do_fork: T
        )
        (command.Simple
          words: [{<exec>}]
          redirects: [(redir op:<Id.Redir_GreatAnd '2>&'> loc:(redir_loc.Fd fd:2) arg:{<1>})]
          do_fork: T
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$UNPACK_TARBALL'))} 
                      {<Id.Lit_RBracket ']'>}
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} 
                              {
                                (DQ 
                                  (braced_var_sub
                                    token: <Id.VSub_Name UNPACK_TARBALL>
                                    suffix_op: 
                                      (suffix_op.Unary
                                        tok: <Id.VOp1_Pound '#'>
                                        arg_word: {<Id.Lit_Slash '/'>}
                                      )
                                  )
                                )
                              } {<Id.Lit_Equals '='>} {(DQ ($ Id.VSub_DollarName '$UNPACK_TARBALL'))} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<error>} {<1>} {<TARPATH>} {(DQ <'Tarball must be given a complete path'>)})
                  ]
                  spids: [3649 3670]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} 
                              {
                                (DQ 
                                  (braced_var_sub
                                    token: <Id.VSub_Name UNPACK_TARBALL>
                                    suffix_op: 
                                      (suffix_op.Unary
                                        tok: <Id.VOp1_Percent '%'>
                                        arg_word: {<.tar>}
                                      )
                                  )
                                )
                              } {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ ($ Id.VSub_DollarName '$UNPACK_TARBALL'))} 
                              {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.Subshell
                      child: 
                        (command.AndOr
                          ops: [Id.Op_DAmp]
                          children: [
                            (C {<cd>} {(DQ ($ Id.VSub_DollarName '$TARGET'))})
                            (C {<tar>} {<-xf>} {(DQ ($ Id.VSub_DollarName '$UNPACK_TARBALL'))})
                          ]
                        )
                    )
                  ]
                  spids: [3687 3709]
                )
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} 
                              {
                                (DQ 
                                  (braced_var_sub
                                    token: <Id.VSub_Name UNPACK_TARBALL>
                                    suffix_op: 
                                      (suffix_op.Unary
                                        tok: <Id.VOp1_Percent '%'>
                                        arg_word: {<.tgz>}
                                      )
                                  )
                                )
                              } {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ ($ Id.VSub_DollarName '$UNPACK_TARBALL'))} 
                              {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.Subshell
                      child: 
                        (command.AndOr
                          ops: [Id.Op_DAmp]
                          children: [
                            (C {<cd>} {(DQ ($ Id.VSub_DollarName '$TARGET'))})
                            (command.Pipeline
                              children: [
                                (C {<zcat>} {(DQ ($ Id.VSub_DollarName '$UNPACK_TARBALL'))})
                                (C {<tar>} {<-xf>} {<->})
                              ]
                              negated: F
                            )
                          ]
                        )
                    )
                  ]
                  spids: [3731 3753]
                )
              ]
              else_action: [
                (C {<error>} {<1>} {<NOTTAR>} {(DQ <'Unknown tarball: must be either .tar or .tgz'>)})
              ]
            )
          ]
          spids: [3635 3646]
        )
      ]
    )
    (C {<.>} {(DQ ($ Id.VSub_DollarName '$SCRIPT'))})
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: 
                    (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$SECOND_STAGE_ONLY'))} 
                      {<Id.Lit_Equals '='>} {(DQ <true>)} {<Id.Lit_RBracket ']'>}
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:MIRRORS)
                  op: assign_op.Equal
                  rhs: {<null> <Id.Lit_Colon ':'>}
                  spids: [3831]
                )
              ]
            )
          ]
          spids: [3811 3828]
        )
      ]
      else_action: [
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:MIRRORS)
              op: assign_op.Equal
              rhs: {(DQ ($ Id.VSub_DollarName '$DEF_MIRROR'))}
              spids: [3838]
            )
          ]
        )
        (command.If
          arms: [
            (if_arm
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: 
                        (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$USER_MIRROR'))} 
                          {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ )} {<Id.Lit_RBracket ']'>}
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:MIRRORS)
                      op: assign_op.Equal
                      rhs: {(DQ ($ Id.VSub_DollarName '$USER_MIRROR'))}
                      spids: [3864]
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:MIRRORS)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (DQ 
                            (braced_var_sub
                              token: <Id.VSub_Name MIRRORS>
                              suffix_op: 
                                (suffix_op.Unary
                                  tok: <Id.VOp1_Percent '%'>
                                  arg_word: {<Id.Lit_Slash '/'>}
                                )
                            )
                          )
                        }
                      spids: [3870]
                    )
                  ]
                )
              ]
              spids: [3844 3861]
            )
          ]
        )
      ]
    )
    (C {<export>} {<MIRRORS>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:ok)
          op: assign_op.Equal
          rhs: {<false>}
          spids: [3890]
        )
      ]
    )
    (command.ForEach
      iter_name: v
      iter_words: [{($ Id.VSub_DollarName '$SUPPORTED_VARIANTS')}]
      do_arg_iter: F
      body: 
        (command.DoGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: (C {<doing_variant>} {($ Id.VSub_DollarName '$v')})
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:ok)
                              op: assign_op.Equal
                              rhs: {<true>}
                              spids: [3914]
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                  spids: [3905 3912]
                )
              ]
            )
          ]
        )
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: (command.Pipeline children:[(C {($ Id.VSub_DollarName '$ok')})] negated:T)
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [(C {<error>} {<1>} {<UNSUPPVARIANT>} {(DQ <'unsupported variant'>)})]
          spids: [3922 3929]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: (C {<am_doing_phase>} {<finddebs>})
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (C {<Id.Lit_LBracket '['>} 
                                  {(DQ ($ Id.VSub_DollarName '$FINDDEBS_NEEDS_INDICES'))} {<Id.Lit_Equals '='>} {(DQ <true>)} {<Id.Lit_RBracket ']'>}
                                )
                                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$RESOLVE_DEPS'))} 
                                  {<Id.Lit_Equals '='>} {(DQ <true>)} {<Id.Lit_RBracket ']'>}
                                )
                              ]
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<download_indices>})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:GOT_INDICES)
                          op: assign_op.Equal
                          rhs: {<true>}
                          spids: [4000]
                        )
                      ]
                    )
                  ]
                  spids: [3959 3994]
                )
              ]
            )
            (C {<work_out_debs>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:base)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (C {<without>} 
                            {
                              (DQ ($ Id.VSub_DollarName '$base') <' '> 
                                ($ Id.VSub_DollarName '$ADDITIONAL')
                              )
                            } {(DQ ($ Id.VSub_DollarName '$EXCLUDE'))}
                          )
                      )
                    }
                  spids: [4012]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$RESOLVE_DEPS'))} 
                              {<Id.Lit_Equals '='>} {<true>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:requiredX)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<echo>} 
                                    {
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (command.Pipeline
                                            children: [
                                              (C {<echo>} {($ Id.VSub_DollarName '$required')})
                                              (C {<tr>} {(SQ <' '>)} {(SQ <'\\n'>)})
                                              (C {<sort>})
                                              (C {<uniq>})
                                            ]
                                            negated: F
                                          )
                                      )
                                    }
                                  )
                              )
                            }
                          spids: [4047]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:baseX)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<echo>} 
                                    {
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (command.Pipeline
                                            children: [
                                              (C {<echo>} {($ Id.VSub_DollarName '$base')})
                                              (C {<tr>} {(SQ <' '>)} {(SQ <'\\n'>)})
                                              (C {<sort>})
                                              (C {<uniq>})
                                            ]
                                            negated: F
                                          )
                                      )
                                    }
                                  )
                              )
                            }
                          spids: [4079]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:baseN)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<without>} {(DQ ($ Id.VSub_DollarName '$baseX'))} 
                                    {(DQ ($ Id.VSub_DollarName '$requiredX'))}
                                  )
                              )
                            }
                          spids: [4112]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:baseU)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<without>} {(DQ ($ Id.VSub_DollarName '$baseX'))} 
                                    {(DQ ($ Id.VSub_DollarName '$baseN'))}
                                  )
                              )
                            }
                          spids: [4126]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$baseU'))} 
                                      {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ )} {<Id.Lit_RBracket ']'>}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<info>} {<REDUNDANTBASE>} 
                              {(DQ <'Found packages in base already in required: %s'>)} {(DQ ($ Id.VSub_DollarName '$baseU'))}
                            )
                          ]
                          spids: [4141 4158]
                        )
                      ]
                    )
                    (C {<info>} {<RESOLVEREQ>} {(DQ <'Resolving dependencies of required packages...'>)})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:required)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: (C {<resolve_deps>} {($ Id.VSub_DollarName '$requiredX')})
                              )
                            }
                          spids: [4187]
                        )
                      ]
                    )
                    (C {<info>} {<RESOLVEBASE>} {(DQ <'Resolving dependencies of base packages...'>)})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:base)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: (C {<resolve_deps>} {($ Id.VSub_DollarName '$baseX')})
                              )
                            }
                          spids: [4204]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:base)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<without>} {(DQ ($ Id.VSub_DollarName '$base'))} 
                                    {(DQ ($ Id.VSub_DollarName '$required'))}
                                  )
                              )
                            }
                          spids: [4212]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:requiredX)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<without>} {(DQ ($ Id.VSub_DollarName '$required'))} 
                                    {(DQ ($ Id.VSub_DollarName '$requiredX'))}
                                  )
                              )
                            }
                          spids: [4227]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:baseX)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<without>} {(DQ ($ Id.VSub_DollarName '$base'))} 
                                    {(DQ ($ Id.VSub_DollarName '$baseX'))}
                                  )
                              )
                            }
                          spids: [4241]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<Id.Lit_LBracket '['>} 
                                      {(DQ ($ Id.VSub_DollarName '$requiredX'))} {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ )} {<Id.Lit_RBracket ']'>}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<info>} {<NEWREQUIRED>} 
                              {(DQ <'Found additional required dependencies: %s'>)} {(DQ ($ Id.VSub_DollarName '$requiredX'))}
                            )
                          ]
                          spids: [4255 4272]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$baseX'))} 
                                      {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ )} {<Id.Lit_RBracket ']'>}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<info>} {<NEWBASE>} {(DQ <'Found additional base dependencies: %s'>)} 
                              {(DQ ($ Id.VSub_DollarName '$baseX'))}
                            )
                          ]
                          spids: [4291 4308]
                        )
                      ]
                    )
                  ]
                  spids: [4029 4044]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:all_debs)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$required') <' '> ($ Id.VSub_DollarName '$base'))}
                  spids: [4331]
                )
              ]
            )
          ]
          spids: [3949 3956]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: (C {<am_doing_phase>} {<printdebs>})
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [(C {<echo>} {(DQ ($ Id.VSub_DollarName '$all_debs'))})]
          spids: [4341 4348]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: (C {<am_doing_phase>} {<dldebs>})
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$GOT_INDICES'))} 
                              {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ <true>)} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<download_indices>})]
                  spids: [4370 4388]
                )
              ]
            )
            (C {<download>} {($ Id.VSub_DollarName '$all_debs')})
          ]
          spids: [4360 4367]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: (C {<am_doing_phase>} {<maketarball>})
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.Subshell
              child: 
                (command.CommandList
                  children: [
                    (command.Sentence
                      child: (C {<cd>} {($ Id.VSub_DollarName '$TARGET')})
                      terminator: <Id.Op_Semi _>
                    )
                    (C {<tar>} {<czf>} {<->} {<'var/lib/apt'>} {<'var/cache/apt'>})
                  ]
                )
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {($ Id.VSub_DollarName '$MAKE_TARBALL')}
                )
              ]
            )
          ]
          spids: [4404 4411]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: (C {<am_doing_phase>} {<first_stage>})
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (C {<choose_extractor>})
            (C {<first_stage_install>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.Pipeline
                              children: [(C {<am_doing_phase>} {<second_stage>})]
                              negated: T
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<cp>} {(DQ ($ Id.VSub_Number '$0'))} 
                      {(DQ ($ Id.VSub_DollarName '$TARGET') <'/debootstrap/debootstrap'>)}
                    )
                    (C {<cp>} {($ Id.VSub_DollarName '$DEBOOTSTRAP_DIR') <'/functions'>} 
                      {(DQ ($ Id.VSub_DollarName '$TARGET') <'/debootstrap/functions'>)}
                    )
                    (C {<cp>} {($ Id.VSub_DollarName '$SCRIPT')} 
                      {(DQ ($ Id.VSub_DollarName '$TARGET') <'/debootstrap/suite-script'>)}
                    )
                    (command.Simple
                      words: [{<echo>} {(DQ ($ Id.VSub_DollarName '$ARCH'))}]
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(DQ ($ Id.VSub_DollarName '$TARGET') <'/debootstrap/arch'>)}
                        )
                      ]
                      do_fork: T
                    )
                    (command.Simple
                      words: [{<echo>} {(DQ ($ Id.VSub_DollarName '$SUITE'))}]
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(DQ ($ Id.VSub_DollarName '$TARGET') <'/debootstrap/suite'>)}
                        )
                      ]
                      do_fork: T
                    )
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<Id.Lit_LBracket '['>} {(DQ )} {<Id.Lit_Equals '='>} 
                          {(DQ ($ Id.VSub_DollarName '$VARIANT'))} {<Id.Lit_RBracket ']'>}
                        )
                        (command.Simple
                          words: [{<echo>} {(DQ ($ Id.VSub_DollarName '$VARIANT'))}]
                          redirects: [
                            (redir
                              op: <Id.Redir_Great '>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {(DQ ($ Id.VSub_DollarName '$TARGET') <'/debootstrap/variant'>)}
                            )
                          ]
                          do_fork: T
                        )
                      ]
                    )
                    (command.Simple
                      words: [{<echo>} {(DQ ($ Id.VSub_DollarName '$required'))}]
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(DQ ($ Id.VSub_DollarName '$TARGET') <'/debootstrap/required'>)}
                        )
                      ]
                      do_fork: T
                    )
                    (command.Simple
                      words: [{<echo>} {(DQ ($ Id.VSub_DollarName '$base'))}]
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(DQ ($ Id.VSub_DollarName '$TARGET') <'/debootstrap/base'>)}
                        )
                      ]
                      do_fork: T
                    )
                    (C {<chmod>} {<755>} 
                      {(DQ ($ Id.VSub_DollarName '$TARGET') <'/debootstrap/debootstrap'>)}
                    )
                  ]
                  spids: [4468 4477]
                )
              ]
            )
          ]
          spids: [4438 4445]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: (C {<am_doing_phase>} {<second_stage>})
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} 
                              {(DQ ($ Id.VSub_DollarName '$SECOND_STAGE_ONLY'))} {<Id.Lit_Equals '='>} {<true>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:required)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (command_sub
                                  left_token: <Id.Left_DollarParen '$('>
                                  child: 
                                    (C {<cat>} 
                                      {($ Id.VSub_DollarName '$DEBOOTSTRAP_DIR') <'/required'>}
                                    )
                                )
                              )
                            }
                          spids: [4638]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:base)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (command_sub
                                  left_token: <Id.Left_DollarParen '$('>
                                  child: 
                                    (C {<cat>} {($ Id.VSub_DollarName '$DEBOOTSTRAP_DIR') <'/base'>})
                                )
                              )
                            }
                          spids: [4649]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:all_debs)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ ($ Id.VSub_DollarName '$required') <' '> 
                                ($ Id.VSub_DollarName '$base')
                              )
                            }
                          spids: [4660]
                        )
                      ]
                    )
                  ]
                  spids: [4620 4635]
                )
              ]
            )
            (C {<second_stage_install>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {<-e>} 
                              {(DQ ($ Id.VSub_DollarName '$TARGET') <'/etc/apt/sources.list'>)} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<rm>} {<-f>} {(DQ ($ Id.VSub_DollarName '$TARGET') <'/etc/apt/sources.list'>)})
                  ]
                  spids: [4697 4711]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} 
                              {
                                (DQ 
                                  (braced_var_sub
                                    token: <Id.VSub_Name MIRRORS>
                                    suffix_op: 
                                      (suffix_op.Unary
                                        tok: <Id.VOp1_Pound '#'>
                                        arg_word: {<'http:'> <Id.Lit_Slash '/'> <Id.Lit_Slash '/'>}
                                      )
                                  )
                                )
                              } {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ ($ Id.VSub_DollarName '$MIRRORS'))} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<setup_apt_sources>} 
                      {
                        (DQ 
                          (braced_var_sub
                            token: <Id.VSub_Name MIRRORS>
                            suffix_op: 
                              (suffix_op.Unary
                                tok: <Id.VOp1_DPercent '%%'>
                                arg_word: {<' '> <Id.Lit_Other '*'>}
                              )
                          )
                        )
                      }
                    )
                    (C {<mv_invalid_to>} 
                      {
                        (DQ 
                          (braced_var_sub
                            token: <Id.VSub_Name MIRRORS>
                            suffix_op: 
                              (suffix_op.Unary
                                tok: <Id.VOp1_DPercent '%%'>
                                arg_word: {<' '> <Id.Lit_Other '*'>}
                              )
                          )
                        )
                      }
                    )
                  ]
                  spids: [4727 4751]
                )
              ]
              else_action: [
                (C {<setup_apt_sources>} {(DQ ($ Id.VSub_DollarName '$DEF_MIRROR'))})
                (C {<mv_invalid_to>} {(DQ ($ Id.VSub_DollarName '$DEF_MIRROR'))})
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {<-e>} 
                              {(DQ ($ Id.VSub_DollarName '$TARGET') <'/debootstrap/debootstrap.log'>)} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<Id.Lit_LBracket '['>} 
                                      {(DQ ($ Id.VSub_DollarName '$KEEP_DEBOOTSTRAP_DIR'))} {<Id.Lit_Equals '='>} {<true>} {<Id.Lit_RBracket ']'>}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<cp>} 
                              {(DQ ($ Id.VSub_DollarName '$TARGET') <'/debootstrap/debootstrap.log'>)} {(DQ ($ Id.VSub_DollarName '$TARGET') <'/var/log/bootstrap.log'>)}
                            )
                          ]
                          spids: [4816 4831]
                        )
                      ]
                      else_action: [
                        (C {<mv>} 
                          {(DQ ($ Id.VSub_DollarName '$TARGET') <'/debootstrap/debootstrap.log'>)} {(DQ ($ Id.VSub_DollarName '$TARGET') <'/var/log/bootstrap.log'>)}
                        )
                      ]
                    )
                  ]
                  spids: [4799 4813]
                )
              ]
            )
            (C {<sync>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} 
                              {(DQ ($ Id.VSub_DollarName '$KEEP_DEBOOTSTRAP_DIR'))} {<Id.Lit_Equals '='>} {<true>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<Id.Lit_LBracket '['>} {<-x>} 
                                      {
                                        (DQ ($ Id.VSub_DollarName '$TARGET') 
                                          <'/debootstrap/debootstrap'>
                                        )
                                      } {<Id.Lit_RBracket ']'>}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (C {<chmod>} {<644>} 
                              {(DQ ($ Id.VSub_DollarName '$TARGET') <'/debootstrap/debootstrap'>)}
                            )
                          ]
                          spids: [4911 4925]
                        )
                      ]
                    )
                  ]
                  spids: [4893 4908]
                )
              ]
              else_action: [(C {<rm>} {<-rf>} {(DQ ($ Id.VSub_DollarName '$TARGET') <'/debootstrap'>)})]
            )
          ]
          spids: [4610 4617]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: (C {<am_doing_phase>} {<kill_target>})
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} 
                              {(DQ ($ Id.VSub_DollarName '$KEEP_DEBOOTSTRAP_DIR'))} {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<true>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<info>} {<KILLTARGET>} {(DQ <'Deleting target directory'>)})
                    (C {<rm>} {<-rf>} {(DQ ($ Id.VSub_DollarName '$TARGET'))})
                  ]
                  spids: [4969 4985]
                )
              ]
            )
          ]
          spids: [4959 4966]
        )
      ]
    )
  ]
)