(command.CommandList
  children: [
    (C {(set)} {(-e)})
    (command.Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:VERSION) op:Equal rhs:{(SQ <'@VERSION@'>)})]
    )
    (command.AndOr
      ops: [Op_DPipe]
      children: [(C {(unset)} {(TMP)} {(TEMP)} {(TMPDIR)}) (C {(true)})]
    )
    (C {(export)} {(PATH)})
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: 
                (C {(Lit_Other '[')} {(-z)} {(DQ ($ VSub_DollarName '$DEBOOTSTRAP_DIR'))} 
                  {(Lit_Other ']')}
                )
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(Lit_Other '[')} {(-x)} {(/debootstrap/debootstrap)} {(Lit_Other ']')})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:DEBOOTSTRAP_DIR)
                          op: Equal
                          rhs: {(/debootstrap)}
                        )
                      ]
                    )
                  ]
                )
              ]
              else_action: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:DEBOOTSTRAP_DIR)
                      op: Equal
                      rhs: {(/usr/share/debootstrap)}
                    )
                  ]
                )
              ]
            )
          ]
        )
      ]
    )
    (C {(.)} {($ VSub_DollarName '$DEBOOTSTRAP_DIR') (/functions)})
    (command.SimpleCommand
      words: [{(exec)}]
      redirects: [(redir.Redir op:<Redir_GreatAnd '4>&'> fd:4 arg_word:{(1)})]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:LANG) op:Equal rhs:{(C)})]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:USE_COMPONENTS) op:Equal rhs:{(main)})]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:KEYRING) op:Equal rhs:{(DQ )})]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:DISABLE_KEYRING) op:Equal rhs:{(DQ )})]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:FORCE_KEYRING) op:Equal rhs:{(DQ )})]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:VARIANT) op:Equal rhs:{(DQ )})]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:MERGED_USR) op:Equal rhs:{(DQ (no))})]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:ARCH) op:Equal rhs:{(DQ )})]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:HOST_ARCH) op:Equal rhs:{(DQ )})]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:HOST_OS) op:Equal rhs:{(DQ )})]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:KEEP_DEBOOTSTRAP_DIR) op:Equal rhs:{(DQ )})]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:USE_DEBIANINSTALLER_INTERACTION) op:Equal rhs:{(DQ )})]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:SECOND_STAGE_ONLY) op:Equal rhs:{(DQ )})]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:PRINT_DEBS) op:Equal rhs:{(DQ )})]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:CHROOTDIR) op:Equal rhs:{(DQ )})]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:MAKE_TARBALL) op:Equal rhs:{(DQ )})]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:EXTRACTOR_OVERRIDE) op:Equal rhs:{(DQ )})]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:UNPACK_TARBALL) op:Equal rhs:{(DQ )})]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:ADDITIONAL) op:Equal rhs:{(DQ )})]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:EXCLUDE) op:Equal rhs:{(DQ )})]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:VERBOSE) op:Equal rhs:{(DQ )})]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:CERTIFICATE) op:Equal rhs:{(DQ )})]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:CHECKCERTIF) op:Equal rhs:{(DQ )})]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:PRIVATEKEY) op:Equal rhs:{(DQ )})]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:DEF_MIRROR)
          op: Equal
          rhs: {(DQ ('http://deb.debian.org/debian'))}
        )
      ]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:DEF_HTTPS_MIRROR)
          op: Equal
          rhs: {(DQ ('https://deb.debian.org/debian'))}
        )
      ]
    )
    (C {(export)} {(LANG)} {(USE_COMPONENTS)})
    (C {(umask)} {(022)})
    (command.Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:RESOLVE_DEPS) op:Equal rhs:{(true)})]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:WHAT_TO_DO)
          op: Equal
          rhs: {(DQ ('finddebs dldebs first_stage second_stage'))}
        )
      ]
    )
    (command.FuncDef
      name: am_doing_phase
      body: 
        (command.BraceGroup
          children: [
            (command.Sentence
              child: 
                (command.Assignment
                  keyword: Assign_Local
                  pairs: [(assign_pair lhs:(lhs_expr.LhsName name:x) op:Equal)]
                )
              terminator: <Op_Semi ';'>
            )
            (command.ForEach
              iter_name: x
              iter_words: [{(DQ ($ VSub_At '$@'))}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.Pipeline
                                  children: [
                                    (C {(echo)} {(DQ (' ') ($ VSub_DollarName '$WHAT_TO_DO') (' '))})
                                    (C {(grep)} {(-q)} {(DQ (' ') ($ VSub_DollarName '$x') (' '))})
                                  ]
                                  negated: F
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (command.Sentence
                              child: 
                                (command.ControlFlow
                                  token: <ControlFlow_Return return>
                                  arg_word: {(0)}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
            )
            (command.ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
          ]
        )
    )
    (command.FuncDef
      name: usage_err
      body: 
        (command.BraceGroup
          children: [
            (C {(info)} {(USAGE1)} {(DQ ('usage: [OPTION]... <suite> <target> [<mirror> [<script>]]'))})
            (C {(info)} {(USAGE2)} 
              {
                (DQ ('Try ') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\`'>) 
                  (word_part.BracedVarSub
                    token: <VSub_Number 0>
                    suffix_op: (suffix_op.StringUnary op_id:VOp1_DPound arg_word:{('*') (Lit_Slash /)})
                  ) (" --help' for more information.")
                )
              }
            )
            (C {(error)} {(DQ ($ VSub_At '$@'))})
          ]
        )
    )
    (command.FuncDef
      name: usage
      body: 
        (command.BraceGroup
          children: [
            (C {(echo)} 
              {
                (DQ ('Usage: ') 
                  (word_part.BracedVarSub
                    token: <VSub_Number 0>
                    suffix_op: (suffix_op.StringUnary op_id:VOp1_DPound arg_word:{('*') (Lit_Slash /)})
                  ) (' [OPTION]... <suite> <target> [<mirror> [<script>]]')
                )
              }
            )
            (C {(echo)} {(DQ ('Bootstrap a Debian base system into a target directory.'))})
            (C {(echo)})
            (command.SimpleCommand
              words: [{(cat)}]
              redirects: [
                (redir.HereDoc
                  op: <Redir_DLess '<<'>
                  fd: 16777215
                  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: ')
                    ($ 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'
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: 
                (C {(Lit_Other '[')} {(-z)} {(DQ ($ VSub_DollarName '$PKGDETAILS'))} {(Lit_Other ']')})
              terminator: <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'
                  )
                )
              }
            )
          ]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: 
                (C {(Lit_Other '[')} {($ VSub_Pound '$#')} {(KW_Bang '!') (Lit_Other '=')} {(0)} 
                  {(Lit_Other ']')}
                )
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [(command.Sentence child:(C {(true)}) terminator:<Op_Semi ';'>)]
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ VSub_Number '$1'))}
                      arms: [
                        (case_arm
                          pat_list: [{(--help)}]
                          action: [
                            (C {(usage)})
                            (command.ControlFlow
                              token: <ControlFlow_Exit exit>
                              arg_word: {(0)}
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--version)}]
                          action: [
                            (C {(echo)} {(DQ ('debootstrap ') ($ VSub_DollarName '$VERSION'))})
                            (command.ControlFlow
                              token: <ControlFlow_Exit exit>
                              arg_word: {(0)}
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--debian-installer)}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (command.Pipeline
                                          children: [
                                            (command.Subshell
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (command.SimpleCommand
                                                      words: [{(echo)} {(-n)} {(DQ )}]
                                                      redirects: [
                                                        (redir.Redir
                                                          op: <Redir_GreatAnd '>&'>
                                                          fd: 16777215
                                                          arg_word: {(3)}
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              redirects: [
                                                (redir.Redir
                                                  op: <Redir_Great '2>'>
                                                  fd: 2
                                                  arg_word: {(/dev/null)}
                                                )
                                              ]
                                            )
                                          ]
                                          negated: T
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C {(error)} {(1)} {(ARG_DIBYHAND)} 
                                      {
                                        (DQ 
                                          (
"If running debootstrap by hand, don't use --debian-installer"
                                          )
                                        )
                                      }
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:USE_DEBIANINSTALLER_INTERACTION)
                                  op: Equal
                                  rhs: {(yes)}
                                )
                              ]
                            )
                            (C {(shift)})
                          ]
                        )
                        (case_arm
                          pat_list: [{(--foreign)}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(Lit_Other '[')} {(DQ ($ VSub_DollarName '$PRINT_DEBS'))} 
                                          {(KW_Bang '!') (Lit_Other '=')} {(DQ (true))} {(Lit_Other ']')}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:WHAT_TO_DO)
                                          op: Equal
                                          rhs: {(DQ ('finddebs dldebs first_stage'))}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (C {(shift)})
                          ]
                        )
                        (case_arm
                          pat_list: [{(--second-stage)}]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:WHAT_TO_DO)
                                  op: Equal
                                  rhs: {(DQ (second_stage))}
                                )
                              ]
                            )
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:SECOND_STAGE_ONLY)
                                  op: Equal
                                  rhs: {(true)}
                                )
                              ]
                            )
                            (C {(shift)})
                          ]
                        )
                        (case_arm
                          pat_list: [
                            {(--second-stage-target)}
                            {(--second-stage-target) (Lit_Other '=') (Lit_Other '?') (Lit_Other '*')}
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(Lit_Other '[')} 
                                          {(DQ ($ VSub_DollarName '$SECOND_STAGE_ONLY'))} {(KW_Bang '!') (Lit_Other '=')} {(DQ (true))} {(Lit_Other ']')}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C {(error)} {(1)} {(STAGE2ONLY)} 
                                      {(DQ ('option %s only applies in the second stage'))} {(DQ ($ VSub_Number '$1'))}
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(Lit_Other '[')} {(DQ ($ VSub_Number '$1'))} 
                                          {(Lit_Other '=')} {(DQ (--second-stage-target))} {(-a)} {(-n)} {(DQ ($ VSub_Number '$2'))} {(Lit_Other ']')}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:CHROOTDIR)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Number '$2'))}
                                        )
                                      ]
                                    )
                                    (C {(shift)} {(2)})
                                  ]
                                )
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(Lit_Other '[')} {(DQ ($ VSub_Number '$1'))} 
                                          {(KW_Bang '!') (Lit_Other '=')} 
                                          {
                                            (DQ 
                                              (word_part.BracedVarSub
                                                token: <VSub_Number 1>
                                                suffix_op: 
                                                  (suffix_op.StringUnary
                                                    op_id: VOp1_Pound
                                                    arg_word: {('--second-stage-target=')}
                                                  )
                                              )
                                            )
                                          } {(Lit_Other ']')}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:CHROOTDIR)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (word_part.BracedVarSub
                                                  token: <VSub_Number 1>
                                                  suffix_op: 
                                                    (suffix_op.StringUnary
                                                      op_id: VOp1_Pound
                                                      arg_word: {('--second-stage-target=')}
                                                    )
                                                )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (C {(shift)})
                                  ]
                                )
                              ]
                              else_action: [
                                (C {(error)} {(1)} {(NEEDARG)} {(DQ ('option requires an argument: %s'))} 
                                  {(DQ ($ VSub_Number '$1'))}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--print-debs)}]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:WHAT_TO_DO)
                                  op: Equal
                                  rhs: {(DQ ('finddebs printdebs kill_target'))}
                                )
                              ]
                            )
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:PRINT_DEBS)
                                  op: Equal
                                  rhs: {(true)}
                                )
                              ]
                            )
                            (C {(shift)})
                          ]
                        )
                        (case_arm
                          pat_list: [{(--download-only)}]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:WHAT_TO_DO)
                                  op: Equal
                                  rhs: {(DQ ('finddebs dldebs'))}
                                )
                              ]
                            )
                            (C {(shift)})
                          ]
                        )
                        (case_arm
                          pat_list: [
                            {(--make-tarball)}
                            {(--make-tarball) (Lit_Other '=') (Lit_Other '?') (Lit_Other '*')}
                          ]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:WHAT_TO_DO)
                                  op: Equal
                                  rhs: {(DQ ('finddebs dldebs maketarball kill_target'))}
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(Lit_Other '[')} {(DQ ($ VSub_Number '$1'))} 
                                          {(Lit_Other '=')} {(DQ (--make-tarball))} {(-a)} {(-n)} {(DQ ($ VSub_Number '$2'))} {(Lit_Other ']')}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:MAKE_TARBALL)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Number '$2'))}
                                        )
                                      ]
                                    )
                                    (C {(shift)} {(2)})
                                  ]
                                )
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(Lit_Other '[')} {(DQ ($ VSub_Number '$1'))} 
                                          {(KW_Bang '!') (Lit_Other '=')} 
                                          {
                                            (DQ 
                                              (word_part.BracedVarSub
                                                token: <VSub_Number 1>
                                                suffix_op: 
                                                  (suffix_op.StringUnary
                                                    op_id: VOp1_Pound
                                                    arg_word: {('--make-tarball=')}
                                                  )
                                              )
                                            )
                                          } {(Lit_Other ']')}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:MAKE_TARBALL)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (word_part.BracedVarSub
                                                  token: <VSub_Number 1>
                                                  suffix_op: 
                                                    (suffix_op.StringUnary
                                                      op_id: VOp1_Pound
                                                      arg_word: {('--make-tarball=')}
                                                    )
                                                )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (C {(shift)})
                                  ]
                                )
                              ]
                              else_action: [
                                (C {(error)} {(1)} {(NEEDARG)} {(DQ ('option requires an argument %s'))} 
                                  {(DQ ($ VSub_Number '$1'))}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--resolve-deps)}]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:RESOLVE_DEPS)
                                  op: Equal
                                  rhs: {(true)}
                                )
                              ]
                            )
                            (C {(shift)})
                          ]
                        )
                        (case_arm
                          pat_list: [{(--no-resolve-deps)}]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:RESOLVE_DEPS)
                                  op: Equal
                                  rhs: {(false)}
                                )
                              ]
                            )
                            (C {(shift)})
                          ]
                        )
                        (case_arm
                          pat_list: [{(--keep-debootstrap-dir)}]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:KEEP_DEBOOTSTRAP_DIR)
                                  op: Equal
                                  rhs: {(true)}
                                )
                              ]
                            )
                            (C {(shift)})
                          ]
                        )
                        (case_arm
                          pat_list: [
                            {(--arch)}
                            {(--arch) (Lit_Other '=') (Lit_Other '?') (Lit_Other '*')}
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(Lit_Other '[')} {(DQ ($ VSub_Number '$1'))} 
                                          {(Lit_Other '=')} {(DQ (--arch))} {(-a)} {(-n)} {(DQ ($ VSub_Number '$2'))} {(Lit_Other ']')}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:ARCH)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Number '$2'))}
                                        )
                                      ]
                                    )
                                    (C {(shift)} {(2)})
                                  ]
                                )
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(Lit_Other '[')} {(DQ ($ VSub_Number '$1'))} 
                                          {(KW_Bang '!') (Lit_Other '=')} 
                                          {
                                            (DQ 
                                              (word_part.BracedVarSub
                                                token: <VSub_Number 1>
                                                suffix_op: 
                                                  (suffix_op.StringUnary
                                                    op_id: VOp1_Pound
                                                    arg_word: {('--arch=')}
                                                  )
                                              )
                                            )
                                          } {(Lit_Other ']')}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:ARCH)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (word_part.BracedVarSub
                                                  token: <VSub_Number 1>
                                                  suffix_op: 
                                                    (suffix_op.StringUnary
                                                      op_id: VOp1_Pound
                                                      arg_word: {('--arch=')}
                                                    )
                                                )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (C {(shift)})
                                  ]
                                )
                              ]
                              else_action: [
                                (C {(error)} {(1)} {(NEEDARG)} {(DQ ('option requires an argument %s'))} 
                                  {(DQ ($ VSub_Number '$1'))}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [
                            {(--extractor)}
                            {(--extractor) (Lit_Other '=') (Lit_Other '?') (Lit_Other '*')}
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(Lit_Other '[')} {(DQ ($ VSub_Number '$1'))} 
                                          {(Lit_Other '=')} {(DQ (--extractor))} {(-a)} {(-n)} {(DQ ($ VSub_Number '$2'))} {(Lit_Other ']')}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:EXTRACTOR_OVERRIDE)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Number '$2'))}
                                        )
                                      ]
                                    )
                                    (C {(shift)} {(2)})
                                  ]
                                )
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(Lit_Other '[')} {(DQ ($ VSub_Number '$1'))} 
                                          {(KW_Bang '!') (Lit_Other '=')} 
                                          {
                                            (DQ 
                                              (word_part.BracedVarSub
                                                token: <VSub_Number 1>
                                                suffix_op: 
                                                  (suffix_op.StringUnary
                                                    op_id: VOp1_Pound
                                                    arg_word: {('--extractor=')}
                                                  )
                                              )
                                            )
                                          } {(Lit_Other ']')}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:EXTRACTOR_OVERRIDE)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (word_part.BracedVarSub
                                                  token: <VSub_Number 1>
                                                  suffix_op: 
                                                    (suffix_op.StringUnary
                                                      op_id: VOp1_Pound
                                                      arg_word: {('--extractor=')}
                                                    )
                                                )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (C {(shift)})
                                  ]
                                )
                              ]
                              else_action: [
                                (C {(error)} {(1)} {(NEEDARG)} {(DQ ('option requires an argument %s'))} 
                                  {(DQ ($ VSub_Number '$1'))}
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(valid_extractor)} 
                                          {(DQ ($ VSub_DollarName '$EXTRACTOR_OVERRIDE'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: 
                                                (command.Pipeline
                                                  children: [
                                                    (command.SimpleCommand
                                                      words: [
                                                        {(type)}
                                                        {
                                                          (DQ 
                                                            ($ VSub_DollarName '$EXTRACTOR_OVERRIDE')
                                                          )
                                                        }
                                                      ]
                                                      redirects: [
                                                        (redir.Redir
                                                          op: <Redir_Great '>'>
                                                          fd: 16777215
                                                          arg_word: {(/dev/null)}
                                                        )
                                                        (redir.Redir
                                                          op: <Redir_GreatAnd '2>&'>
                                                          fd: 2
                                                          arg_word: {(1)}
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                  negated: T
                                                )
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (C {(error)} {(1)} {(MISSINGEXTRACTOR)} 
                                              {(DQ ('The selected extractor cannot be found: %s'))} {(DQ ($ VSub_DollarName '$EXTRACTOR_OVERRIDE'))}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                              else_action: [
                                (C {(error)} {(1)} {(BADEXTRACTOR)} {(DQ ('%s: unknown extractor'))} 
                                  {(DQ ($ VSub_DollarName '$EXTRACTOR_OVERRIDE'))}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [
                            {(--unpack-tarball)}
                            {(--unpack-tarball) (Lit_Other '=') (Lit_Other '?') (Lit_Other '*')}
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(Lit_Other '[')} {(DQ ($ VSub_Number '$1'))} 
                                          {(Lit_Other '=')} {(DQ (--unpack-tarball))} {(-a)} {(-n)} {(DQ ($ VSub_Number '$2'))} {(Lit_Other ']')}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:UNPACK_TARBALL)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Number '$2'))}
                                        )
                                      ]
                                    )
                                    (C {(shift)} {(2)})
                                  ]
                                )
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(Lit_Other '[')} {(DQ ($ VSub_Number '$1'))} 
                                          {(KW_Bang '!') (Lit_Other '=')} 
                                          {
                                            (DQ 
                                              (word_part.BracedVarSub
                                                token: <VSub_Number 1>
                                                suffix_op: 
                                                  (suffix_op.StringUnary
                                                    op_id: VOp1_Pound
                                                    arg_word: {('--unpack-tarball=')}
                                                  )
                                              )
                                            )
                                          } {(Lit_Other ']')}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:UNPACK_TARBALL)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (word_part.BracedVarSub
                                                  token: <VSub_Number 1>
                                                  suffix_op: 
                                                    (suffix_op.StringUnary
                                                      op_id: VOp1_Pound
                                                      arg_word: {('--unpack-tarball=')}
                                                    )
                                                )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (C {(shift)})
                                  ]
                                )
                              ]
                              else_action: [
                                (C {(error)} {(1)} {(NEEDARG)} {(DQ ('option requires an argument %s'))} 
                                  {(DQ ($ VSub_Number '$1'))}
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(Lit_Other '[')} {(KW_Bang '!')} {(-f)} 
                                          {(DQ ($ VSub_DollarName '$UNPACK_TARBALL'))} {(Lit_Other ']')}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C {(error)} {(1)} {(NOTARBALL)} 
                                      {(DQ ('%s: No such file or directory'))} {(DQ ($ VSub_DollarName '$UNPACK_TARBALL'))}
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [
                            {(--include)}
                            {(--include) (Lit_Other '=') (Lit_Other '?') (Lit_Other '*')}
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(Lit_Other '[')} {(DQ ($ VSub_Number '$1'))} 
                                          {(Lit_Other '=')} {(DQ (--include))} {(-a)} {(-n)} {(DQ ($ VSub_Number '$2'))} {(Lit_Other ']')}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:ADDITIONAL)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Number '$2'))}
                                        )
                                      ]
                                    )
                                    (C {(shift)} {(2)})
                                  ]
                                )
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(Lit_Other '[')} {(DQ ($ VSub_Number '$1'))} 
                                          {(KW_Bang '!') (Lit_Other '=')} 
                                          {
                                            (DQ 
                                              (word_part.BracedVarSub
                                                token: <VSub_Number 1>
                                                suffix_op: 
                                                  (suffix_op.StringUnary
                                                    op_id: VOp1_Pound
                                                    arg_word: {('--include=')}
                                                  )
                                              )
                                            )
                                          } {(Lit_Other ']')}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:ADDITIONAL)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (word_part.BracedVarSub
                                                  token: <VSub_Number 1>
                                                  suffix_op: 
                                                    (suffix_op.StringUnary
                                                      op_id: VOp1_Pound
                                                      arg_word: {('--include=')}
                                                    )
                                                )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (C {(shift)} {(1)})
                                  ]
                                )
                              ]
                              else_action: [
                                (C {(error)} {(1)} {(NEEDARG)} {(DQ ('option requires an argument %s'))} 
                                  {(DQ ($ VSub_Number '$1'))}
                                )
                              ]
                            )
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:ADDITIONAL)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (word_part.CommandSubPart
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (command.Pipeline
                                                  children: [
                                                    (C {(echo)} {(DQ ($ VSub_DollarName '$ADDITIONAL'))})
                                                    (C {(tr)} {(Lit_Comma ',')} {(DQ (' '))})
                                                  ]
                                                  negated: F
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                        )
                                      )
                                    }
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [
                            {(--exclude)}
                            {(--exclude) (Lit_Other '=') (Lit_Other '?') (Lit_Other '*')}
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(Lit_Other '[')} {(DQ ($ VSub_Number '$1'))} 
                                          {(Lit_Other '=')} {(DQ (--exclude))} {(-a)} {(-n)} {(DQ ($ VSub_Number '$2'))} {(Lit_Other ']')}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:EXCLUDE)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Number '$2'))}
                                        )
                                      ]
                                    )
                                    (C {(shift)} {(2)})
                                  ]
                                )
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(Lit_Other '[')} {(DQ ($ VSub_Number '$1'))} 
                                          {(KW_Bang '!') (Lit_Other '=')} 
                                          {
                                            (DQ 
                                              (word_part.BracedVarSub
                                                token: <VSub_Number 1>
                                                suffix_op: 
                                                  (suffix_op.StringUnary
                                                    op_id: VOp1_Pound
                                                    arg_word: {('--exclude=')}
                                                  )
                                              )
                                            )
                                          } {(Lit_Other ']')}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:EXCLUDE)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (word_part.BracedVarSub
                                                  token: <VSub_Number 1>
                                                  suffix_op: 
                                                    (suffix_op.StringUnary
                                                      op_id: VOp1_Pound
                                                      arg_word: {('--exclude=')}
                                                    )
                                                )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (C {(shift)} {(1)})
                                  ]
                                )
                              ]
                              else_action: [
                                (C {(error)} {(1)} {(NEEDARG)} {(DQ ('option requires an argument %s'))} 
                                  {(DQ ($ VSub_Number '$1'))}
                                )
                              ]
                            )
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:EXCLUDE)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (word_part.CommandSubPart
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (command.Pipeline
                                                  children: [
                                                    (C {(echo)} {(DQ ($ VSub_DollarName '$EXCLUDE'))})
                                                    (C {(tr)} {(Lit_Comma ',')} {(DQ (' '))})
                                                  ]
                                                  negated: F
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                        )
                                      )
                                    }
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--verbose)}]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:VERBOSE)
                                  op: Equal
                                  rhs: {(true)}
                                )
                              ]
                            )
                            (C {(export)} {(VERBOSE)})
                            (C {(shift)} {(1)})
                          ]
                        )
                        (case_arm
                          pat_list: [
                            {(--components)}
                            {(--components) (Lit_Other '=') (Lit_Other '?') (Lit_Other '*')}
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(Lit_Other '[')} {(DQ ($ VSub_Number '$1'))} 
                                          {(Lit_Other '=')} {(DQ (--components))} {(-a)} {(-n)} {(DQ ($ VSub_Number '$2'))} {(Lit_Other ']')}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:USE_COMPONENTS)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Number '$2'))}
                                        )
                                      ]
                                    )
                                    (C {(shift)} {(2)})
                                  ]
                                )
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(Lit_Other '[')} {(DQ ($ VSub_Number '$1'))} 
                                          {(KW_Bang '!') (Lit_Other '=')} 
                                          {
                                            (DQ 
                                              (word_part.BracedVarSub
                                                token: <VSub_Number 1>
                                                suffix_op: 
                                                  (suffix_op.StringUnary
                                                    op_id: VOp1_Pound
                                                    arg_word: {('--components=')}
                                                  )
                                              )
                                            )
                                          } {(Lit_Other ']')}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:USE_COMPONENTS)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (word_part.BracedVarSub
                                                  token: <VSub_Number 1>
                                                  suffix_op: 
                                                    (suffix_op.StringUnary
                                                      op_id: VOp1_Pound
                                                      arg_word: {('--components=')}
                                                    )
                                                )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (C {(shift)} {(1)})
                                  ]
                                )
                              ]
                              else_action: [
                                (C {(error)} {(1)} {(NEEDARG)} {(DQ ('option requires an argument %s'))} 
                                  {(DQ ($ VSub_Number '$1'))}
                                )
                              ]
                            )
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:USE_COMPONENTS)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (word_part.CommandSubPart
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (command.Pipeline
                                                  children: [
                                                    (C {(echo)} 
                                                      {(DQ ($ VSub_DollarName '$USE_COMPONENTS'))}
                                                    )
                                                    (C {(tr)} {(Lit_Comma ',')} {(DQ ('|'))})
                                                  ]
                                                  negated: F
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                        )
                                      )
                                    }
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [
                            {(--variant)}
                            {(--variant) (Lit_Other '=') (Lit_Other '?') (Lit_Other '*')}
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(Lit_Other '[')} {(DQ ($ VSub_Number '$1'))} 
                                          {(Lit_Other '=')} {(DQ (--variant))} {(-a)} {(-n)} {(DQ ($ VSub_Number '$2'))} {(Lit_Other ']')}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:VARIANT)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Number '$2'))}
                                        )
                                      ]
                                    )
                                    (C {(shift)} {(2)})
                                  ]
                                )
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(Lit_Other '[')} {(DQ ($ VSub_Number '$1'))} 
                                          {(KW_Bang '!') (Lit_Other '=')} 
                                          {
                                            (DQ 
                                              (word_part.BracedVarSub
                                                token: <VSub_Number 1>
                                                suffix_op: 
                                                  (suffix_op.StringUnary
                                                    op_id: VOp1_Pound
                                                    arg_word: {('--variant=')}
                                                  )
                                              )
                                            )
                                          } {(Lit_Other ']')}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:VARIANT)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (word_part.BracedVarSub
                                                  token: <VSub_Number 1>
                                                  suffix_op: 
                                                    (suffix_op.StringUnary
                                                      op_id: VOp1_Pound
                                                      arg_word: {('--variant=')}
                                                    )
                                                )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (C {(shift)} {(1)})
                                  ]
                                )
                              ]
                              else_action: [
                                (C {(error)} {(1)} {(NEEDARG)} {(DQ ('option requires an argument %s'))} 
                                  {(DQ ($ VSub_Number '$1'))}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--merged-usr)}]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:MERGED_USR)
                                  op: Equal
                                  rhs: {(yes)}
                                )
                              ]
                            )
                            (C {(shift)})
                          ]
                        )
                        (case_arm
                          pat_list: [{(--no-merged-usr)}]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:MERGED_USR)
                                  op: Equal
                                  rhs: {(no)}
                                )
                              ]
                            )
                            (C {(shift)})
                          ]
                        )
                        (case_arm
                          pat_list: [
                            {(--keyring)}
                            {(--keyring) (Lit_Other '=') (Lit_Other '?') (Lit_Other '*')}
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (command.Pipeline
                                          children: [
                                            (command.SimpleCommand
                                              words: [{(gpgv)} {(--version)}]
                                              redirects: [
                                                (redir.Redir
                                                  op: <Redir_Great '>'>
                                                  fd: 16777215
                                                  arg_word: {(/dev/null)}
                                                )
                                                (redir.Redir
                                                  op: <Redir_GreatAnd '2>&'>
                                                  fd: 2
                                                  arg_word: {(1)}
                                                )
                                              ]
                                            )
                                          ]
                                          negated: T
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (C {(error)} {(1)} {(NEEDGPGV)} 
                                      {
                                        (DQ 
                                          (
'gpgv not installed, but required for Release verification'
                                          )
                                        )
                                      }
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(Lit_Other '[')} {(DQ ($ VSub_Number '$1'))} 
                                          {(Lit_Other '=')} {(DQ (--keyring))} {(-a)} {(-n)} {(DQ ($ VSub_Number '$2'))} {(Lit_Other ']')}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:KEYRING)
                                          op: Equal
                                          rhs: {(DQ ($ VSub_Number '$2'))}
                                        )
                                      ]
                                    )
                                    (C {(shift)} {(2)})
                                  ]
                                )
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(Lit_Other '[')} {(DQ ($ VSub_Number '$1'))} 
                                          {(KW_Bang '!') (Lit_Other '=')} 
                                          {
                                            (DQ 
                                              (word_part.BracedVarSub
                                                token: <VSub_Number 1>
                                                suffix_op: 
                                                  (suffix_op.StringUnary
                                                    op_id: VOp1_Pound
                                                    arg_word: {('--keyring=')}
                                                  )
                                              )
                                            )
                                          } {(Lit_Other ']')}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:KEYRING)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (word_part.BracedVarSub
                                                  token: <VSub_Number 1>
                                                  suffix_op: 
                                                    (suffix_op.StringUnary
                                                      op_id: VOp1_Pound
                                                      arg_word: {('--keyring=')}
                                                    )
                                                )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (C {(shift)} {(1)})
                                  ]
                                )
                              ]
                              else_action: [
                                (C {(error)} {(1)} {(NEEDARG)} {(DQ ('option requires an argument %s'))} 
                                  {(DQ ($ VSub_Number '$1'))}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--no-check-gpg)}]
                          action: [
                            (C {(shift)} {(1)})
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:DISABLE_KEYRING)
                                  op: Equal
                                  rhs: {(1)}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--force-check-gpg)}]
                          action: [
                            (C {(shift)} {(1)})
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:FORCE_KEYRING)
                                  op: Equal
                                  rhs: {(1)}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [
                            {(--certificate)}
                            {(--certificate) (Lit_Other '=') (Lit_Other '?') (Lit_Other '*')}
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(Lit_Other '[')} {(DQ ($ VSub_Number '$1'))} 
                                          {(Lit_Other '=')} {(DQ (--certificate))} {(-a)} {(-n)} {(DQ ($ VSub_Number '$2'))} {(Lit_Other ']')}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:CERTIFICATE)
                                          op: Equal
                                          rhs: {(DQ ('--certificate=') ($ VSub_Number '$2'))}
                                        )
                                      ]
                                    )
                                    (C {(shift)} {(2)})
                                  ]
                                )
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(Lit_Other '[')} {(DQ ($ VSub_Number '$1'))} 
                                          {(KW_Bang '!') (Lit_Other '=')} 
                                          {
                                            (DQ 
                                              (word_part.BracedVarSub
                                                token: <VSub_Number 1>
                                                suffix_op: 
                                                  (suffix_op.StringUnary
                                                    op_id: VOp1_Pound
                                                    arg_word: {('--certificate=')}
                                                  )
                                              )
                                            )
                                          } {(Lit_Other ']')}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:CERTIFICATE)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ('--certificate=') 
                                                (word_part.BracedVarSub
                                                  token: <VSub_Number 1>
                                                  suffix_op: 
                                                    (suffix_op.StringUnary
                                                      op_id: VOp1_Pound
                                                      arg_word: {('--certificate=')}
                                                    )
                                                )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (C {(shift)} {(1)})
                                  ]
                                )
                              ]
                              else_action: [
                                (C {(error)} {(1)} {(NEEDARG)} {(DQ ('option requires an argument %s'))} 
                                  {(DQ ($ VSub_Number '$1'))}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [
                            {(--private-key)}
                            {(--private-key) (Lit_Other '=') (Lit_Other '?') (Lit_Other '*')}
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(Lit_Other '[')} {(DQ ($ VSub_Number '$1'))} 
                                          {(Lit_Other '=')} {(DQ (--private-key))} {(-a)} {(-n)} {(DQ ($ VSub_Number '$2'))} {(Lit_Other ']')}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:PRIVATEKEY)
                                          op: Equal
                                          rhs: {(DQ ('--private-key=') ($ VSub_Number '$2'))}
                                        )
                                      ]
                                    )
                                    (C {(shift)} {(2)})
                                  ]
                                )
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(Lit_Other '[')} {(DQ ($ VSub_Number '$1'))} 
                                          {(KW_Bang '!') (Lit_Other '=')} 
                                          {
                                            (DQ 
                                              (word_part.BracedVarSub
                                                token: <VSub_Number 1>
                                                suffix_op: 
                                                  (suffix_op.StringUnary
                                                    op_id: VOp1_Pound
                                                    arg_word: {('--private-key=')}
                                                  )
                                              )
                                            )
                                          } {(Lit_Other ']')}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:PRIVATEKEY)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ('--private-key=') 
                                                (word_part.BracedVarSub
                                                  token: <VSub_Number 1>
                                                  suffix_op: 
                                                    (suffix_op.StringUnary
                                                      op_id: VOp1_Pound
                                                      arg_word: {('--private-key=')}
                                                    )
                                                )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (C {(shift)} {(1)})
                                  ]
                                )
                              ]
                              else_action: [
                                (C {(error)} {(1)} {(NEEDARG)} {(DQ ('option requires an argument %s'))} 
                                  {(DQ ($ VSub_Number '$1'))}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--no-check-certificate)}]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:CHECKCERTIF)
                                  op: Equal
                                  rhs: {(DQ (--no-check-certificate))}
                                )
                              ]
                            )
                            (C {(shift)})
                          ]
                        )
                        (case_arm
                          pat_list: [{(-) (Lit_Other '*')}]
                          action: [
                            (C {(error)} {(1)} {(BADARG)} {(DQ ('unrecognized or invalid option %s'))} 
                              {(DQ ($ VSub_Number '$1'))}
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other '*')}]
                          action: [(command.ControlFlow token:<ControlFlow_Break break>)]
                        )
                      ]
                    )
                  ]
                )
            )
          ]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: 
                (C {(Lit_Other '[')} {(-n)} {(DQ ($ VSub_DollarName '$DISABLE_KEYRING'))} {(-a)} {(-n)} 
                  {(DQ ($ VSub_DollarName '$FORCE_KEYRING'))} {(Lit_Other ']')}
                )
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (C {(error)} {(1)} {(BADARG)} 
              {
                (DQ 
                  ('Both --no-check-gpg and --force-check-gpg specified, please pick one (at most)')
                )
              }
            )
          ]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: 
                (C {(Lit_Other '[')} {(DQ ($ VSub_DollarName '$SECOND_STAGE_ONLY'))} {(Lit_Other '=')} 
                  {(DQ (true))} {(Lit_Other ']')}
                )
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:SUITE)
                  op: Equal
                  rhs: 
                    {
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [(C {(cat)} {($ VSub_DollarName '$DEBOOTSTRAP_DIR') (/suite)})]
                          )
                        left_token: <Left_CommandSub '$('>
                      )
                    }
                )
              ]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:ARCH)
                  op: Equal
                  rhs: 
                    {
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [(C {(cat)} {($ VSub_DollarName '$DEBOOTSTRAP_DIR') (/arch)})]
                          )
                        left_token: <Left_CommandSub '$('>
                      )
                    }
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(Lit_Other '[')} {(-e)} {($ VSub_DollarName '$DEBOOTSTRAP_DIR') (/variant)} 
                          {(Lit_Other ']')}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:VARIANT)
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(cat)} {($ VSub_DollarName '$DEBOOTSTRAP_DIR') (/variant)})
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                              )
                            }
                        )
                      ]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:SUPPORTED_VARIANTS)
                          op: Equal
                          rhs: {(DQ ($ VSub_DollarName '$VARIANT'))}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(Lit_Other '[')} {(-z)} {(DQ ($ VSub_DollarName '$CHROOTDIR'))} 
                          {(Lit_Other ']')}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:TARGET) op:Equal rhs:{(/)})]
                    )
                  ]
                )
              ]
              else_action: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:TARGET)
                      op: Equal
                      rhs: {($ VSub_DollarName '$CHROOTDIR')}
                    )
                  ]
                )
              ]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:SCRIPT)
                  op: Equal
                  rhs: {($ VSub_DollarName '$DEBOOTSTRAP_DIR') (/suite-script)}
                )
              ]
            )
          ]
        )
      ]
      else_action: [
        (command.If
          arms: [
            (if_arm
              cond: [
                (command.Sentence
                  child: 
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(Lit_Other '[')} {(-z)} {(DQ ($ VSub_Number '$1'))} {(Lit_Other ']')})
                        (C {(Lit_Other '[')} {(-z)} {(DQ ($ VSub_Number '$2'))} {(Lit_Other ']')})
                      ]
                    )
                  terminator: <Op_Semi ';'>
                )
              ]
              action: [
                (C {(usage_err)} {(1)} {(NEEDSUITETARGET)} 
                  {(DQ ('You must specify a suite and a target.'))}
                )
              ]
            )
          ]
        )
        (command.Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (lhs_expr.LhsName name:SUITE)
              op: Equal
              rhs: {(DQ ($ VSub_Number '$1'))}
            )
          ]
        )
        (command.Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (lhs_expr.LhsName name:TARGET)
              op: Equal
              rhs: {(DQ ($ VSub_Number '$2'))}
            )
          ]
        )
        (command.Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (lhs_expr.LhsName name:USER_MIRROR)
              op: Equal
              rhs: {(DQ ($ VSub_Number '$3'))}
            )
          ]
        )
        (command.Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (lhs_expr.LhsName name:TARGET)
              op: Equal
              rhs: 
                {
                  (DQ 
                    (word_part.BracedVarSub
                      token: <VSub_Name TARGET>
                      suffix_op: (suffix_op.StringUnary op_id:VOp1_Percent arg_word:{(Lit_Slash /)})
                    )
                  )
                }
            )
          ]
        )
        (command.If
          arms: [
            (if_arm
              cond: [
                (command.Sentence
                  child: 
                    (C {(Lit_Other '[')} 
                      {
                        (DQ 
                          (word_part.BracedVarSub
                            token: <VSub_Name TARGET>
                            suffix_op: 
                              (suffix_op.StringUnary
                                op_id: VOp1_Pound
                                arg_word: {(Lit_Slash /)}
                              )
                          )
                        )
                      } {(Lit_Other '=')} {(DQ (${ VSub_Name TARGET))} {(Lit_Other ']')}
                    )
                  terminator: <Op_Semi ';'>
                )
              ]
              action: [
                (command.If
                  arms: [
                    (if_arm
                      cond: [
                        (command.Sentence
                          child: 
                            (C {(Lit_Other '[')} 
                              {
                                (DQ 
                                  (word_part.BracedVarSub
                                    token: <VSub_Name TARGET>
                                    suffix_op: 
                                      (suffix_op.StringUnary
                                        op_id: VOp1_Percent
                                        arg_word: {(Lit_Slash /) ('*')}
                                      )
                                  )
                                )
                              } {(Lit_Other '=')} {(DQ ($ VSub_DollarName '$TARGET'))} {(Lit_Other ']')}
                            )
                          terminator: <Op_Semi ';'>
                        )
                      ]
                      action: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:TARGET)
                              op: Equal
                              rhs: 
                                {
                                  (DQ 
                                    (word_part.CommandSubPart
                                      command_list: 
                                        (command.CommandList
                                          children: [
                                            (C {(echo)} 
                                              {
                                                (DQ 
                                                  (word_part.CommandSubPart
                                                    command_list: 
                                                      (command.CommandList
                                                        children: [(C {(pwd)})]
                                                      )
                                                    left_token: <Left_Backtick '`'>
                                                  ) (/) ($ VSub_DollarName '$TARGET')
                                                )
                                              }
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub '$('>
                                    )
                                  )
                                }
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  else_action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:TARGET)
                          op: Equal
                          rhs: 
                            {
                              (DQ 
                                (word_part.CommandSubPart
                                  command_list: 
                                    (command.CommandList
                                      children: [
                                        (command.Sentence
                                          child: 
                                            (C {(cd)} 
                                              {
                                                (DQ 
                                                  (word_part.BracedVarSub
                                                    token: <VSub_Name TARGET>
                                                    suffix_op: 
                                                      (suffix_op.StringUnary
                                                        op_id: VOp1_Percent
                                                        arg_word: {(Lit_Slash /) ('*')}
                                                      )
                                                  )
                                                )
                                              }
                                            )
                                          terminator: <Op_Semi ';'>
                                        )
                                        (C {(echo)} 
                                          {
                                            (DQ 
                                              (word_part.CommandSubPart
                                                command_list: 
                                                  (command.CommandList
                                                    children: [(C {(pwd)})]
                                                  )
                                                left_token: <Left_Backtick '`'>
                                              ) (/) 
                                              (word_part.BracedVarSub
                                                token: <VSub_Name TARGET>
                                                suffix_op: 
                                                  (suffix_op.StringUnary
                                                    op_id: VOp1_DPound
                                                    arg_word: {('*') (Lit_Slash /)}
                                                  )
                                              )
                                            )
                                          }
                                        )
                                      ]
                                    )
                                  left_token: <Left_CommandSub '$('>
                                )
                              )
                            }
                        )
                      ]
                    )
                  ]
                )
              ]
            )
          ]
        )
        (command.Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (lhs_expr.LhsName name:SCRIPT)
              op: Equal
              rhs: {(DQ ($ VSub_DollarName '$DEBOOTSTRAP_DIR') (/scripts/) ($ VSub_Number '$1'))}
            )
          ]
        )
        (command.If
          arms: [
            (if_arm
              cond: [
                (command.Sentence
                  child: 
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(Lit_Other '[')} {(-n)} {(DQ ($ VSub_DollarName '$VARIANT'))} 
                          {(Lit_Other ']')}
                        )
                        (C {(Lit_Other '[')} {(-e)} 
                          {(DQ (${ VSub_Name SCRIPT) (.) (${ VSub_Name VARIANT))} {(Lit_Other ']')}
                        )
                      ]
                    )
                  terminator: <Op_Semi ';'>
                )
              ]
              action: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:SCRIPT)
                      op: Equal
                      rhs: {(DQ (${ VSub_Name SCRIPT) (.) (${ VSub_Name VARIANT))}
                    )
                  ]
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:SUPPORTED_VARIANTS)
                      op: Equal
                      rhs: {(DQ ($ VSub_DollarName '$VARIANT'))}
                    )
                  ]
                )
              ]
            )
          ]
        )
        (command.If
          arms: [
            (if_arm
              cond: [
                (command.Sentence
                  child: 
                    (C {(Lit_Other '[')} {(DQ ($ VSub_Number '$4'))} {(KW_Bang '!') (Lit_Other '=')} {(DQ )} 
                      {(Lit_Other ']')}
                    )
                  terminator: <Op_Semi ';'>
                )
              ]
              action: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:SCRIPT)
                      op: Equal
                      rhs: {(DQ ($ VSub_Number '$4'))}
                    )
                  ]
                )
              ]
            )
          ]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: 
                (command.AndOr
                  ops: [Op_DAmp]
                  children: [
                    (C {(in_path)} {(dpkg)})
                    (command.SimpleCommand
                      words: [{(dpkg)} {(--print-architecture)}]
                      redirects: [
                        (redir.Redir
                          op: <Redir_Great '>'>
                          fd: 16777215
                          arg_word: {(/dev/null)}
                        )
                        (redir.Redir
                          op: <Redir_GreatAnd '2>&'>
                          fd: 2
                          arg_word: {(1)}
                        )
                      ]
                    )
                  ]
                )
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:HOST_ARCH)
                  op: Equal
                  rhs: 
                    {
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [(C {(/usr/bin/dpkg)} {(--print-architecture)})]
                          )
                        left_token: <Left_Backtick '`'>
                      )
                    }
                )
              ]
            )
          ]
        )
        (if_arm
          cond: [
            (command.Sentence
              child: 
                (command.AndOr
                  ops: [Op_DAmp]
                  children: [
                    (C {(in_path)} {(udpkg)})
                    (command.SimpleCommand
                      words: [{(udpkg)} {(--print-architecture)}]
                      redirects: [
                        (redir.Redir
                          op: <Redir_Great '>'>
                          fd: 16777215
                          arg_word: {(/dev/null)}
                        )
                        (redir.Redir
                          op: <Redir_GreatAnd '2>&'>
                          fd: 2
                          arg_word: {(1)}
                        )
                      ]
                    )
                  ]
                )
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:HOST_ARCH)
                  op: Equal
                  rhs: 
                    {
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [(C {(/usr/bin/udpkg)} {(--print-architecture)})]
                          )
                        left_token: <Left_Backtick '`'>
                      )
                    }
                )
              ]
            )
          ]
        )
        (if_arm
          cond: [
            (command.Sentence
              child: 
                (C {(Lit_Other '[')} {(-e)} {($ VSub_DollarName '$DEBOOTSTRAP_DIR') (/arch)} 
                  {(Lit_Other ']')}
                )
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:HOST_ARCH)
                  op: Equal
                  rhs: 
                    {
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [(C {(cat)} {($ VSub_DollarName '$DEBOOTSTRAP_DIR') (/arch)})]
                          )
                        left_token: <Left_Backtick '`'>
                      )
                    }
                )
              ]
            )
          ]
        )
      ]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:HOST_OS)
          op: Equal
          rhs: {(DQ ($ VSub_DollarName '$HOST_ARCH'))}
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: 
                (C {(Lit_Other '[')} {(-z)} {(DQ ($ VSub_DollarName '$HOST_OS'))} {(Lit_Other ']')})
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (command.Case
              to_match: 
                {
                  (word_part.CommandSubPart
                    command_list: (command.CommandList children:[(C {(uname)})])
                    left_token: <Left_Backtick '`'>
                  )
                }
              arms: [
                (case_arm
                  pat_list: [{(Linux)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:HOST_OS) op:Equal rhs:{(linux)})]
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(GNU/kFreeBSD)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:HOST_OS)
                          op: Equal
                          rhs: {(kfreebsd)}
                        )
                      ]
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(GNU)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:HOST_OS) op:Equal rhs:{(hurd)})]
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(FreeBSD) (Lit_Other '*')}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:HOST_OS)
                          op: Equal
                          rhs: {(freebsd)}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
          ]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: (C {(Lit_Other '[')} {(-z)} {(DQ ($ VSub_DollarName '$ARCH'))} {(Lit_Other ']')})
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:ARCH)
                  op: Equal
                  rhs: {($ VSub_DollarName '$HOST_ARCH')}
                )
              ]
            )
          ]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: 
                (command.AndOr
                  ops: [Op_DPipe]
                  children: [
                    (C {(Lit_Other '[')} {(-z)} {(DQ ($ VSub_DollarName '$ARCH'))} {(Lit_Other ']')})
                    (C {(Lit_Other '[')} {(-z)} {(DQ ($ VSub_DollarName '$HOST_OS'))} {(Lit_Other ']')})
                  ]
                )
              terminator: <Op_Semi ';'>
            )
          ]
          action: [(C {(error)} {(1)} {(WHATARCH)} {(DQ ("Couldn't work out current architecture"))})]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: 
                (command.AndOr
                  ops: [Op_DPipe]
                  children: [
                    (C {(Lit_Other '[')} {(DQ ($ VSub_DollarName '$HOST_OS'))} {(Lit_Other '=')} 
                      {(DQ (kfreebsd))} {(Lit_Other ']')}
                    )
                    (C {(Lit_Other '[')} {(DQ ($ VSub_DollarName '$HOST_OS'))} {(Lit_Other '=')} 
                      {(DQ (freebsd))} {(Lit_Other ']')}
                    )
                  ]
                )
              terminator: <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: [Op_DPipe]
                      children: [
                        (command.SimpleCommand
                          words: [{(kldstat)} {(-m)} {(DQ ($ VSub_DollarName '$module'))}]
                          redirects: [
                            (redir.Redir
                              op: <Redir_Great '>'>
                              fd: 16777215
                              arg_word: {(/dev/null)}
                            )
                            (redir.Redir
                              op: <Redir_GreatAnd '2>&'>
                              fd: 2
                              arg_word: {(1)}
                            )
                          ]
                        )
                        (C {(warning)} {(SANITYCHECK)} 
                          {(DQ ('Probably required module %s is not loaded'))} {(DQ ($ VSub_DollarName '$module'))}
                        )
                      ]
                    )
                  ]
                )
            )
          ]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: 
                (C {(Lit_Other '[')} {(DQ ($ VSub_DollarName '$TARGET'))} {(Lit_Other '=')} {(DQ (/))} 
                  {(Lit_Other ']')}
                )
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (command.Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(lhs_expr.LhsName name:CHROOT_CMD) op:Equal rhs:{(DQ )})]
            )
          ]
        )
      ]
      else_action: [
        (command.Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (lhs_expr.LhsName name:CHROOT_CMD)
              op: Equal
              rhs: {(DQ ('chroot ') ($ VSub_DollarName '$TARGET'))}
            )
          ]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: 
                (C {(Lit_Other '[')} {(-z)} {(DQ ($ VSub_DollarName '$SHA_SIZE'))} {(Lit_Other ']')})
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (command.Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(lhs_expr.LhsName name:SHA_SIZE) op:Equal rhs:{(256)})]
            )
          ]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: 
                (command.AndOr
                  ops: [Op_DAmp]
                  children: [
                    (command.Pipeline
                      children: [(C {(in_path)} {(DQ (sha) (${ VSub_Name SHA_SIZE) (sum))})]
                      negated: T
                    )
                    (command.Pipeline
                      children: [(C {(in_path)} {(DQ (sha) (${ VSub_Name SHA_SIZE))})]
                      negated: T
                    )
                  ]
                )
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (command.Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(lhs_expr.LhsName name:SHA_SIZE) op:Equal rhs:{(1)})]
            )
          ]
        )
      ]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:DEBOOTSTRAP_CHECKSUM_FIELD)
          op: Equal
          rhs: {(DQ (SHA) ($ VSub_DollarName '$SHA_SIZE'))}
        )
      ]
    )
    (C {(export)} {(ARCH)} {(SUITE)} {(TARGET)} {(CHROOT_CMD)} {(SHA_SIZE)} {(DEBOOTSTRAP_CHECKSUM_FIELD)})
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: (C {(am_doing_phase)} {(first_stage)} {(second_stage)})
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.AndOr
                          ops: [Op_DAmp]
                          children: [
                            (C {(in_path)} {(id)})
                            (C {(Lit_Other '[')} 
                              {
                                (word_part.CommandSubPart
                                  command_list: (command.CommandList children:[(C {(id)} {(-u)})])
                                  left_token: <Left_Backtick '`'>
                                )
                              } {(-ne)} {(0)} {(Lit_Other ']')}
                            )
                          ]
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [(C {(error)} {(1)} {(NEEDROOT)} {(DQ ('debootstrap can only run as root'))})]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.Pipeline
                          children: [(C {(check_sane_mount)} {(DQ ($ VSub_DollarName '$TARGET'))})]
                          negated: T
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(error)} {(1)} {(NOEXEC)} 
                      {
                        (DQ ("Cannot install into target '") ($ VSub_DollarName '$TARGET') 
                          ("' mounted with noexec or nodev")
                        )
                      }
                    )
                  ]
                )
              ]
            )
          ]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: 
                (C {(Lit_Other '[')} {(KW_Bang '!')} {(-e)} {(DQ ($ VSub_DollarName '$SCRIPT'))} 
                  {(Lit_Other ']')}
                )
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (C {(error)} {(1)} {(NOSCRIPT)} {(DQ ('No such script: %s'))} 
              {(DQ ($ VSub_DollarName '$SCRIPT'))}
            )
          ]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: 
                (C {(Lit_Other '[')} {(DQ ($ VSub_DollarName '$TARGET'))} 
                  {(KW_Bang '!') (Lit_Other '=')} {(DQ )} {(Lit_Other ']')}
                )
              terminator: <Op_Semi ';'>
            )
          ]
          action: [(C {(mkdir)} {(-p)} {(DQ ($ VSub_DollarName '$TARGET') (/debootstrap))})]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: 
                (C {(Lit_Other '[')} {(DQ ($ VSub_DollarName '$USE_DEBIANINSTALLER_INTERACTION'))} 
                  {(Lit_Other '=')} {(yes)} {(Lit_Other ']')}
                )
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (command.SimpleCommand
              words: [{(exec)}]
              redirects: [(redir.Redir op:<Redir_GreatAnd '4>&'> fd:4 arg_word:{(3)})]
            )
          ]
        )
        (if_arm
          cond: [
            (command.Sentence
              child: (C {(am_doing_phase)} {(printdebs)})
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (command.SimpleCommand
              words: [{(exec)}]
              redirects: [(redir.Redir op:<Redir_GreatAnd '4>&'> fd:4 arg_word:{(2)})]
            )
          ]
        )
      ]
      else_action: [
        (command.SimpleCommand
          words: [{(exec)}]
          redirects: [(redir.Redir op:<Redir_GreatAnd '4>&'> fd:4 arg_word:{(1)})]
        )
        (command.SimpleCommand
          words: [{(exec)}]
          redirects: [
            (redir.Redir
              op: <Redir_DGreat '>>'>
              fd: 16777215
              arg_word: {(DQ ($ VSub_DollarName '$TARGET') (/debootstrap/debootstrap.log))}
            )
          ]
        )
        (command.SimpleCommand
          words: [{(exec)}]
          redirects: [(redir.Redir op:<Redir_GreatAnd '2>&'> fd:2 arg_word:{(1)})]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: 
                (C {(Lit_Other '[')} {(DQ ($ VSub_DollarName '$UNPACK_TARBALL'))} {(Lit_Other ']')})
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(Lit_Other '[')} 
                          {
                            (DQ 
                              (word_part.BracedVarSub
                                token: <VSub_Name UNPACK_TARBALL>
                                suffix_op: 
                                  (suffix_op.StringUnary
                                    op_id: VOp1_Pound
                                    arg_word: {(Lit_Slash /)}
                                  )
                              )
                            )
                          } {(Lit_Other '=')} {(DQ ($ VSub_DollarName '$UNPACK_TARBALL'))} {(Lit_Other ']')}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(error)} {(1)} {(TARPATH)} {(DQ ('Tarball must be given a complete path'))})
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(Lit_Other '[')} 
                          {
                            (DQ 
                              (word_part.BracedVarSub
                                token: <VSub_Name UNPACK_TARBALL>
                                suffix_op: (suffix_op.StringUnary op_id:VOp1_Percent arg_word:{(.tar)})
                              )
                            )
                          } {(KW_Bang '!') (Lit_Other '=')} {(DQ ($ VSub_DollarName '$UNPACK_TARBALL'))} {(Lit_Other ']')}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.Subshell
                      command_list: 
                        (command.CommandList
                          children: [
                            (command.AndOr
                              ops: [Op_DAmp]
                              children: [
                                (C {(cd)} {(DQ ($ VSub_DollarName '$TARGET'))})
                                (C {(tar)} {(-xf)} {(DQ ($ VSub_DollarName '$UNPACK_TARBALL'))})
                              ]
                            )
                          ]
                        )
                    )
                  ]
                )
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(Lit_Other '[')} 
                          {
                            (DQ 
                              (word_part.BracedVarSub
                                token: <VSub_Name UNPACK_TARBALL>
                                suffix_op: (suffix_op.StringUnary op_id:VOp1_Percent arg_word:{(.tgz)})
                              )
                            )
                          } {(KW_Bang '!') (Lit_Other '=')} {(DQ ($ VSub_DollarName '$UNPACK_TARBALL'))} {(Lit_Other ']')}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.Subshell
                      command_list: 
                        (command.CommandList
                          children: [
                            (command.AndOr
                              ops: [Op_DAmp]
                              children: [
                                (C {(cd)} {(DQ ($ VSub_DollarName '$TARGET'))})
                                (command.Pipeline
                                  children: [
                                    (C {(zcat)} {(DQ ($ VSub_DollarName '$UNPACK_TARBALL'))})
                                    (C {(tar)} {(-xf)} {(-)})
                                  ]
                                  negated: F
                                )
                              ]
                            )
                          ]
                        )
                    )
                  ]
                )
              ]
              else_action: [
                (C {(error)} {(1)} {(NOTTAR)} {(DQ ('Unknown tarball: must be either .tar or .tgz'))})
              ]
            )
          ]
        )
      ]
    )
    (C {(.)} {(DQ ($ VSub_DollarName '$SCRIPT'))})
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: 
                (C {(Lit_Other '[')} {(DQ ($ VSub_DollarName '$SECOND_STAGE_ONLY'))} {(Lit_Other '=')} 
                  {(DQ (true))} {(Lit_Other ']')}
                )
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:MIRRORS)
                  op: Equal
                  rhs: {(null) (Lit_Other ':')}
                )
              ]
            )
          ]
        )
      ]
      else_action: [
        (command.Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (lhs_expr.LhsName name:MIRRORS)
              op: Equal
              rhs: {(DQ ($ VSub_DollarName '$DEF_MIRROR'))}
            )
          ]
        )
        (command.If
          arms: [
            (if_arm
              cond: [
                (command.Sentence
                  child: 
                    (C {(Lit_Other '[')} {(DQ ($ VSub_DollarName '$USER_MIRROR'))} 
                      {(KW_Bang '!') (Lit_Other '=')} {(DQ )} {(Lit_Other ']')}
                    )
                  terminator: <Op_Semi ';'>
                )
              ]
              action: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:MIRRORS)
                      op: Equal
                      rhs: {(DQ ($ VSub_DollarName '$USER_MIRROR'))}
                    )
                  ]
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:MIRRORS)
                      op: Equal
                      rhs: 
                        {
                          (DQ 
                            (word_part.BracedVarSub
                              token: <VSub_Name MIRRORS>
                              suffix_op: 
                                (suffix_op.StringUnary
                                  op_id: VOp1_Percent
                                  arg_word: {(Lit_Slash /)}
                                )
                            )
                          )
                        }
                    )
                  ]
                )
              ]
            )
          ]
        )
      ]
    )
    (C {(export)} {(MIRRORS)})
    (command.Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:ok) op:Equal rhs:{(false)})]
    )
    (command.ForEach
      iter_name: v
      iter_words: [{($ VSub_DollarName '$SUPPORTED_VARIANTS')}]
      do_arg_iter: F
      body: 
        (command.DoGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: (C {(doing_variant)} {($ VSub_DollarName '$v')})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.Sentence
                      child: 
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [(assign_pair lhs:(lhs_expr.LhsName name:ok) op:Equal rhs:{(true)})]
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: (command.Pipeline children:[(C {($ VSub_DollarName '$ok')})] negated:T)
              terminator: <Op_Semi ';'>
            )
          ]
          action: [(C {(error)} {(1)} {(UNSUPPVARIANT)} {(DQ ('unsupported variant'))})]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [(command.Sentence child:(C {(am_doing_phase)} {(finddebs)}) terminator:<Op_Semi ';'>)]
          action: [
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.AndOr
                          ops: [Op_DPipe]
                          children: [
                            (C {(Lit_Other '[')} {(DQ ($ VSub_DollarName '$FINDDEBS_NEEDS_INDICES'))} 
                              {(Lit_Other '=')} {(DQ (true))} {(Lit_Other ']')}
                            )
                            (C {(Lit_Other '[')} {(DQ ($ VSub_DollarName '$RESOLVE_DEPS'))} 
                              {(Lit_Other '=')} {(DQ (true))} {(Lit_Other ']')}
                            )
                          ]
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(download_indices)})
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:GOT_INDICES)
                          op: Equal
                          rhs: {(true)}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (C {(work_out_debs)})
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:base)
                  op: Equal
                  rhs: 
                    {
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {(without)} 
                                {
                                  (DQ ($ VSub_DollarName '$base') (' ') 
                                    ($ VSub_DollarName '$ADDITIONAL')
                                  )
                                } {(DQ ($ VSub_DollarName '$EXCLUDE'))}
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                      )
                    }
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(Lit_Other '[')} {(DQ ($ VSub_DollarName '$RESOLVE_DEPS'))} 
                          {(Lit_Other '=')} {(true)} {(Lit_Other ']')}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:requiredX)
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(echo)} 
                                        {
                                          (word_part.CommandSubPart
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (command.Pipeline
                                                    children: [
                                                      (C {(echo)} {($ VSub_DollarName '$required')})
                                                      (C {(tr)} {(SQ <' '>)} {(SQ <'\\n'>)})
                                                      (C {(sort)})
                                                      (C {(uniq)})
                                                    ]
                                                    negated: F
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub '$('>
                                          )
                                        }
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                              )
                            }
                        )
                      ]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:baseX)
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(echo)} 
                                        {
                                          (word_part.CommandSubPart
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (command.Pipeline
                                                    children: [
                                                      (C {(echo)} {($ VSub_DollarName '$base')})
                                                      (C {(tr)} {(SQ <' '>)} {(SQ <'\\n'>)})
                                                      (C {(sort)})
                                                      (C {(uniq)})
                                                    ]
                                                    negated: F
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub '$('>
                                          )
                                        }
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                              )
                            }
                        )
                      ]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:baseN)
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(without)} {(DQ ($ VSub_DollarName '$baseX'))} 
                                        {(DQ ($ VSub_DollarName '$requiredX'))}
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                              )
                            }
                        )
                      ]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:baseU)
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(without)} {(DQ ($ VSub_DollarName '$baseX'))} 
                                        {(DQ ($ VSub_DollarName '$baseN'))}
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                              )
                            }
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(Lit_Other '[')} {(DQ ($ VSub_DollarName '$baseU'))} 
                                  {(KW_Bang '!') (Lit_Other '=')} {(DQ )} {(Lit_Other ']')}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {(info)} {(REDUNDANTBASE)} 
                              {(DQ ('Found packages in base already in required: %s'))} {(DQ ($ VSub_DollarName '$baseU'))}
                            )
                          ]
                        )
                      ]
                    )
                    (C {(info)} {(RESOLVEREQ)} {(DQ ('Resolving dependencies of required packages...'))})
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:required)
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [(C {(resolve_deps)} {($ VSub_DollarName '$requiredX')})]
                                  )
                                left_token: <Left_CommandSub '$('>
                              )
                            }
                        )
                      ]
                    )
                    (C {(info)} {(RESOLVEBASE)} {(DQ ('Resolving dependencies of base packages...'))})
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:base)
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [(C {(resolve_deps)} {($ VSub_DollarName '$baseX')})]
                                  )
                                left_token: <Left_CommandSub '$('>
                              )
                            }
                        )
                      ]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:base)
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(without)} {(DQ ($ VSub_DollarName '$base'))} 
                                        {(DQ ($ VSub_DollarName '$required'))}
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                              )
                            }
                        )
                      ]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:requiredX)
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(without)} {(DQ ($ VSub_DollarName '$required'))} 
                                        {(DQ ($ VSub_DollarName '$requiredX'))}
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                              )
                            }
                        )
                      ]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:baseX)
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(without)} {(DQ ($ VSub_DollarName '$base'))} 
                                        {(DQ ($ VSub_DollarName '$baseX'))}
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                              )
                            }
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(Lit_Other '[')} {(DQ ($ VSub_DollarName '$requiredX'))} 
                                  {(KW_Bang '!') (Lit_Other '=')} {(DQ )} {(Lit_Other ']')}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {(info)} {(NEWREQUIRED)} 
                              {(DQ ('Found additional required dependencies: %s'))} {(DQ ($ VSub_DollarName '$requiredX'))}
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(Lit_Other '[')} {(DQ ($ VSub_DollarName '$baseX'))} 
                                  {(KW_Bang '!') (Lit_Other '=')} {(DQ )} {(Lit_Other ']')}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {(info)} {(NEWBASE)} {(DQ ('Found additional base dependencies: %s'))} 
                              {(DQ ($ VSub_DollarName '$baseX'))}
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:all_debs)
                  op: Equal
                  rhs: {(DQ ($ VSub_DollarName '$required') (' ') ($ VSub_DollarName '$base'))}
                )
              ]
            )
          ]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: (C {(am_doing_phase)} {(printdebs)})
              terminator: <Op_Semi ';'>
            )
          ]
          action: [(C {(echo)} {(DQ ($ VSub_DollarName '$all_debs'))})]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [(command.Sentence child:(C {(am_doing_phase)} {(dldebs)}) terminator:<Op_Semi ';'>)]
          action: [
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(Lit_Other '[')} {(DQ ($ VSub_DollarName '$GOT_INDICES'))} 
                          {(KW_Bang '!') (Lit_Other '=')} {(DQ (true))} {(Lit_Other ']')}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [(C {(download_indices)})]
                )
              ]
            )
            (C {(download)} {($ VSub_DollarName '$all_debs')})
          ]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: (C {(am_doing_phase)} {(maketarball)})
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (command.Subshell
              command_list: 
                (command.CommandList
                  children: [
                    (command.Sentence
                      child: (C {(cd)} {($ VSub_DollarName '$TARGET')})
                      terminator: <Op_Semi ';'>
                    )
                    (C {(tar)} {(czf)} {(-)} {(var/lib/apt)} {(var/cache/apt)})
                  ]
                )
              redirects: [
                (redir.Redir
                  op: <Redir_Great '>'>
                  fd: 16777215
                  arg_word: {($ VSub_DollarName '$MAKE_TARBALL')}
                )
              ]
            )
          ]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: (C {(am_doing_phase)} {(first_stage)})
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (C {(choose_extractor)})
            (C {(first_stage_install)})
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.Pipeline
                          children: [(C {(am_doing_phase)} {(second_stage)})]
                          negated: T
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(cp)} {(DQ ($ VSub_Number '$0'))} 
                      {(DQ ($ VSub_DollarName '$TARGET') (/debootstrap/debootstrap))}
                    )
                    (C {(cp)} {($ VSub_DollarName '$DEBOOTSTRAP_DIR') (/functions)} 
                      {(DQ ($ VSub_DollarName '$TARGET') (/debootstrap/functions))}
                    )
                    (C {(cp)} {($ VSub_DollarName '$SCRIPT')} 
                      {(DQ ($ VSub_DollarName '$TARGET') (/debootstrap/suite-script))}
                    )
                    (command.SimpleCommand
                      words: [{(echo)} {(DQ ($ VSub_DollarName '$ARCH'))}]
                      redirects: [
                        (redir.Redir
                          op: <Redir_Great '>'>
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_DollarName '$TARGET') (/debootstrap/arch))}
                        )
                      ]
                    )
                    (command.SimpleCommand
                      words: [{(echo)} {(DQ ($ VSub_DollarName '$SUITE'))}]
                      redirects: [
                        (redir.Redir
                          op: <Redir_Great '>'>
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_DollarName '$TARGET') (/debootstrap/suite))}
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(Lit_Other '[')} {(DQ )} {(Lit_Other '=')} 
                          {(DQ ($ VSub_DollarName '$VARIANT'))} {(Lit_Other ']')}
                        )
                        (command.SimpleCommand
                          words: [{(echo)} {(DQ ($ VSub_DollarName '$VARIANT'))}]
                          redirects: [
                            (redir.Redir
                              op: <Redir_Great '>'>
                              fd: 16777215
                              arg_word: {(DQ ($ VSub_DollarName '$TARGET') (/debootstrap/variant))}
                            )
                          ]
                        )
                      ]
                    )
                    (command.SimpleCommand
                      words: [{(echo)} {(DQ ($ VSub_DollarName '$required'))}]
                      redirects: [
                        (redir.Redir
                          op: <Redir_Great '>'>
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_DollarName '$TARGET') (/debootstrap/required))}
                        )
                      ]
                    )
                    (command.SimpleCommand
                      words: [{(echo)} {(DQ ($ VSub_DollarName '$base'))}]
                      redirects: [
                        (redir.Redir
                          op: <Redir_Great '>'>
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_DollarName '$TARGET') (/debootstrap/base))}
                        )
                      ]
                    )
                    (C {(chmod)} {(755)} {(DQ ($ VSub_DollarName '$TARGET') (/debootstrap/debootstrap))})
                  ]
                )
              ]
            )
          ]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: (C {(am_doing_phase)} {(second_stage)})
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(Lit_Other '[')} {(DQ ($ VSub_DollarName '$SECOND_STAGE_ONLY'))} 
                          {(Lit_Other '=')} {(true)} {(Lit_Other ']')}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:required)
                          op: Equal
                          rhs: 
                            {
                              (DQ 
                                (word_part.CommandSubPart
                                  command_list: 
                                    (command.CommandList
                                      children: [
                                        (C {(cat)} {($ VSub_DollarName '$DEBOOTSTRAP_DIR') (/required)})
                                      ]
                                    )
                                  left_token: <Left_CommandSub '$('>
                                )
                              )
                            }
                        )
                      ]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:base)
                          op: Equal
                          rhs: 
                            {
                              (DQ 
                                (word_part.CommandSubPart
                                  command_list: 
                                    (command.CommandList
                                      children: [
                                        (C {(cat)} {($ VSub_DollarName '$DEBOOTSTRAP_DIR') (/base)})
                                      ]
                                    )
                                  left_token: <Left_CommandSub '$('>
                                )
                              )
                            }
                        )
                      ]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:all_debs)
                          op: Equal
                          rhs: {(DQ ($ VSub_DollarName '$required') (' ') ($ VSub_DollarName '$base'))}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (C {(second_stage_install)})
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(Lit_Other '[')} {(-e)} 
                          {(DQ ($ VSub_DollarName '$TARGET') (/etc/apt/sources.list))} {(Lit_Other ']')}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(rm)} {(-f)} {(DQ ($ VSub_DollarName '$TARGET') (/etc/apt/sources.list))})
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(Lit_Other '[')} 
                          {
                            (DQ 
                              (word_part.BracedVarSub
                                token: <VSub_Name MIRRORS>
                                suffix_op: 
                                  (suffix_op.StringUnary
                                    op_id: VOp1_Pound
                                    arg_word: {('http:') (Lit_Slash /) (Lit_Slash /)}
                                  )
                              )
                            )
                          } {(KW_Bang '!') (Lit_Other '=')} {(DQ ($ VSub_DollarName '$MIRRORS'))} {(Lit_Other ']')}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(setup_apt_sources)} 
                      {
                        (DQ 
                          (word_part.BracedVarSub
                            token: <VSub_Name MIRRORS>
                            suffix_op: (suffix_op.StringUnary op_id:VOp1_DPercent arg_word:{(' *')})
                          )
                        )
                      }
                    )
                    (C {(mv_invalid_to)} 
                      {
                        (DQ 
                          (word_part.BracedVarSub
                            token: <VSub_Name MIRRORS>
                            suffix_op: (suffix_op.StringUnary op_id:VOp1_DPercent arg_word:{(' *')})
                          )
                        )
                      }
                    )
                  ]
                )
              ]
              else_action: [
                (C {(setup_apt_sources)} {(DQ ($ VSub_DollarName '$DEF_MIRROR'))})
                (C {(mv_invalid_to)} {(DQ ($ VSub_DollarName '$DEF_MIRROR'))})
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(Lit_Other '[')} {(-e)} 
                          {(DQ ($ VSub_DollarName '$TARGET') (/debootstrap/debootstrap.log))} {(Lit_Other ']')}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(Lit_Other '[')} {(DQ ($ VSub_DollarName '$KEEP_DEBOOTSTRAP_DIR'))} 
                                  {(Lit_Other '=')} {(true)} {(Lit_Other ']')}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {(cp)} 
                              {(DQ ($ VSub_DollarName '$TARGET') (/debootstrap/debootstrap.log))} {(DQ ($ VSub_DollarName '$TARGET') (/var/log/bootstrap.log))}
                            )
                          ]
                        )
                      ]
                      else_action: [
                        (C {(mv)} {(DQ ($ VSub_DollarName '$TARGET') (/debootstrap/debootstrap.log))} 
                          {(DQ ($ VSub_DollarName '$TARGET') (/var/log/bootstrap.log))}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (C {(sync)})
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(Lit_Other '[')} {(DQ ($ VSub_DollarName '$KEEP_DEBOOTSTRAP_DIR'))} 
                          {(Lit_Other '=')} {(true)} {(Lit_Other ']')}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (C {(Lit_Other '[')} {(-x)} 
                                  {(DQ ($ VSub_DollarName '$TARGET') (/debootstrap/debootstrap))} {(Lit_Other ']')}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (C {(chmod)} {(644)} 
                              {(DQ ($ VSub_DollarName '$TARGET') (/debootstrap/debootstrap))}
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
              ]
              else_action: [(C {(rm)} {(-rf)} {(DQ ($ VSub_DollarName '$TARGET') (/debootstrap))})]
            )
          ]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: (C {(am_doing_phase)} {(kill_target)})
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(Lit_Other '[')} {(DQ ($ VSub_DollarName '$KEEP_DEBOOTSTRAP_DIR'))} 
                          {(KW_Bang '!') (Lit_Other '=')} {(true)} {(Lit_Other ']')}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (C {(info)} {(KILLTARGET)} {(DQ ('Deleting target directory'))})
                    (C {(rm)} {(-rf)} {(DQ ($ VSub_DollarName '$TARGET'))})
                  ]
                )
              ]
            )
          ]
        )
      ]
    )
  ]
)