(CommandList
  children: [
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:OPTIONS_KEEPDASHDASH)
          op: Equal
          rhs: {(EmptyPart)}
          spids: [13]
        )
      ]
      spids: [13]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:OPTIONS_SPEC)
          op: Equal
          rhs: 
            {
              (DQ ('git repack [options]\n') ('--\n') 
                ('a               pack everything in a single pack\n') ('A               same as -a, and turn unreachable objects loose\n') 
                ('d               remove redundant packs, and run git-prune-packed\n') ('f               pass --no-reuse-delta to git-pack-objects\n') 
                ('F               pass --no-reuse-object to git-pack-objects\n') ('n               do not run git-update-server-info\n') ('q,quiet         be quiet\n') 
                ('l               pass --local to git-pack-objects\n') ('unpack-unreachable=  with -A, do not loosen objects older than this\n') (' Packing constraints\n') 
                ('window=         size of the window used for delta compression\n') ('window-memory=  same as the above, but limit memory size instead of entries count\n') 
                ('depth=          limits the maximum delta depth\n') ('max-pack-size=  maximum size of each packfile\n')
              )
            }
          spids: [15]
        )
      ]
      spids: [15]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:SUBDIRECTORY_OK) op:Equal rhs:{(SQ <Yes>)} spids:[36])]
      spids: [36]
    )
    (C {(.)} {(git-sh-setup)})
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair lhs:(LhsName name:no_update_info) op:Equal rhs:{(EmptyPart)} spids:[46])
        (assign_pair lhs:(LhsName name:all_into_one) op:Equal rhs:{(EmptyPart)} spids:[48])
        (assign_pair
          lhs: (LhsName name:remove_redundant)
          op: Equal
          rhs: {(EmptyPart)}
          spids: [50]
        )
        (assign_pair
          lhs: (LhsName name:unpack_unreachable)
          op: Equal
          rhs: {(EmptyPart)}
          spids: [52]
        )
      ]
      spids: [46]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair lhs:(LhsName name:local) op:Equal rhs:{(EmptyPart)} spids:[54])
        (assign_pair lhs:(LhsName name:no_reuse) op:Equal rhs:{(EmptyPart)} spids:[56])
        (assign_pair lhs:(LhsName name:extra) op:Equal rhs:{(EmptyPart)} spids:[58])
      ]
      spids: [54]
    )
    (While
      cond: [(C {(test)} {($ VSub_Pound '$#')} {(KW_Bang '!') (Lit_Other '=')} {(0)})]
      body: 
        (DoGroup
          children: [
            (Case
              to_match: {(DQ ($ VSub_Number '$1'))}
              arms: [
                (case_arm
                  pat_list: [{(-n)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:no_update_info)
                          op: Equal
                          rhs: {(t)}
                          spids: [86]
                        )
                      ]
                      spids: [86]
                    )
                  ]
                  spids: [83 84 89 16777215]
                )
                (case_arm
                  pat_list: [{(-a)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:all_into_one)
                          op: Equal
                          rhs: {(t)}
                          spids: [95]
                        )
                      ]
                      spids: [95]
                    )
                  ]
                  spids: [92 93 98 16777215]
                )
                (case_arm
                  pat_list: [{(-A)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:all_into_one)
                          op: Equal
                          rhs: {(t)}
                          spids: [104]
                        )
                      ]
                      spids: [104]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:unpack_unreachable)
                          op: Equal
                          rhs: {(--unpack-unreachable)}
                          spids: [108]
                        )
                      ]
                      spids: [108]
                    )
                  ]
                  spids: [101 102 111 16777215]
                )
                (case_arm
                  pat_list: [{(--unpack-unreachable)}]
                  action: [
                    (Sentence
                      child: 
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:unpack_unreachable)
                              op: Equal
                              rhs: {(DQ ('--unpack-unreachable=') ($ VSub_Number '$2'))}
                              spids: [118]
                            )
                          ]
                          spids: [118]
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (C {(shift)})
                  ]
                  spids: [114 115 127 16777215]
                )
                (case_arm
                  pat_list: [{(-d)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:remove_redundant)
                          op: Equal
                          rhs: {(t)}
                          spids: [133]
                        )
                      ]
                      spids: [133]
                    )
                  ]
                  spids: [130 131 136 16777215]
                )
                (case_arm
                  pat_list: [{(-q)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:GIT_QUIET)
                          op: Equal
                          rhs: {(t)}
                          spids: [142]
                        )
                      ]
                      spids: [142]
                    )
                  ]
                  spids: [139 140 145 16777215]
                )
                (case_arm
                  pat_list: [{(-f)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:no_reuse)
                          op: Equal
                          rhs: {(--no-reuse-delta)}
                          spids: [151]
                        )
                      ]
                      spids: [151]
                    )
                  ]
                  spids: [148 149 154 16777215]
                )
                (case_arm
                  pat_list: [{(-F)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:no_reuse)
                          op: Equal
                          rhs: {(--no-reuse-object)}
                          spids: [160]
                        )
                      ]
                      spids: [160]
                    )
                  ]
                  spids: [157 158 163 16777215]
                )
                (case_arm
                  pat_list: [{(-l)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:local)
                          op: Equal
                          rhs: {(--local)}
                          spids: [169]
                        )
                      ]
                      spids: [169]
                    )
                  ]
                  spids: [166 167 172 16777215]
                )
                (case_arm
                  pat_list: [{(--max-pack-size)} {(--window)} {(--window-memory)} {(--depth)}]
                  action: [
                    (Sentence
                      child: 
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:extra)
                              op: Equal
                              rhs: 
                                {
                                  (DQ ($ VSub_Name '$extra') (' ') ($ VSub_Number '$1') ('=') 
                                    ($ VSub_Number '$2')
                                  )
                                }
                              spids: [185]
                            )
                          ]
                          spids: [185]
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (C {(shift)})
                  ]
                  spids: [175 182 197 16777215]
                )
                (case_arm
                  pat_list: [{(--)}]
                  action: [
                    (Sentence child:(C {(shift)}) terminator:<Op_Semi ';'>)
                    (ControlFlow token:<ControlFlow_Break break>)
                  ]
                  spids: [200 201 207 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [(C {(usage)})]
                  spids: [210 211 215 16777215]
                )
              ]
              spids: [74 80 218]
            )
            (C {(shift)})
          ]
          spids: [71 223]
        )
    )
    (Case
      to_match: 
        {
          (DQ 
            (CommandSubPart
              command_list: 
                (CommandList
                  children: [
                    (AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(git)} {(config)} {(--bool)} {(repack.usedeltabaseoffset)})
                        (C {(echo)} {(true)})
                      ]
                    )
                  ]
                )
              left_token: <Left_CommandSub '$('>
              spids: [229 243]
            )
          )
        }
      arms: [
        (case_arm
          pat_list: [{(true)}]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:extra)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name '$extra') (' --delta-base-offset'))}
                  spids: [252]
                )
              ]
              spids: [252]
            )
          ]
          spids: [248 249 258 16777215]
        )
      ]
      spids: [226 246 260]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:PACKDIR)
          op: Equal
          rhs: {(DQ ($ VSub_Name '$GIT_OBJECT_DIRECTORY') (/pack))}
          spids: [263]
        )
      ]
      spids: [263]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:PACKTMP)
          op: Equal
          rhs: {(DQ ($ VSub_Name '$PACKDIR') (/.tmp-) ($ VSub_Dollar '$$') (-pack))}
          spids: [269]
        )
      ]
      spids: [269]
    )
    (C {(rm)} {(-f)} {(DQ ($ VSub_Name '$PACKTMP')) (-) (Lit_Other '*')})
    (C {(trap)} {(SQ <'rm -f "$PACKTMP"-*'>)} {(0)} {(1)} {(2)} {(3)} {(15)})
    (Case
      to_match: {(DQ (',') ($ VSub_Name '$all_into_one') (','))}
      arms: [
        (case_arm
          pat_list: [{(Lit_Comma ',') (Lit_Comma ',')}]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:args)
                  op: Equal
                  rhs: {(SQ <'--unpacked --incremental'>)}
                  spids: [322]
                )
              ]
              spids: [322]
            )
          ]
          spids: [317 319 328 16777215]
        )
        (case_arm
          pat_list: [{(Lit_Comma ',') (t) (Lit_Comma ',')}]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:args)
                  op: Equal
                  rhs: {(EmptyPart)}
                  spids: [336]
                )
                (assign_pair
                  lhs: (LhsName name:existing)
                  op: Equal
                  rhs: {(EmptyPart)}
                  spids: [338]
                )
              ]
              spids: [336]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other '[')} {(-d)} {(DQ ($ VSub_Name '$PACKDIR'))} {(Lit_Other ']')})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (ForEach
                      iter_name: e
                      iter_words: [
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (AndOr
                                    ops: [Op_DAmp]
                                    children: [
                                      (C {(cd)} {(DQ ($ VSub_Name '$PACKDIR'))})
                                      (Pipeline
                                        children: [
                                          (C {(find)} {(.)} {(-type)} {(f)} {(-name)} {(SQ <'*.pack'>)})
                                          (C {(sed)} {(-e)} {(SQ <'s/^\\.\\///'>)} {(-e)} 
                                            {(SQ <'s/\\.pack$//'>)}
                                          )
                                        ]
                                        negated: F
                                      )
                                    ]
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [363 403]
                          )
                        }
                      ]
                      do_arg_iter: F
                      body: 
                        (DoGroup
                          children: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(Lit_Other '[')} {(-e)} 
                                          {
                                            (DQ ($ VSub_Name '$PACKDIR') (/) ($ VSub_Name '$e') (.keep))
                                          } {(Lit_Other ']')}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [(C {(Lit_Other ':')} {(keep)})]
                                  spids: [16777215 425]
                                )
                              ]
                              else_action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:existing)
                                      op: Equal
                                      rhs: {(DQ ($ VSub_Name '$existing') (' ') ($ VSub_Name '$e'))}
                                      spids: [436]
                                    )
                                  ]
                                  spids: [436]
                                )
                              ]
                              spids: [433 444]
                            )
                          ]
                          spids: [406 447]
                        )
                      spids: [362 16777215]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (AndOr
                              ops: [Op_DAmp Op_DAmp]
                              children: [
                                (C {(test)} {(-n)} {(DQ ($ VSub_Name '$existing'))})
                                (C {(test)} {(-n)} {(DQ ($ VSub_Name '$unpack_unreachable'))})
                                (C {(test)} {(-n)} {(DQ ($ VSub_Name '$remove_redundant'))})
                              ]
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:args)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ ($ VSub_Name '$args') (' ') 
                                        (CommandSubPart
                                          command_list: 
                                            (CommandList
                                              children: [
                                                (Pipeline
                                                  children: [
                                                    (C {(echo)} 
                                                      {(DQ ($ VSub_Name '$unpack_unreachable'))}
                                                    )
                                                    (C {(tr)} {(SQ <' '>)} {(.)})
                                                  ]
                                                  negated: F
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                          spids: [510 526]
                                        )
                                      )
                                    }
                                  spids: [506]
                                )
                              ]
                              spids: [506]
                            )
                          ]
                          spids: [16777215 483]
                        )
                      ]
                      spids: [16777215 530]
                    )
                  ]
                  spids: [16777215 354]
                )
              ]
              spids: [16777215 533]
            )
          ]
          spids: [330 333 536 16777215]
        )
      ]
      spids: [307 315 538]
    )
    (AndOr
      ops: [Op_DPipe]
      children: [
        (C {(mkdir)} {(-p)} {(DQ ($ VSub_Name '$PACKDIR'))})
        (ControlFlow token:<ControlFlow_Exit exit>)
      ]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:args)
          op: Equal
          rhs: 
            {
              (DQ ($ VSub_Name '$args') (' ') ($ VSub_Name '$local') (' ') 
                (BracedVarSub
                  token: <VSub_Name GIT_QUIET>
                  suffix_op: (StringUnary op_id:VTest_ColonPlus arg_word:{(-q)})
                  spids: [560 564]
                ) (' ') ($ VSub_Name '$no_reuse') ($ VSub_Name '$extra')
              )
            }
          spids: [554]
        )
      ]
      spids: [554]
    )
    (AndOr
      ops: [Op_DPipe]
      children: [
        (Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (LhsName name:names)
              op: Equal
              rhs: 
                {
                  (CommandSubPart
                    command_list: 
                      (CommandList
                        children: [
                          (SimpleCommand
                            words: [
                              {(git)}
                              {(pack-objects)}
                              {(--keep-true-parents)}
                              {(--honor-pack-keep)}
                              {(--non-empty)}
                              {(--all)}
                              {(--reflog)}
                              {($ VSub_Name '$args')}
                              {(DQ ($ VSub_Name '$PACKTMP'))}
                            ]
                            redirects: [
                              (Redir
                                op_id: Redir_Less
                                fd: 16777215
                                arg_word: {(/dev/null)}
                                spids: [588]
                              )
                            ]
                          )
                        ]
                      )
                    left_token: <Left_CommandSub '$('>
                    spids: [571 594]
                  )
                }
              spids: [570]
            )
          ]
          spids: [570]
        )
        (ControlFlow token:<ControlFlow_Exit exit> arg_word:{(1)})
      ]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: (C {(Lit_Other '[')} {(-z)} {(DQ ($ VSub_Name '$names'))} {(Lit_Other ']')})
              terminator: <Op_Semi ';'>
            )
          ]
          action: [(C {(say)} {(Nothing)} {(new)} {(to)} {(pack.)})]
          spids: [16777215 616]
        )
      ]
      spids: [16777215 629]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:rollback) op:Equal rhs:{(EmptyPart)} spids:[645])]
      spids: [645]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:failed) op:Equal rhs:{(EmptyPart)} spids:[647])]
      spids: [647]
    )
    (ForEach
      iter_name: name
      iter_words: [{($ VSub_Name '$names')}]
      do_arg_iter: F
      body: 
        (DoGroup
          children: [
            (ForEach
              iter_name: sfx
              iter_words: [{(pack)} {(idx)}]
              do_arg_iter: F
              body: 
                (DoGroup
                  children: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:file)
                          op: Equal
                          rhs: {(pack-) ($ VSub_Name '$name') (.) ($ VSub_Name '$sfx')}
                          spids: [674]
                        )
                      ]
                      spids: [674]
                    )
                    (AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(test)} {(-f)} {(DQ ($ VSub_Name '$PACKDIR') (/) ($ VSub_Name '$file'))})
                        (ControlFlow token:<ControlFlow_Continue continue>)
                      ]
                    )
                    (AndOr
                      ops: [Op_DAmp Op_DPipe]
                      children: [
                        (C {(rm)} {(-f)} {(DQ ($ VSub_Name '$PACKDIR') (/old-) ($ VSub_Name '$file'))})
                        (C {(mv)} {(DQ ($ VSub_Name '$PACKDIR') (/) ($ VSub_Name '$file'))} 
                          {(DQ ($ VSub_Name '$PACKDIR') (/old-) ($ VSub_Name '$file'))}
                        )
                        (BraceGroup
                          children: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:failed)
                                  op: Equal
                                  rhs: {(t)}
                                  spids: [728]
                                )
                              ]
                              spids: [728]
                            )
                            (ControlFlow token:<ControlFlow_Break break>)
                          ]
                          spids: [725]
                        )
                      ]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:rollback)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name '$rollback') (' ') ($ VSub_Name '$file'))}
                          spids: [738]
                        )
                      ]
                      spids: [738]
                    )
                  ]
                  spids: [671 746]
                )
              spids: [665 16777215]
            )
            (AndOr
              ops: [Op_DPipe]
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_Name '$failed'))})
                (ControlFlow token:<ControlFlow_Break break>)
              ]
            )
          ]
          spids: [657 761]
        )
      spids: [654 16777215]
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name '$failed'))})]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:rollback_failure)
                  op: Equal
                  rhs: {(EmptyPart)}
                  spids: [783]
                )
              ]
              spids: [783]
            )
            (ForEach
              iter_name: file
              iter_words: [{($ VSub_Name '$rollback')}]
              do_arg_iter: F
              body: 
                (DoGroup
                  children: [
                    (AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(mv)} {(DQ ($ VSub_Name '$PACKDIR') (/old-) ($ VSub_Name '$file'))} 
                          {(DQ ($ VSub_Name '$PACKDIR') (/) ($ VSub_Name '$file'))}
                        )
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:rollback_failure)
                              op: Equal
                              rhs: {(DQ ($ VSub_Name '$rollback_failure') (' ') ($ VSub_Name '$file'))}
                              spids: [815]
                            )
                          ]
                          spids: [815]
                        )
                      ]
                    )
                  ]
                  spids: [795 823]
                )
              spids: [791 16777215]
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name '$rollback_failure'))})]
                  action: [
                    (SimpleCommand
                      words: [{(echo)} {(DQ ('WARNING: Some packs in use have been renamed by'))}]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:16777215 arg_word:{(2)} spids:[842])]
                    )
                    (SimpleCommand
                      words: [{(echo)} {(DQ ('WARNING: prefixing old- to their name, in order to'))}]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:16777215 arg_word:{(2)} spids:[852])]
                    )
                    (SimpleCommand
                      words: [{(echo)} {(DQ ('WARNING: replace them with the new version of the'))}]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:16777215 arg_word:{(2)} spids:[862])]
                    )
                    (SimpleCommand
                      words: [{(echo)} {(DQ ('WARNING: file.  But the operation failed, and'))}]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:16777215 arg_word:{(2)} spids:[872])]
                    )
                    (SimpleCommand
                      words: [{(echo)} {(DQ ('WARNING: attempt to rename them back to their'))}]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:16777215 arg_word:{(2)} spids:[882])]
                    )
                    (SimpleCommand
                      words: [{(echo)} {(DQ ('WARNING: original names also failed.'))}]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:16777215 arg_word:{(2)} spids:[892])]
                    )
                    (SimpleCommand
                      words: [
                        {(echo)}
                        {
                          (DQ ('WARNING: Please rename them in ') ($ VSub_Name '$PACKDIR') 
                            (' manually:')
                          )
                        }
                      ]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:16777215 arg_word:{(2)} spids:[902])]
                    )
                    (ForEach
                      iter_name: file
                      iter_words: [{($ VSub_Name '$rollback_failure')}]
                      do_arg_iter: F
                      body: 
                        (DoGroup
                          children: [
                            (SimpleCommand
                              words: [
                                {(echo)}
                                {
                                  (DQ ('WARNING:   old-') ($ VSub_Name '$file') (' -> ') 
                                    ($ VSub_Name '$file')
                                  )
                                }
                              ]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: 16777215
                                  arg_word: {(2)}
                                  spids: [926]
                                )
                              ]
                            )
                          ]
                          spids: [921 937]
                        )
                      spids: [917 16777215]
                    )
                  ]
                  spids: [16777215 837]
                )
              ]
              spids: [16777215 940]
            )
            (ControlFlow token:<ControlFlow_Exit exit> arg_word:{(1)})
          ]
          spids: [16777215 780]
        )
      ]
      spids: [16777215 947]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:fullbases) op:Equal rhs:{(EmptyPart)} spids:[953])]
      spids: [953]
    )
    (ForEach
      iter_name: name
      iter_words: [{($ VSub_Name '$names')}]
      do_arg_iter: F
      body: 
        (DoGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:fullbases)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name '$fullbases') (' pack-') ($ VSub_Name '$name'))}
                  spids: [966]
                )
              ]
              spids: [966]
            )
            (C {(chmod)} {(a-w)} {(DQ ($ VSub_Name '$PACKTMP') (-) ($ VSub_Name '$name') (.pack))})
            (C {(chmod)} {(a-w)} {(DQ ($ VSub_Name '$PACKTMP') (-) ($ VSub_Name '$name') (.idx))})
            (AndOr
              ops: [Op_DAmp Op_DPipe]
              children: [
                (C {(mv)} {(-f)} {(DQ ($ VSub_Name '$PACKTMP') (-) ($ VSub_Name '$name') (.pack))} 
                  {(DQ ($ VSub_Name '$PACKDIR') (/pack-) ($ VSub_Name '$name') (.pack))}
                )
                (C {(mv)} {(-f)} {(DQ ($ VSub_Name '$PACKTMP') (-) ($ VSub_Name '$name') (.idx))} 
                  {(DQ ($ VSub_Name '$PACKDIR') (/pack-) ($ VSub_Name '$name') (.idx))}
                )
                (ControlFlow token:<ControlFlow_Exit exit>)
              ]
            )
          ]
          spids: [963 1042]
        )
      spids: [960 16777215]
    )
    (ForEach
      iter_name: name
      iter_words: [{($ VSub_Name '$names')}]
      do_arg_iter: F
      body: 
        (DoGroup
          children: [
            (C {(rm)} {(-f)} {(DQ ($ VSub_Name '$PACKDIR') (/old-pack-) ($ VSub_Name '$name') (.idx))})
            (C {(rm)} {(-f)} {(DQ ($ VSub_Name '$PACKDIR') (/old-pack-) ($ VSub_Name '$name') (.pack))})
          ]
          spids: [1056 1082]
        )
      spids: [1053 16777215]
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(DQ ($ VSub_Name '$remove_redundant'))} {(Lit_Other '=')} {(t)})]
          action: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (C {(Lit_Other '[')} {(-n)} {(DQ ($ VSub_Name '$existing'))} {(Lit_Other ']')})
                  ]
                  action: [
                    (Subshell
                      child: 
                        (AndOr
                          ops: [Op_DAmp]
                          children: [
                            (C {(cd)} {(DQ ($ VSub_Name '$PACKDIR'))})
                            (ForEach
                              iter_name: e
                              iter_words: [{($ VSub_Name '$existing')}]
                              do_arg_iter: F
                              body: 
                                (DoGroup
                                  children: [
                                    (Case
                                      to_match: {(DQ (' ') ($ VSub_Name '$fullbases') (' '))}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(Lit_Other '*') (DQ (' ') ($ VSub_Name '$e') (' ')) 
                                              (Lit_Other '*')
                                            }
                                          ]
                                          spids: [1158 1165 1167 16777215]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other '*')}]
                                          action: [
                                            (C {(rm)} {(-f)} {(DQ ($ VSub_Name '$e') (.pack))} 
                                              {(DQ ($ VSub_Name '$e') (.idx))} {(DQ ($ VSub_Name '$e') (.keep))}
                                            )
                                          ]
                                          spids: [1170 1171 1192 16777215]
                                        )
                                      ]
                                      spids: [1147 1155 1195]
                                    )
                                  ]
                                  spids: [1144 1198]
                                )
                              spids: [1140 16777215]
                            )
                          ]
                        )
                      spids: [1124 1201]
                    )
                  ]
                  spids: [16777215 1121]
                )
              ]
              spids: [16777215 1204]
            )
            (C {(git)} {(prune-packed)} 
              {
                (BracedVarSub
                  token: <VSub_Name GIT_QUIET>
                  suffix_op: (StringUnary op_id:VTest_ColonPlus arg_word:{(-q)})
                  spids: [1211 1215]
                )
              }
            )
          ]
          spids: [16777215 1101]
        )
      ]
      spids: [16777215 1217]
    )
    (Case
      to_match: {(DQ ($ VSub_Name '$no_update_info'))}
      arms: [
        (case_arm
          pat_list: [{(t)}]
          action: [(C {(Lit_Other ':')})]
          spids: [1228 1229 1233 16777215]
        )
        (case_arm
          pat_list: [{(Lit_Other '*')}]
          action: [(C {(git)} {(update-server-info)})]
          spids: [1235 1236 1242 16777215]
        )
      ]
      spids: [1220 1226 1244]
    )
  ]
)