(CommandList
  children: [
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:USAGE)
          op: Equal
          rhs: {(SQ <'<fetch-options> <repository> <refspec>...'>)}
          spids: [7]
        )
      ]
      spids: [7]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:SUBDIRECTORY_OK) op:Equal rhs:{(Yes)} spids:[12])]
      spids: [12]
    )
    (C {(.)} {(git-sh-setup)})
    (C {(set_reflog_action)} {(DQ ('fetch ') ($ VSub_Star '$*'))})
    (Sentence child:(C {(cd_to_toplevel)}) terminator:<Op_Semi ';'>)
    (C {(.)} {(git-parse-remote)})
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:_x40)
          op: Equal
          rhs: {(SQ <'[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]'>)}
          spids: [37]
        )
      ]
      spids: [37]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:_x40)
          op: Equal
          rhs: 
            {
              (DQ ($ VSub_Name '$_x40') ($ VSub_Name '$_x40') ($ VSub_Name '$_x40') 
                ($ VSub_Name '$_x40') ($ VSub_Name '$_x40') ($ VSub_Name '$_x40') ($ VSub_Name '$_x40') ($ VSub_Name '$_x40')
              )
            }
          spids: [42]
        )
      ]
      spids: [42]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:LF) op:Equal rhs:{(SQ <'\n'>)} spids:[55])]
      spids: [55]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:IFS) op:Equal rhs:{(DQ ($ VSub_Name '$LF'))} spids:[60])]
      spids: [60]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:no_tags) op:Equal rhs:{(EmptyPart)} spids:[66])]
      spids: [66]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:tags) op:Equal rhs:{(EmptyPart)} spids:[68])]
      spids: [68]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:append) op:Equal rhs:{(EmptyPart)} spids:[70])]
      spids: [70]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:force) op:Equal rhs:{(EmptyPart)} spids:[72])]
      spids: [72]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:verbose) op:Equal rhs:{(EmptyPart)} spids:[74])]
      spids: [74]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:update_head_ok) op:Equal rhs:{(EmptyPart)} spids:[76])]
      spids: [76]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:exec) op:Equal rhs:{(EmptyPart)} spids:[78])]
      spids: [78]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:keep) op:Equal rhs:{(EmptyPart)} spids:[80])]
      spids: [80]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:shallow_depth) op:Equal rhs:{(EmptyPart)} spids:[82])]
      spids: [82]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:no_progress) op:Equal rhs:{(EmptyPart)} spids:[84])]
      spids: [84]
    )
    (AndOr
      ops: [Op_DPipe]
      children: [
        (C {(test)} {(-t)} {(1)})
        (Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (LhsName name:no_progress)
              op: Equal
              rhs: {(--no-progress)}
              spids: [94]
            )
          ]
          spids: [94]
        )
      ]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:quiet) op:Equal rhs:{(EmptyPart)} spids:[97])]
      spids: [97]
    )
    (WhileUntil
      keyword: <KW_While 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: [{(-a)} {(--a)} {(--ap)} {(--app)} {(--appe)} {(--appen)} {(--append)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(LhsName name:append) op:Equal rhs:{(t)} spids:[138])]
                      spids: [138]
                    )
                  ]
                  spids: [122 135 142 16777215]
                )
                (case_arm
                  pat_list: [
                    {(--upl)}
                    {(--uplo)}
                    {(--uploa)}
                    {(--upload)}
                    {(--upload-)}
                    {(--upload-p)}
                    {(--upload-pa)}
                    {(--upload-pac)}
                    {(--upload-pack)}
                  ]
                  action: [
                    (C {(shift)})
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:exec)
                          op: Equal
                          rhs: {(DQ ('--upload-pack=') ($ VSub_Number '$1'))}
                          spids: [170]
                        )
                      ]
                      spids: [170]
                    )
                  ]
                  spids: [145 164 177 16777215]
                )
                (case_arm
                  pat_list: [
                    {(--upl) (Lit_Other '=') (Lit_Other '*')}
                    {(--uplo) (Lit_Other '=') (Lit_Other '*')}
                    {(--uploa) (Lit_Other '=') (Lit_Other '*')}
                    {(--upload) (Lit_Other '=') (Lit_Other '*')}
                    {(--upload-) (Lit_Other '=') (Lit_Other '*')}
                    {(--upload-p) (Lit_Other '=') (Lit_Other '*')}
                    {(--upload-pa) (Lit_Other '=') (Lit_Other '*')}
                    {(--upload-pac) (Lit_Other '=') (Lit_Other '*')}
                    {(--upload-pack) (Lit_Other '=') (Lit_Other '*')}
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:exec)
                          op: Equal
                          rhs: 
                            {(--upload-pack) (Lit_Other '=') 
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(expr)} {(DQ (z) ($ VSub_Number '$1'))} {(Lit_Other ':')} 
                                        {(SQ <'z-[^=]*=\\(.*\\)'>)}
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [223 236]
                              )
                            }
                          spids: [220]
                        )
                      ]
                      spids: [220]
                    )
                    (C {(shift)})
                  ]
                  spids: [180 217 242 16777215]
                )
                (case_arm
                  pat_list: [{(-f)} {(--f)} {(--fo)} {(--for)} {(--forc)} {(--force)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(LhsName name:force) op:Equal rhs:{(t)} spids:[259])]
                      spids: [259]
                    )
                  ]
                  spids: [245 256 263 16777215]
                )
                (case_arm
                  pat_list: [{(-t)} {(--t)} {(--ta)} {(--tag)} {(--tags)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(LhsName name:tags) op:Equal rhs:{(t)} spids:[278])]
                      spids: [278]
                    )
                  ]
                  spids: [266 275 282 16777215]
                )
                (case_arm
                  pat_list: [
                    {(-n)}
                    {(--n)}
                    {(--no)}
                    {(--no-)}
                    {(--no-t)}
                    {(--no-ta)}
                    {(--no-tag)}
                    {(--no-tags)}
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(LhsName name:no_tags) op:Equal rhs:{(t)} spids:[303])]
                      spids: [303]
                    )
                  ]
                  spids: [285 300 307 16777215]
                )
                (case_arm
                  pat_list: [
                    {(-u)}
                    {(--u)}
                    {(--up)}
                    {(--upd)}
                    {(--upda)}
                    {(--updat)}
                    {(--update)}
                    {(--update-)}
                    {(--update-h)}
                    {(--update-he)}
                    {(--update-hea)}
                    {(--update-head)}
                    {(--update-head-)}
                    {(--update-head-o)}
                    {(--update-head-ok)}
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:update_head_ok)
                          op: Equal
                          rhs: {(t)}
                          spids: [346]
                        )
                      ]
                      spids: [346]
                    )
                  ]
                  spids: [310 343 350 16777215]
                )
                (case_arm
                  pat_list: [{(-q)} {(--q)} {(--qu)} {(--qui)} {(--quie)} {(--quiet)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:quiet)
                          op: Equal
                          rhs: {(--quiet)}
                          spids: [367]
                        )
                      ]
                      spids: [367]
                    )
                  ]
                  spids: [353 364 371 16777215]
                )
                (case_arm
                  pat_list: [{(-v)} {(--verbose)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:verbose)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name '$verbose')) (Yes)}
                          spids: [380]
                        )
                      ]
                      spids: [380]
                    )
                  ]
                  spids: [374 377 387 16777215]
                )
                (case_arm
                  pat_list: [{(-k)} {(--k)} {(--ke)} {(--kee)} {(--keep)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:keep)
                          op: Equal
                          rhs: {(SQ <'-k -k'>)}
                          spids: [402]
                        )
                      ]
                      spids: [402]
                    )
                  ]
                  spids: [390 399 408 16777215]
                )
                (case_arm
                  pat_list: [{(--depth) (Lit_Other '=') (Lit_Other '*')}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:shallow_depth)
                          op: Equal
                          rhs: 
                            {
                              (DQ ('--depth=') 
                                (CommandSubPart
                                  command_list: 
                                    (CommandList
                                      children: [
                                        (C {(expr)} {(DQ (z) ($ VSub_Number '$1'))} {(Lit_Other ':')} 
                                          {(SQ <'z-[^=]*=\\(.*\\)'>)}
                                        )
                                      ]
                                    )
                                  left_token: <Left_CommandSub '$('>
                                  spids: [420 433]
                                )
                              )
                            }
                          spids: [417]
                        )
                      ]
                      spids: [417]
                    )
                  ]
                  spids: [411 414 437 16777215]
                )
                (case_arm
                  pat_list: [{(--depth)}]
                  action: [
                    (C {(shift)})
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:shallow_depth)
                          op: Equal
                          rhs: {(DQ ('--depth=') ($ VSub_Number '$1'))}
                          spids: [447]
                        )
                      ]
                      spids: [447]
                    )
                  ]
                  spids: [440 441 454 16777215]
                )
                (case_arm
                  pat_list: [{(-) (Lit_Other '*')}]
                  action: [(C {(usage)})]
                  spids: [457 459 465 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [(ControlFlow token:<ControlFlow_Break break>)]
                  spids: [468 469 475 16777215]
                )
              ]
              spids: [113 119 478]
            )
            (C {(shift)})
          ]
          spids: [110 483]
        )
    )
    (Case
      to_match: {(DQ ($ VSub_Pound '$#'))}
      arms: [
        (case_arm
          pat_list: [{(0)}]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:origin)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: (CommandList children:[(C {(get_default_remote)})])
                        left_token: <Left_CommandSub '$('>
                        spids: [499 501]
                      )
                    }
                  spids: [498]
                )
              ]
              spids: [498]
            )
            (AndOr
              ops: [Op_DPipe]
              children: [
                (C {(test)} {(-n)} 
                  {
                    (DQ 
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [(C {(get_remote_url)} {(${ VSub_Name origin)})]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [509 515]
                      )
                    )
                  }
                )
                (C {(die)} {(DQ ('Where do you want to fetch from today?'))})
              ]
            )
            (Sentence
              child: (C {(set)} {(x)} {($ VSub_Name '$origin')})
              terminator: <Op_Semi ';'>
            )
            (C {(shift)})
          ]
          spids: [494 495 538 16777215]
        )
      ]
      spids: [486 492 540]
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name '$exec'))})]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:exec)
                  op: Equal
                  rhs: 
                    {
                      (DQ ('--upload-pack=') 
                        (CommandSubPart
                          command_list: 
                            (CommandList
                              children: [(C {(get_uploadpack)} {($ VSub_Number '$1')})]
                            )
                          left_token: <Left_CommandSub '$('>
                          spids: [563 567]
                        )
                      )
                    }
                  spids: [560]
                )
              ]
              spids: [560]
            )
          ]
          spids: [16777215 553]
        )
      ]
      spids: [16777215 570]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:remote_nick)
          op: Equal
          rhs: {(DQ ($ VSub_Number '$1'))}
          spids: [573]
        )
      ]
      spids: [573]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:remote)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: (CommandList children:[(C {(get_remote_url)} {(DQ ($ VSub_At '$@'))})])
                left_token: <Left_CommandSub '$('>
                spids: [579 585]
              )
            }
          spids: [578]
        )
      ]
      spids: [578]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:refs) op:Equal rhs:{(EmptyPart)} spids:[587])]
      spids: [587]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:rref) op:Equal rhs:{(EmptyPart)} spids:[589])]
      spids: [589]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:rsync_slurped_objects)
          op: Equal
          rhs: {(EmptyPart)}
          spids: [591]
        )
      ]
      spids: [591]
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(DQ )} {(Lit_Other '=')} {(DQ ($ VSub_Name '$append'))})]
          action: [
            (SimpleCommand
              words: [{(Lit_Other ':')}]
              redirects: [
                (Redir
                  op: <Redir_Great '>'>
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_Name '$GIT_DIR') (/FETCH_HEAD))}
                )
              ]
            )
          ]
          spids: [16777215 607]
        )
      ]
      spids: [16777215 618]
    )
    (AndOr
      ops: [Op_DPipe]
      children: [
        (Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (LhsName name:ls_remote_result)
              op: Equal
              rhs: 
                {
                  (CommandSubPart
                    command_list: 
                      (CommandList
                        children: [
                          (C {(git)} {(ls-remote)} {($ VSub_Name '$exec')} {(DQ ($ VSub_Name '$remote'))})
                        ]
                      )
                    left_token: <Left_CommandSub '$('>
                    spids: [625 635]
                  )
                }
              spids: [624]
            )
          ]
          spids: [624]
        )
        (C {(die)} {(DQ ('Cannot get the repository state from ') ($ VSub_Name '$remote'))})
      ]
    )
    (FuncDef
      name: append_fetch_head
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:flags) op:Equal rhs:{(EmptyPart)} spids:[656])]
              spids: [656]
            )
            (AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_Name '$verbose'))})
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:flags)
                      op: Equal
                      rhs: {(DQ ($ VSub_Name '$flags') ($ VSub_Name '$LF') (-v))}
                      spids: [669]
                    )
                  ]
                  spids: [669]
                )
              ]
            )
            (AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_Name '$force') ($ VSub_Name '$single_force'))})
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:flags)
                      op: Equal
                      rhs: {(DQ ($ VSub_Name '$flags') ($ VSub_Name '$LF') (-f))}
                      spids: [688]
                    )
                  ]
                  spids: [688]
                )
              ]
            )
            (SimpleCommand
              words: [
                {(git)}
                {(fetch--tool)}
                {($ VSub_Name '$flags')}
                {(append-fetch-head)}
                {(DQ ($ VSub_At '$@'))}
              ]
              more_env: [
                (env_pair
                  name: GIT_REFLOG_ACTION
                  val: {(DQ ($ VSub_Name '$GIT_REFLOG_ACTION'))}
                  spids: [696]
                )
              ]
            )
          ]
          spids: [653]
        )
      spids: [648 652]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_Name '$update_head_ok'))})
                (C {(test)} 
                  {
                    (CommandSubPart
                      command_list: (CommandList children:[(C {(is_bare_repository)})])
                      left_token: <Left_CommandSub '$('>
                      spids: [738 740]
                    )
                  } {(Lit_Other '=')} {(false)}
                )
              ]
            )
          ]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:orig_head)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (SimpleCommand
                                words: [{(git)} {(rev-parse)} {(--verify)} {(HEAD)}]
                                redirects: [(Redir op:<Redir_Great '2>'> fd:2 arg_word:{(/dev/null)})]
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [750 761]
                      )
                    }
                  spids: [749]
                )
              ]
              spids: [749]
            )
          ]
          spids: [16777215 746]
        )
      ]
      spids: [16777215 763]
    )
    (Case
      to_match: {(DQ ($ VSub_Name '$tags') ($ VSub_Name '$no_tags'))}
      arms: [
        (case_arm
          pat_list: [{(SQ )}]
          action: [
            (Case
              to_match: 
                {
                  (DQ 
                    (CommandSubPart
                      command_list: 
                        (CommandList
                          children: [
                            (C {(git)} {(config)} {(--get)} 
                              {(DQ (remote.) ($ VSub_Number '$1') (.tagopt))}
                            )
                          ]
                        )
                      left_token: <Left_CommandSub '$('>
                      spids: [786 798]
                    )
                  )
                }
              arms: [
                (case_arm
                  pat_list: [{(--tags)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(LhsName name:tags) op:Equal rhs:{(t)} spids:[808])]
                      spids: [808]
                    )
                  ]
                  spids: [804 805 811 16777215]
                )
                (case_arm
                  pat_list: [{(--no-tags)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(LhsName name:no_tags) op:Equal rhs:{(t)} spids:[818])]
                      spids: [818]
                    )
                  ]
                  spids: [814 815 821 16777215]
                )
              ]
              spids: [783 801 824]
            )
          ]
          spids: [778 780 16777215 826]
        )
      ]
      spids: [769 776 826]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:reflist)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [(C {(get_remote_refs_for_fetch)} {(DQ ($ VSub_At '$@'))})]
                  )
                left_token: <Left_CommandSub '$('>
                spids: [843 849]
              )
            }
          spids: [842]
        )
      ]
      spids: [842]
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(DQ ($ VSub_Name '$tags'))})]
          action: [
            (AndOr
              ops: [Op_DPipe]
              children: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:taglist)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (AndOr
                                    ops: [Op_DAmp]
                                    children: [
                                      (Assignment
                                        keyword: Assign_None
                                        pairs: [
                                          (assign_pair
                                            lhs: (LhsName name:IFS)
                                            op: Equal
                                            rhs: {(SQ <'\t'>)}
                                            spids: [864]
                                          )
                                        ]
                                        spids: [864]
                                      )
                                      (Pipeline
                                        children: [
                                          (C {(echo)} {(DQ ($ VSub_Name '$ls_remote_result'))})
                                          (C {(git)} {(show-ref)} 
                                            {(--exclude-existing) (Lit_Other '=') (refs/tags/)}
                                          )
                                          (WhileUntil
                                            keyword: <KW_While while>
                                            cond: [(C {(read)} {(sha1)} {(name)})]
                                            body: 
                                              (DoGroup
                                                children: [
                                                  (C {(echo)} 
                                                    {
                                                      (DQ (.) (${ VSub_Name name) (':') 
                                                        (${ VSub_Name name)
                                                      )
                                                    }
                                                  )
                                                ]
                                                spids: [901 918]
                                              )
                                          )
                                        ]
                                        negated: F
                                      )
                                    ]
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [863 919]
                          )
                        }
                      spids: [862]
                    )
                  ]
                  spids: [862]
                )
                (ControlFlow token:<ControlFlow_Exit exit>)
              ]
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(DQ ($ VSub_Pound '$#'))} {(-gt)} {(1)})]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:reflist)
                          op: Equal
                          rhs: 
                            {
                              (DQ ($ VSub_Name '$reflist') ($ VSub_Name '$LF') ($ VSub_Name '$taglist'))
                            }
                          spids: [946]
                        )
                      ]
                      spids: [946]
                    )
                  ]
                  spids: [16777215 939]
                )
              ]
              else_action: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:reflist)
                      op: Equal
                      rhs: {($ VSub_Name '$taglist')}
                      spids: [961]
                    )
                  ]
                  spids: [961]
                )
              ]
              spids: [954 965]
            )
          ]
          spids: [16777215 859]
        )
      ]
      spids: [16777215 967]
    )
    (FuncDef
      name: fetch_all_at_once
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:eval)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (Pipeline
                                children: [
                                  (C {(echo)} {(DQ ($ VSub_Number '$1'))})
                                  (C {(git)} {(fetch--tool)} {(parse-reflist)} {(DQ (-))})
                                ]
                                negated: F
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [980 998]
                      )
                    }
                  spids: [979]
                )
              ]
              spids: [979]
            )
            (C {(eval)} {(DQ ($ VSub_Name '$eval'))})
            (AndOr
              ops: [Op_DPipe]
              children: [
                (Subshell
                  child: 
                    (CommandList
                      children: [
                        (C {(Lit_Other ':')} {(subshell)} {(because)} {(we)} {(muck)} {(with)} {(IFS)})
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:IFS)
                              op: Equal
                              rhs: {(DQ (' \t') ($ VSub_Name '$LF'))}
                              spids: [1026]
                            )
                          ]
                          spids: [1026]
                        )
                        (Pipeline
                          children: [
                            (Subshell
                              child: 
                                (If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (Sentence
                                          child: 
                                            (C {(test)} {(DQ ($ VSub_Name '$remote'))} {(Lit_Other '=')} 
                                              {(.)}
                                            )
                                          terminator: <Op_Semi ';'>
                                        )
                                      ]
                                      action: [
                                        (AndOr
                                          ops: [Op_DPipe]
                                          children: [
                                            (C {(git)} {(show-ref)} {($ VSub_Name '$rref')})
                                            (C {(echo)} {(failed)} {(DQ ($ VSub_Name '$remote'))})
                                          ]
                                        )
                                      ]
                                      spids: [16777215 1050]
                                    )
                                    (if_arm
                                      cond: [
                                        (Sentence
                                          child: (C {(test)} {(-f)} {(DQ ($ VSub_Name '$remote'))})
                                          terminator: <Op_Semi ';'>
                                        )
                                      ]
                                      action: [
                                        (AndOr
                                          ops: [Op_DAmp]
                                          children: [
                                            (C {(test)} {(-n)} {(DQ ($ VSub_Name '$shallow_depth'))})
                                            (C {(die)} 
                                              {(DQ ('shallow clone with bundle is not supported'))}
                                            )
                                          ]
                                        )
                                        (AndOr
                                          ops: [Op_DPipe]
                                          children: [
                                            (C {(git)} {(bundle)} {(unbundle)} 
                                              {(DQ ($ VSub_Name '$remote'))} {($ VSub_Name '$rref')}
                                            )
                                            (C {(echo)} {(failed)} {(DQ ($ VSub_Name '$remote'))})
                                          ]
                                        )
                                      ]
                                      spids: [1070 1082]
                                    )
                                  ]
                                  else_action: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (AndOr
                                              ops: [Op_DAmp Op_DAmp Op_DAmp Op_DAmp]
                                              children: [
                                                (C {(test)} {(-d)} {(DQ ($ VSub_Name '$remote'))})
                                                (C {(test)} {(KW_Bang '!')} {(-f)} 
                                                  {(DQ ($ VSub_Name '$GIT_DIR') (/shallow))}
                                                )
                                                (C {(test)} {(-z)} {(DQ ($ VSub_Name '$shallow_depth'))})
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:theirs)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (CommandSubPart
                                                            command_list: 
                                                              (CommandList
                                                                children: [
                                                                  (Pipeline
                                                                    children: [
                                                                      (C {(echo)} 
                                                                        {
                                                                          (DQ 
                                                                            ($ VSub_Name 
'$ls_remote_result'
                                                                            )
                                                                          )
                                                                        }
                                                                      )
                                                                      (C {(git)} {(fetch--tool)} {(-s)} 
                                                                        {(pick-rref)} {(DQ ($ VSub_Name '$rref'))} {(DQ (-))}
                                                                      )
                                                                    ]
                                                                    negated: F
                                                                  )
                                                                ]
                                                              )
                                                            left_token: <Left_CommandSub '$('>
                                                            spids: [1199 1225]
                                                          )
                                                        }
                                                      spids: [1198]
                                                    )
                                                  ]
                                                  spids: [1198]
                                                )
                                                (SimpleCommand
                                                  words: [
                                                    {(git)}
                                                    {(rev-list)}
                                                    {(--objects)}
                                                    {($ VSub_Name '$theirs')}
                                                    {(--not)}
                                                    {(--all)}
                                                  ]
                                                  redirects: [
                                                    (Redir
                                                      op: <Redir_Great '>'>
                                                      fd: 16777215
                                                      arg_word: {(/dev/null)}
                                                    )
                                                    (Redir
                                                      op: <Redir_Great '2>'>
                                                      fd: 2
                                                      arg_word: {(/dev/null)}
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                          action: [
                                            (Pipeline
                                              children: [
                                                (C {(echo)} {(DQ ($ VSub_Name '$ls_remote_result'))})
                                                (C {(git)} {(fetch--tool)} {(pick-rref)} 
                                                  {(DQ ($ VSub_Name '$rref'))} {(DQ (-))}
                                                )
                                              ]
                                              negated: F
                                            )
                                          ]
                                          spids: [16777215 1264]
                                        )
                                      ]
                                      else_action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:flags)
                                              op: Equal
                                              rhs: {(EmptyPart)}
                                              spids: [1295]
                                            )
                                          ]
                                          spids: [1295]
                                        )
                                        (Case
                                          to_match: {($ VSub_Name '$verbose')}
                                          arms: [
                                            (case_arm
                                              pat_list: [{(YesYes) (Lit_Other '*')}]
                                              action: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:flags)
                                                      op: Equal
                                                      rhs: {(DQ (-v))}
                                                      spids: [1310]
                                                    )
                                                  ]
                                                  spids: [1310]
                                                )
                                              ]
                                              spids: [1305 1307 1316 16777215]
                                            )
                                          ]
                                          spids: [1298 1302 1319]
                                        )
                                        (AndOr
                                          ops: [Op_DPipe]
                                          children: [
                                            (C {(git-fetch-pack)} {(--thin)} {($ VSub_Name '$exec')} 
                                              {($ VSub_Name '$keep')} {($ VSub_Name '$shallow_depth')} {($ VSub_Name '$quiet')} {($ VSub_Name '$no_progress')} 
                                              {($ VSub_Name '$flags')} {(DQ ($ VSub_Name '$remote'))} {($ VSub_Name '$rref')}
                                            )
                                            (C {(echo)} {(failed)} {(DQ ($ VSub_Name '$remote'))})
                                          ]
                                        )
                                      ]
                                      spids: [1292 1358]
                                    )
                                  ]
                                  spids: [1127 1361]
                                )
                              spids: [1033 1364]
                            )
                            (Subshell
                              child: 
                                (CommandList
                                  children: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:flags)
                                          op: Equal
                                          rhs: {(EmptyPart)}
                                          spids: [1372]
                                        )
                                      ]
                                      spids: [1372]
                                    )
                                    (AndOr
                                      ops: [Op_DAmp]
                                      children: [
                                        (C {(test)} {(-n)} {(DQ ($ VSub_Name '$verbose'))})
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:flags)
                                              op: Equal
                                              rhs: {(DQ ($ VSub_Name '$flags') (' -v'))}
                                              spids: [1385]
                                            )
                                          ]
                                          spids: [1385]
                                        )
                                      ]
                                    )
                                    (AndOr
                                      ops: [Op_DAmp]
                                      children: [
                                        (C {(test)} {(-n)} {(DQ ($ VSub_Name '$force'))})
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:flags)
                                              op: Equal
                                              rhs: {(DQ ($ VSub_Name '$flags') (' -f'))}
                                              spids: [1402]
                                            )
                                          ]
                                          spids: [1402]
                                        )
                                      ]
                                    )
                                    (SimpleCommand
                                      words: [
                                        {(git)}
                                        {(fetch--tool)}
                                        {($ VSub_Name '$flags')}
                                        {(native-store)}
                                        {(DQ ($ VSub_Name '$remote'))}
                                        {(DQ ($ VSub_Name '$remote_nick'))}
                                        {(DQ ($ VSub_Name '$refs'))}
                                      ]
                                      more_env: [
                                        (env_pair
                                          name: GIT_REFLOG_ACTION
                                          val: {(DQ ($ VSub_Name '$GIT_REFLOG_ACTION'))}
                                          spids: [1409]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              spids: [1369 1439]
                            )
                          ]
                          negated: F
                        )
                      ]
                    )
                  spids: [1009 1442]
                )
                (ControlFlow token:<ControlFlow_Exit exit>)
              ]
            )
          ]
          spids: [975]
        )
      spids: [970 974]
    )
    (FuncDef
      name: fetch_per_ref
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:reflist)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number '$1'))}
                  spids: [1460]
                )
              ]
              spids: [1460]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:refs) op:Equal rhs:{(EmptyPart)} spids:[1466])]
              spids: [1466]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:rref) op:Equal rhs:{(EmptyPart)} spids:[1469])]
              spids: [1469]
            )
            (ForEach
              iter_name: ref
              iter_words: [{($ VSub_Name '$reflist')}]
              do_arg_iter: F
              body: 
                (DoGroup
                  children: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:refs)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name '$refs') ($ VSub_Name '$LF') ($ VSub_Name '$ref'))}
                          spids: [1485]
                        )
                      ]
                      spids: [1485]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (SimpleCommand
                              words: [
                                {(expr)}
                                {(DQ (z) ($ VSub_Name '$ref'))}
                                {(Lit_Other ':')}
                                {(SQ <'z\\.'>)}
                              ]
                              redirects: [
                                (Redir
                                  op: <Redir_Great '>'>
                                  fd: 16777215
                                  arg_word: {(/dev/null)}
                                )
                              ]
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:not_for_merge)
                                  op: Equal
                                  rhs: {(t)}
                                  spids: [1524]
                                )
                              ]
                              spids: [1524]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:ref)
                                  op: Equal
                                  rhs: 
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (C {(expr)} {(DQ (z) ($ VSub_Name '$ref'))} 
                                                {(Lit_Other ':')} {(SQ <'z\\.\\(.*\\)'>)}
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub '$('>
                                        spids: [1529 1542]
                                      )
                                    }
                                  spids: [1528]
                                )
                              ]
                              spids: [1528]
                            )
                          ]
                          spids: [16777215 1521]
                        )
                      ]
                      else_action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:not_for_merge)
                              op: Equal
                              rhs: {(EmptyPart)}
                              spids: [1548]
                            )
                          ]
                          spids: [1548]
                        )
                      ]
                      spids: [1545 1551]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (SimpleCommand
                              words: [
                                {(expr)}
                                {(DQ (z) ($ VSub_Name '$ref'))}
                                {(Lit_Other ':')}
                                {(SQ <'z+'>)}
                              ]
                              redirects: [
                                (Redir
                                  op: <Redir_Great '>'>
                                  fd: 16777215
                                  arg_word: {(/dev/null)}
                                )
                              ]
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:single_force)
                                  op: Equal
                                  rhs: {(t)}
                                  spids: [1576]
                                )
                              ]
                              spids: [1576]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:ref)
                                  op: Equal
                                  rhs: 
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (C {(expr)} {(DQ (z) ($ VSub_Name '$ref'))} 
                                                {(Lit_Other ':')} {(SQ <'z+\\(.*\\)'>)}
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub '$('>
                                        spids: [1581 1594]
                                      )
                                    }
                                  spids: [1580]
                                )
                              ]
                              spids: [1580]
                            )
                          ]
                          spids: [16777215 1573]
                        )
                      ]
                      else_action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:single_force)
                              op: Equal
                              rhs: {(EmptyPart)}
                              spids: [1600]
                            )
                          ]
                          spids: [1600]
                        )
                      ]
                      spids: [1597 1603]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:remote_name)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(expr)} {(DQ (z) ($ VSub_Name '$ref'))} {(Lit_Other ':')} 
                                        {(SQ <'z\\([^:]*\\):'>)}
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [1607 1620]
                              )
                            }
                          spids: [1606]
                        )
                      ]
                      spids: [1606]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:local_name)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(expr)} {(DQ (z) ($ VSub_Name '$ref'))} {(Lit_Other ':')} 
                                        {(SQ <'z[^:]*:\\(.*\\)'>)}
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [1624 1637]
                              )
                            }
                          spids: [1623]
                        )
                      ]
                      spids: [1623]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:rref)
                          op: Equal
                          rhs: 
                            {
                              (DQ ($ VSub_Name '$rref') ($ VSub_Name '$LF') 
                                ($ VSub_Name '$remote_name')
                              )
                            }
                          spids: [1641]
                        )
                      ]
                      spids: [1641]
                    )
                    (Case
                      to_match: {(DQ ($ VSub_Name '$remote'))}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(http) (Lit_Other ':') (//) (Lit_Other '*')}
                            {(https) (Lit_Other ':') (//) (Lit_Other '*')}
                            {(ftp) (Lit_Other ':') (//) (Lit_Other '*')}
                          ]
                          action: [
                            (AndOr
                              ops: [Op_DAmp]
                              children: [
                                (C {(test)} {(-n)} {(DQ ($ VSub_Name '$shallow_depth'))})
                                (C {(die)} {(DQ ('shallow clone with http not supported'))})
                              ]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:proto)
                                  op: Equal
                                  rhs: 
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (C {(expr)} {(DQ ($ VSub_Name '$remote'))} 
                                                {(Lit_Other ':')} {(SQ <'\\([^:]*\\):'>)}
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub '$('>
                                        spids: [1703 1715]
                                      )
                                    }
                                  spids: [1702]
                                )
                              ]
                              spids: [1702]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(Lit_Other '[')} {(-n)} 
                                          {(DQ ($ VSub_Name '$GIT_SSL_NO_VERIFY'))} {(Lit_Other ']')}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:curl_extra_args)
                                          op: Equal
                                          rhs: {(DQ (-k))}
                                          spids: [1734]
                                        )
                                      ]
                                      spids: [1734]
                                    )
                                  ]
                                  spids: [16777215 1731]
                                )
                              ]
                              spids: [16777215 1740]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(Lit_Other '[')} {(-n)} 
                                          {(DQ ($ VSub_Name '$GIT_CURL_FTP_NO_EPSV'))} {(-o)} 
                                          {
                                            (DQ 
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (C {(git)} {(config)} {(--bool)} {(http.noEPSV)})
                                                    ]
                                                  )
                                                left_token: <Left_CommandSub '$('>
                                                spids: [1758 1766]
                                              )
                                            )
                                          } {(Lit_Other '=')} {(true)} {(Lit_Other ']')}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:noepsv_opt)
                                          op: Equal
                                          rhs: {(DQ (--disable-epsv))}
                                          spids: [1779]
                                        )
                                      ]
                                      spids: [1779]
                                    )
                                  ]
                                  spids: [16777215 1776]
                                )
                              ]
                              spids: [16777215 1785]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:head)
                                  op: Equal
                                  rhs: 
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (Pipeline
                                                children: [
                                                  (C {(echo)} {(DQ ($ VSub_Name '$ls_remote_result'))})
                                                  (C {(git)} {(fetch--tool)} {(-s)} {(pick-rref)} 
                                                    {(DQ ($ VSub_Name '$remote_name'))} {(DQ (-))}
                                                  )
                                                ]
                                                negated: F
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub '$('>
                                        spids: [1794 1820]
                                      )
                                    }
                                  spids: [1793]
                                )
                              ]
                              spids: [1793]
                            )
                            (AndOr
                              ops: [Op_DPipe]
                              children: [
                                (SimpleCommand
                                  words: [
                                    {(expr)}
                                    {(DQ (z) ($ VSub_Name '$head'))}
                                    {(Lit_Other ':')}
                                    {
                                      (DQ (z) ($ VSub_Name '$_x40') 
                                        (EscapedLiteralPart
                                          token: <Lit_EscapedChar '\\$'>
                                        )
                                      )
                                    }
                                  ]
                                  redirects: [
                                    (Redir
                                      op: <Redir_Great '>'>
                                      fd: 16777215
                                      arg_word: {(/dev/null)}
                                    )
                                  ]
                                )
                                (C {(die)} 
                                  {
                                    (DQ ('No such ref ') ($ VSub_Name '$remote_name') (' at ') 
                                      ($ VSub_Name '$remote')
                                    )
                                  }
                                )
                              ]
                            )
                            (SimpleCommand
                              words: [
                                {(echo)}
                                {
                                  (DQ ('Fetching ') ($ VSub_Name '$remote_name') (' from ') 
                                    ($ VSub_Name '$remote') (' using ') ($ VSub_Name '$proto')
                                  )
                                }
                              ]
                              redirects: [(Redir op:<Redir_GreatAnd '>&'> fd:16777215 arg_word:{(2)})]
                            )
                            (Case
                              to_match: {(DQ ($ VSub_Name '$quiet'))}
                              arms: [
                                (case_arm
                                  pat_list: [{(SQ )}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:v)
                                          op: Equal
                                          rhs: {(-v)}
                                          spids: [1881]
                                        )
                                      ]
                                      spids: [1881]
                                    )
                                  ]
                                  spids: [1877 1879 1884 16777215]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Other '*')}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:v)
                                          op: Equal
                                          rhs: {(EmptyPart)}
                                          spids: [1889]
                                        )
                                      ]
                                      spids: [1889]
                                    )
                                  ]
                                  spids: [1886 1887 1891 16777215]
                                )
                              ]
                              spids: [1869 1875 1893]
                            )
                            (AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {(git-http-fetch)} {($ VSub_Name '$v')} {(-a)} 
                                  {(DQ ($ VSub_Name '$head'))} {(DQ ($ VSub_Name '$remote'))}
                                )
                                (ControlFlow
                                  token: <ControlFlow_Exit exit>
                                )
                              ]
                            )
                          ]
                          spids: [1663 1681 1915 16777215]
                        )
                        (case_arm
                          pat_list: [{(rsync) (Lit_Other ':') (//) (Lit_Other '*')}]
                          action: [
                            (AndOr
                              ops: [Op_DAmp]
                              children: [
                                (C {(test)} {(-n)} {(DQ ($ VSub_Name '$shallow_depth'))})
                                (C {(die)} {(DQ ('shallow clone with rsync not supported'))})
                              ]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:TMP_HEAD)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name '$GIT_DIR') (/TMP_HEAD))}
                                  spids: [1943]
                                )
                              ]
                              spids: [1943]
                            )
                            (AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {(rsync)} {(-L)} {(-q)} 
                                  {(DQ ($ VSub_Name '$remote') (/) ($ VSub_Name '$remote_name'))} {(DQ ($ VSub_Name '$TMP_HEAD'))}
                                )
                                (ControlFlow
                                  token: <ControlFlow_Exit exit>
                                  arg_word: {(1)}
                                )
                              ]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:head)
                                  op: Equal
                                  rhs: 
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (C {(git)} {(rev-parse)} {(--verify)} {(TMP_HEAD)})
                                            ]
                                          )
                                        left_token: <Left_CommandSub '$('>
                                        spids: [1974 1982]
                                      )
                                    }
                                  spids: [1973]
                                )
                              ]
                              spids: [1973]
                            )
                            (C {(rm)} {(-f)} {(DQ ($ VSub_Name '$TMP_HEAD'))})
                            (Case
                              to_match: {(DQ ($ VSub_Name '$quiet'))}
                              arms: [
                                (case_arm
                                  pat_list: [{(SQ )}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:v)
                                          op: Equal
                                          rhs: {(-v)}
                                          spids: [2006]
                                        )
                                      ]
                                      spids: [2006]
                                    )
                                  ]
                                  spids: [2002 2004 2009 16777215]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Other '*')}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:v)
                                          op: Equal
                                          rhs: {(EmptyPart)}
                                          spids: [2014]
                                        )
                                      ]
                                      spids: [2014]
                                    )
                                  ]
                                  spids: [2011 2012 2016 16777215]
                                )
                              ]
                              spids: [1994 2000 2018]
                            )
                            (AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {(test)} {(DQ ($ VSub_Name '$rsync_slurped_objects'))})
                                (BraceGroup
                                  children: [
                                    (AndOr
                                      ops: [Op_DPipe]
                                      children: [
                                        (C {(rsync)} {(-a)} {($ VSub_Name '$v')} {(--ignore-existing)} 
                                          {(--exclude)} {(info)} {(DQ ($ VSub_Name '$remote') (/objects/))} {(DQ ($ VSub_Name '$GIT_OBJECT_DIRECTORY') (/))}
                                        )
                                        (ControlFlow
                                          token: <ControlFlow_Exit exit>
                                        )
                                      ]
                                    )
                                    (AndOr
                                      ops: [Op_DPipe]
                                      children: [
                                        (SimpleCommand
                                          words: [
                                            {(rsync)}
                                            {(-q)}
                                            {(DQ ($ VSub_Name '$remote') (/objects/info/alternates))}
                                            {(DQ ($ VSub_Name '$GIT_DIR') (/TMP_ALT))}
                                          ]
                                          redirects: [
                                            (Redir
                                              op: <Redir_Great '2>'>
                                              fd: 2
                                              arg_word: {(/dev/null)}
                                            )
                                          ]
                                        )
                                        (C {(rm)} {(-f)} {(DQ ($ VSub_Name '$GIT_DIR') (/TMP_ALT))})
                                      ]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (C {(test)} {(-f)} {(DQ ($ VSub_Name '$GIT_DIR') (/TMP_ALT))})
                                          ]
                                          action: [
                                            (Pipeline
                                              children: [
                                                (SimpleCommand
                                                  words: [
                                                    {(resolve_alternates)}
                                                    {(DQ ($ VSub_Name '$remote'))}
                                                  ]
                                                  redirects: [
                                                    (Redir
                                                      op: <Redir_Less '<'>
                                                      fd: 16777215
                                                      arg_word: 
                                                        {(DQ ($ VSub_Name '$GIT_DIR') (/TMP_ALT))}
                                                    )
                                                  ]
                                                )
                                                (WhileUntil
                                                  keyword: <KW_While while>
                                                  cond: [(C {(read)} {(alt)})]
                                                  body: 
                                                    (DoGroup
                                                      children: [
                                                        (Case
                                                          to_match: {(DQ ($ VSub_Name '$alt'))}
                                                          arms: [
                                                            (case_arm
                                                              pat_list: [
                                                                {(SQ <'bad alternate: '>) 
                                                                  (Lit_Other '*')
                                                                }
                                                              ]
                                                              action: [
                                                                (C {(die)} {(DQ ($ VSub_Name '$alt'))})
                                                              ]
                                                              spids: [2154 2158 2165 16777215]
                                                            )
                                                          ]
                                                          spids: [2146 2152 2167]
                                                        )
                                                        (SimpleCommand
                                                          words: [
                                                            {(echo)}
                                                            {
                                                              (DQ ('Getting alternate: ') 
                                                                ($ VSub_Name '$alt')
                                                              )
                                                            }
                                                          ]
                                                          redirects: [
                                                            (Redir
                                                              op: <Redir_GreatAnd '>&'>
                                                              fd: 16777215
                                                              arg_word: {(2)}
                                                            )
                                                          ]
                                                        )
                                                        (AndOr
                                                          ops: [Op_DPipe]
                                                          children: [
                                                            (C {(rsync)} {(-av)} {(--ignore-existing)} 
                                                              {(--exclude)} {(info)} {(DQ ($ VSub_Name '$alt'))} {(DQ ($ VSub_Name '$GIT_OBJECT_DIRECTORY') (/))}
                                                            )
                                                            (ControlFlow
                                                              token: <ControlFlow_Exit exit>
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                      spids: [2143 2207]
                                                    )
                                                )
                                              ]
                                              negated: F
                                            )
                                            (C {(rm)} {(-f)} {(DQ ($ VSub_Name '$GIT_DIR') (/TMP_ALT))})
                                          ]
                                          spids: [16777215 2118]
                                        )
                                      ]
                                      spids: [16777215 2220]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:rsync_slurped_objects)
                                          op: Equal
                                          rhs: {(t)}
                                          spids: [2223]
                                        )
                                      ]
                                      spids: [2223]
                                    )
                                  ]
                                  spids: [2029]
                                )
                              ]
                            )
                          ]
                          spids: [1918 1922 2230 16777215]
                        )
                      ]
                      spids: [1654 1660 2233]
                    )
                    (AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(append_fetch_head)} {(DQ ($ VSub_Name '$head'))} 
                          {(DQ ($ VSub_Name '$remote'))} {(DQ ($ VSub_Name '$remote_name'))} {(DQ ($ VSub_Name '$remote_nick'))} 
                          {(DQ ($ VSub_Name '$local_name'))} {(DQ ($ VSub_Name '$not_for_merge'))}
                        )
                        (ControlFlow token:<ControlFlow_Exit exit>)
                      ]
                    )
                  ]
                  spids: [1482 2271]
                )
              spids: [1478 16777215]
            )
          ]
          spids: [1457]
        )
      spids: [1452 1456]
    )
    (FuncDef
      name: fetch_main
      body: 
        (BraceGroup
          children: [
            (Case
              to_match: {(DQ ($ VSub_Name '$remote'))}
              arms: [
                (case_arm
                  pat_list: [
                    {(http) (Lit_Other ':') (//) (Lit_Other '*')}
                    {(https) (Lit_Other ':') (//) (Lit_Other '*')}
                    {(ftp) (Lit_Other ':') (//) (Lit_Other '*')}
                    {(rsync) (Lit_Other ':') (//) (Lit_Other '*')}
                  ]
                  action: [(C {(fetch_per_ref)} {(DQ ($ VSub_At '$@'))})]
                  spids: [2294 2320 2330 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [(C {(fetch_all_at_once)} {(DQ ($ VSub_At '$@'))})]
                  spids: [2333 2334 2344 16777215]
                )
              ]
              spids: [2285 2291 2347]
            )
          ]
          spids: [2282]
        )
      spids: [2277 2281]
    )
    (AndOr
      ops: [Op_DPipe]
      children: [
        (C {(fetch_main)} {(DQ ($ VSub_Name '$reflist'))})
        (ControlFlow token:<ControlFlow_Exit exit>)
      ]
    )
    (Case
      to_match: {(DQ ($ VSub_Name '$no_tags') ($ VSub_Name '$tags'))}
      arms: [
        (case_arm
          pat_list: [{(SQ )}]
          action: [
            (Case
              to_match: {(DQ ($ VSub_Name '$reflist'))}
              arms: [
                (case_arm
                  pat_list: [{(Lit_Other '*') (Lit_Other ':') (refs/) (Lit_Other '*')}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:taglist)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (AndOr
                                        ops: [Op_DAmp]
                                        children: [
                                          (Assignment
                                            keyword: Assign_None
                                            pairs: [
                                              (assign_pair
                                                lhs: (LhsName name:IFS)
                                                op: Equal
                                                rhs: {(SQ <'\t'>)}
                                                spids: [2406]
                                              )
                                            ]
                                            spids: [2406]
                                          )
                                          (Pipeline
                                            children: [
                                              (C {(echo)} {(DQ ($ VSub_Name '$ls_remote_result'))})
                                              (C {(git)} {(show-ref)} 
                                                {(--exclude-existing) (Lit_Other '=') (refs/tags/)}
                                              )
                                              (WhileUntil
                                                keyword: <KW_While while>
                                                cond: [(C {(read)} {(sha1)} {(name)})]
                                                body: 
                                                  (DoGroup
                                                    children: [
                                                      (AndOr
                                                        ops: [Op_DPipe]
                                                        children: [
                                                          (SimpleCommand
                                                            words: [
                                                              {(git)}
                                                              {(cat-file)}
                                                              {(-t)}
                                                              {(DQ ($ VSub_Name '$sha1'))}
                                                            ]
                                                            redirects: [
                                                              (Redir
                                                                op: <Redir_Great '>'>
                                                                fd: 16777215
                                                                arg_word: {(/dev/null)}
                                                              )
                                                              (Redir
                                                                op: <Redir_GreatAnd '2>&'>
                                                                fd: 2
                                                                arg_word: {(1)}
                                                              )
                                                            ]
                                                          )
                                                          (ControlFlow
                                                            token: <ControlFlow_Continue continue>
                                                          )
                                                        ]
                                                      )
                                                      (SimpleCommand
                                                        words: [
                                                          {(echo)}
                                                          {
                                                            (DQ ('Auto-following ') 
                                                              ($ VSub_Name '$name')
                                                            )
                                                          }
                                                        ]
                                                        redirects: [
                                                          (Redir
                                                            op: <Redir_GreatAnd '>&'>
                                                            fd: 16777215
                                                            arg_word: {(2)}
                                                          )
                                                        ]
                                                      )
                                                      (C {(echo)} 
                                                        {
                                                          (DQ (.) (${ VSub_Name name) (':') 
                                                            (${ VSub_Name name)
                                                          )
                                                        }
                                                      )
                                                    ]
                                                    spids: [2443 2492]
                                                  )
                                              )
                                            ]
                                            negated: F
                                          )
                                        ]
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [2405 2493]
                              )
                            }
                          spids: [2404]
                        )
                      ]
                      spids: [2404]
                    )
                  ]
                  spids: [2389 2393 16777215 2496]
                )
              ]
              spids: [2380 2386 2496]
            )
            (Case
              to_match: {(DQ ($ VSub_Name '$taglist'))}
              arms: [
                (case_arm pat_list:[{(SQ )}] spids:[2508 2510 2512 16777215])
                (case_arm
                  pat_list: [{(Lit_Other '?') (Lit_Other '*')}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:shallow_depth)
                          op: Equal
                          rhs: {(EmptyPart)}
                          spids: [2524]
                        )
                      ]
                      spids: [2524]
                    )
                    (AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(fetch_main)} {(DQ ($ VSub_Name '$taglist'))})
                        (ControlFlow token:<ControlFlow_Exit exit>)
                      ]
                    )
                  ]
                  spids: [2515 2517 2537 16777215]
                )
              ]
              spids: [2499 2505 2540]
            )
          ]
          spids: [2375 2377 16777215 2542]
        )
      ]
      spids: [2366 2373 2542]
    )
    (Case
      to_match: {(DQ ($ VSub_Name '$orig_head'))}
      arms: [
        (case_arm pat_list:[{(SQ )}] spids:[2559 2561 2564 16777215])
        (case_arm
          pat_list: [{(Lit_Other '?') (Lit_Other '*')}]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:curr_head)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (SimpleCommand
                                words: [{(git)} {(rev-parse)} {(--verify)} {(HEAD)}]
                                redirects: [(Redir op:<Redir_Great '2>'> fd:2 arg_word:{(/dev/null)})]
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [2572 2583]
                      )
                    }
                  spids: [2571]
                )
              ]
              spids: [2571]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (C {(test)} {(DQ ($ VSub_Name '$curr_head'))} {(KW_Bang '!') (Lit_Other '=')} 
                      {(DQ ($ VSub_Name '$orig_head'))}
                    )
                  ]
                  action: [
                    (C {(git)} {(update-ref)} {(-m)} 
                      {
                        (DQ ($ VSub_Name '$GIT_REFLOG_ACTION') (': Undoing incorrectly fetched HEAD.'))
                      } {(HEAD)} {(DQ ($ VSub_Name '$orig_head'))}
                    )
                    (C {(die)} {(DQ ('Cannot fetch into the current branch.'))})
                  ]
                  spids: [16777215 2602]
                )
              ]
              spids: [16777215 2634]
            )
          ]
          spids: [2566 2568 2637 16777215]
        )
      ]
      spids: [2551 2557 2639]
    )
  ]
)