(CommandList
  children: [
    (C {(unset)} {(CDPATH)})
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:OPTIONS_SPEC)
          op: Equal
          rhs: 
            {
              (DQ ('git-clone [options] [--] <repo> [<dir>]\n') ('--\n') 
                ("n,no-checkout        don't create a checkout\n") ('bare                 create a bare repository\n') 
                ('naked                create a bare repository\n') ('l,local              to clone from a local repository\n') 
                ("no-hardlinks         don't use local hardlinks, always copy\n") ('s,shared             setup as a shared repository\n') 
                ('template=            path to the template directory\n') ('q,quiet              be quiet\n') ('reference=           reference repository\n') 
                ("o,origin=            use <name> instead of 'origin' to track upstream\n") ('u,upload-pack=       path to git-upload-pack on the remote\n') 
                ('depth=               create a shallow clone of that depth\n') ('\n') ('use-separate-remote  compatibility, do not use\n') 
                ('no-separate-remote   compatibility, do not use')
              )
            }
          spids: [27]
        )
      ]
      spids: [27]
    )
    (FuncDef
      name: die
      body: 
        (BraceGroup
          children: [
            (SimpleCommand
              words: [{(echo)} {(DQ ($ VSub_At '$@'))}]
              redirects: [(Redir op_id:Redir_GreatAnd fd:16777215 arg_word:{(2)} spids:[59])]
            )
            (ControlFlow token:<ControlFlow_Exit exit> arg_word:{(1)})
          ]
          spids: [54]
        )
      spids: [50 53]
    )
    (FuncDef
      name: usage
      body: (BraceGroup children:[(C {(exec)} {(DQ ($ VSub_Number '$0'))} {(-h)})] spids:[78])
      spids: [74 77]
    )
    (C {(eval)} 
      {
        (DQ 
          (CommandSubPart
            command_list: 
              (CommandList
                children: [
                  (AndOr
                    ops: [Op_DPipe]
                    children: [
                      (Pipeline
                        children: [
                          (C {(echo)} {(DQ ($ VSub_Name '$OPTIONS_SPEC'))})
                          (C {(git)} {(rev-parse)} {(--parseopt)} {(--)} {(DQ ($ VSub_At '$@'))})
                        ]
                        negated: F
                      )
                      (C {(echo)} {(ControlFlow_Exit exit)} {($ VSub_QMark '$?')})
                    ]
                  )
                ]
              )
            left_token: <Left_CommandSub '$('>
            spids: [95 123]
          )
        )
      }
    )
    (FuncDef
      name: get_repo_base
      body: 
        (BraceGroup
          children: [
            (Subshell
              child: 
                (AndOr
                  ops: [Op_DAmp Op_DPipe Op_DAmp]
                  children: [
                    (C {(cd)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: (CommandList children:[(C {(/bin/pwd)})])
                            left_token: <Left_CommandSub '$('>
                            spids: [140 142]
                          )
                        )
                      }
                    )
                    (C {(cd)} {(DQ ($ VSub_Number '$1'))})
                    (C {(cd)} {(DQ ($ VSub_Number '$1') (.git))})
                    (BraceGroup
                      children: [(C {(cd)} {(.git)}) (C {(pwd)})]
                      spids: [166]
                    )
                  ]
                )
              redirects: [(Redir op_id:Redir_Great fd:2 arg_word:{(/dev/null)} spids:[182])]
              spids: [134 180]
            )
          ]
          spids: [131]
        )
      spids: [127 130]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (C {(Lit_Other '[')} {(-n)} {(DQ ($ VSub_Name '$GIT_SSL_NO_VERIFY'))} {(-o)} 
                  {
                    (DQ 
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [(C {(git)} {(config)} {(--bool)} {(http.sslVerify)})]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [203 211]
                      )
                    )
                  } {(Lit_Other '=')} {(false)} {(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: [224]
                )
              ]
              spids: [224]
            )
          ]
          spids: [16777215 221]
        )
      ]
      spids: [16777215 229]
    )
    (FuncDef
      name: http_fetch
      body: 
        (BraceGroup
          children: [
            (SimpleCommand
              words: [{(curl)} {(-nsfL)} {($ VSub_Name '$curl_extra_args')} {(DQ ($ VSub_Number '$1'))}]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_Number '$2'))}
                  spids: [254]
                )
              ]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:curl_exit_status)
                  op: Equal
                  rhs: {($ VSub_QMark '$?')}
                  spids: [260]
                )
              ]
              spids: [260]
            )
            (Case
              to_match: {($ VSub_Name '$curl_exit_status')}
              arms: [
                (case_arm
                  pat_list: [{(126)} {(127)}]
                  action: [(ControlFlow token:<ControlFlow_Exit exit>)]
                  spids: [271 274 278 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [
                    (ControlFlow
                      token: <ControlFlow_Return return>
                      arg_word: {($ VSub_Name '$curl_exit_status')}
                    )
                  ]
                  spids: [281 282 288 16777215]
                )
              ]
              spids: [264 268 291]
            )
          ]
          spids: [237]
        )
      spids: [232 236]
    )
    (FuncDef
      name: clone_dumb_http
      body: 
        (BraceGroup
          children: [
            (AndOr
              ops: [Op_DAmp Op_DAmp Op_DPipe]
              children: [
                (C {(cd)} {(DQ ($ VSub_Number '$2'))})
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:clone_tmp)
                      op: Equal
                      rhs: {(DQ ($ VSub_Name '$GIT_DIR') (/clone-tmp))}
                      spids: [317]
                    )
                  ]
                  spids: [317]
                )
                (C {(mkdir)} {(-p)} {(DQ ($ VSub_Name '$clone_tmp'))})
                (ControlFlow token:<ControlFlow_Exit exit> arg_word:{(1)})
              ]
            )
            (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: [356 364]
                              )
                            )
                          } {(Lit_Other '=')} {(true)} {(Lit_Other ']')}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:curl_extra_args)
                          op: Equal
                          rhs: {(DQ (${ VSub_Name curl_extra_args) (' --disable-epsv'))}
                          spids: [377]
                        )
                      ]
                      spids: [377]
                    )
                  ]
                  spids: [16777215 374]
                )
              ]
              spids: [16777215 386]
            )
            (AndOr
              ops: [Op_DPipe]
              children: [
                (C {(http_fetch)} {(DQ ($ VSub_Number '$1') (/info/refs))} 
                  {(DQ ($ VSub_Name '$clone_tmp') (/refs))}
                )
                (C {(die)} 
                  {
                    (DQ ('Cannot get remote repository information.\n') 
                      ('Perhaps git-update-server-info needs to be run there?')
                    )
                  }
                )
              ]
            )
            (AndOr
              ops: [Op_DAmp Op_DPipe]
              children: [
                (C {(test)} {(DQ (z) ($ VSub_Name '$quiet'))} {(Lit_Other '=')} {(z)})
                (Assignment
                  keyword: Assign_None
                  pairs: [(assign_pair lhs:(LhsName name:v) op:Equal rhs:{(-v)} spids:[425])]
                  spids: [425]
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [(assign_pair lhs:(LhsName name:v) op:Equal rhs:{(EmptyPart)} spids:[430])]
                  spids: [430]
                )
              ]
            )
            (While
              cond: [(C {(read)} {(sha1)} {(refname)})]
              body: 
                (DoGroup
                  children: [
                    (AndOr
                      ops: [Op_DAmp]
                      children: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:name)
                              op: Equal
                              rhs: 
                                {
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(expr)} {(DQ (z) ($ VSub_Name '$refname'))} 
                                            {(Lit_Other ':')} {(SQ <'zrefs/\\(.*\\)'>)}
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [446 459]
                                  )
                                }
                              spids: [445]
                            )
                          ]
                          spids: [445]
                        )
                        (Case
                          to_match: {(DQ ($ VSub_Name '$name'))}
                          arms: [
                            (case_arm
                              pat_list: [{(Lit_Other '*') (Lit_Other '^') (Lit_Other '*')}]
                              action: [(ControlFlow token:<ControlFlow_Continue continue>)]
                              spids: [473 476 479 16777215]
                            )
                          ]
                          spids: [464 470 482]
                        )
                      ]
                    )
                    (Case
                      to_match: {(DQ ($ VSub_Name '$bare') (',') ($ VSub_Name '$name'))}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(yes) (Lit_Comma ',') (Lit_Other '*')}
                            {(Lit_Comma ',') (heads/) (Lit_Other '*')}
                            {(Lit_Comma ',') (tags/) (Lit_Other '*')}
                          ]
                          spids: [496 511 513 16777215]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other '*')}]
                          action: [(ControlFlow token:<ControlFlow_Continue continue>)]
                          spids: [516 517 521 16777215]
                        )
                      ]
                      spids: [485 493 524]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (AndOr
                              ops: [Op_DAmp]
                              children: [
                                (C {(test)} {(-n)} {(DQ ($ VSub_Name '$use_separate_remote'))})
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:branch_name)
                                      op: Equal
                                      rhs: 
                                        {
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (C {(expr)} {(DQ (z) ($ VSub_Name '$name'))} 
                                                    {(Lit_Other ':')} {(SQ <'zheads/\\(.*\\)'>)}
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub '$('>
                                            spids: [541 554]
                                          )
                                        }
                                      spids: [540]
                                    )
                                  ]
                                  spids: [540]
                                )
                              ]
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:tname)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ (remotes/) ($ VSub_Name '$origin') (/) 
                                        ($ VSub_Name '$branch_name')
                                      )
                                    }
                                  spids: [560]
                                )
                              ]
                              spids: [560]
                            )
                          ]
                          spids: [16777215 557]
                        )
                      ]
                      else_action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:tname)
                              op: Equal
                              rhs: {($ VSub_Name '$name')}
                              spids: [572]
                            )
                          ]
                          spids: [572]
                        )
                      ]
                      spids: [569 576]
                    )
                    (AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(git-http-fetch)} {($ VSub_Name '$v')} {(-a)} {(-w)} 
                          {(DQ ($ VSub_Name '$tname'))} {(DQ ($ VSub_Name '$sha1'))} {(DQ ($ VSub_Number '$1'))}
                        )
                        (ControlFlow
                          token: <ControlFlow_Exit exit>
                          arg_word: {(1)}
                        )
                      ]
                    )
                  ]
                  spids: [442 606]
                )
              redirects: [
                (Redir
                  op_id: Redir_Less
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_Name '$clone_tmp') (/refs))}
                  spids: [608]
                )
              ]
            )
            (C {(rm)} {(-fr)} {(DQ ($ VSub_Name '$clone_tmp'))})
            (AndOr
              ops: [Op_DPipe]
              children: [
                (C {(http_fetch)} {(DQ ($ VSub_Number '$1') (/HEAD))} 
                  {(DQ ($ VSub_Name '$GIT_DIR') (/REMOTE_HEAD))}
                )
                (C {(rm)} {(-f)} {(DQ ($ VSub_Name '$GIT_DIR') (/REMOTE_HEAD))})
              ]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: (C {(test)} {(-f)} {(DQ ($ VSub_Name '$GIT_DIR') (/REMOTE_HEAD))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:head_sha1)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(cat)} {(DQ ($ VSub_Name '$GIT_DIR') (/REMOTE_HEAD))})
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [665 672]
                              )
                            }
                          spids: [664]
                        )
                      ]
                      spids: [664]
                    )
                    (Case
                      to_match: {(DQ ($ VSub_Name '$head_sha1'))}
                      arms: [
                        (case_arm
                          pat_list: [{(SQ <'ref: refs/'>) (Lit_Other '*')}]
                          spids: [685 688 691 16777215]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other '*')}]
                          action: [
                            (AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {(git-http-fetch)} {($ VSub_Name '$v')} {(-a)} 
                                  {(DQ ($ VSub_Name '$head_sha1'))} {(DQ ($ VSub_Number '$1'))}
                                )
                                (C {(rm)} {(-f)} {(DQ ($ VSub_Name '$GIT_DIR') (/REMOTE_HEAD))})
                              ]
                            )
                          ]
                          spids: [694 695 725 16777215]
                        )
                      ]
                      spids: [675 681 728]
                    )
                  ]
                  spids: [16777215 661]
                )
              ]
              spids: [16777215 731]
            )
          ]
          spids: [301]
        )
      spids: [296 300]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:quiet) op:Equal rhs:{(EmptyPart)} spids:[736])]
      spids: [736]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:local) op:Equal rhs:{(no)} spids:[738])]
      spids: [738]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:use_local_hardlink) op:Equal rhs:{(yes)} spids:[741])]
      spids: [741]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:local_shared) op:Equal rhs:{(no)} spids:[744])]
      spids: [744]
    )
    (C {(unset)} {(template)})
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:no_checkout) op:Equal rhs:{(EmptyPart)} spids:[751])]
      spids: [751]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:upload_pack) op:Equal rhs:{(EmptyPart)} spids:[753])]
      spids: [753]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:bare) op:Equal rhs:{(EmptyPart)} spids:[755])]
      spids: [755]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:reference) op:Equal rhs:{(EmptyPart)} spids:[757])]
      spids: [757]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:origin) op:Equal rhs:{(EmptyPart)} spids:[759])]
      spids: [759]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:origin_override) op:Equal rhs:{(EmptyPart)} spids:[761])]
      spids: [761]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:use_separate_remote) op:Equal rhs:{(t)} spids:[763])]
      spids: [763]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:depth) op:Equal rhs:{(EmptyPart)} spids:[766])]
      spids: [766]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:no_progress) op:Equal rhs:{(EmptyPart)} spids:[768])]
      spids: [768]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:local_explicitly_asked_for)
          op: Equal
          rhs: {(EmptyPart)}
          spids: [770]
        )
      ]
      spids: [770]
    )
    (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: [780]
            )
          ]
          spids: [780]
        )
      ]
    )
    (While
      cond: [(C {(test)} {($ VSub_Pound '$#')} {(KW_Bang '!') (Lit_Other '=')} {(0)})]
      body: 
        (DoGroup
          children: [
            (Case
              to_match: {(DQ ($ VSub_Number '$1'))}
              arms: [
                (case_arm
                  pat_list: [{(-n)} {(--no-checkout)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:no_checkout)
                          op: Equal
                          rhs: {(yes)}
                          spids: [813]
                        )
                      ]
                      spids: [813]
                    )
                  ]
                  spids: [807 810 816 16777215]
                )
                (case_arm
                  pat_list: [{(--naked)} {(--bare)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(LhsName name:bare) op:Equal rhs:{(yes)} spids:[825])]
                      spids: [825]
                    )
                  ]
                  spids: [819 822 828 16777215]
                )
                (case_arm
                  pat_list: [{(-l)} {(--local)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:local_explicitly_asked_for)
                          op: Equal
                          rhs: {(yes)}
                          spids: [837]
                        )
                      ]
                      spids: [837]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:use_local_hardlink)
                          op: Equal
                          rhs: {(yes)}
                          spids: [841]
                        )
                      ]
                      spids: [841]
                    )
                  ]
                  spids: [831 834 845 16777215]
                )
                (case_arm
                  pat_list: [{(--no-hardlinks)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:use_local_hardlink)
                          op: Equal
                          rhs: {(no)}
                          spids: [852]
                        )
                      ]
                      spids: [852]
                    )
                  ]
                  spids: [848 849 855 16777215]
                )
                (case_arm
                  pat_list: [{(-s)} {(--shared)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:local_shared)
                          op: Equal
                          rhs: {(yes)}
                          spids: [864]
                        )
                      ]
                      spids: [864]
                    )
                  ]
                  spids: [858 861 867 16777215]
                )
                (case_arm
                  pat_list: [{(--template)}]
                  action: [
                    (Sentence child:(C {(shift)}) terminator:<Op_Semi ';'>)
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:template)
                          op: Equal
                          rhs: {(DQ ('--template=') ($ VSub_Number '$1'))}
                          spids: [877]
                        )
                      ]
                      spids: [877]
                    )
                  ]
                  spids: [870 871 883 16777215]
                )
                (case_arm
                  pat_list: [{(-q)} {(--quiet)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(LhsName name:quiet) op:Equal rhs:{(-q)} spids:[892])]
                      spids: [892]
                    )
                  ]
                  spids: [886 889 895 16777215]
                )
                (case_arm
                  pat_list: [{(--use-separate-remote)} {(--no-separate-remote)}]
                  action: [(C {(die)} {(DQ ('clones are always made with separate-remote layout'))})]
                  spids: [898 901 910 16777215]
                )
                (case_arm
                  pat_list: [{(--reference)}]
                  action: [
                    (Sentence child:(C {(shift)}) terminator:<Op_Semi ';'>)
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:reference)
                          op: Equal
                          rhs: {(DQ ($ VSub_Number '$1'))}
                          spids: [920]
                        )
                      ]
                      spids: [920]
                    )
                  ]
                  spids: [913 914 925 16777215]
                )
                (case_arm
                  pat_list: [{(-o)} {(--origin)}]
                  action: [
                    (Sentence child:(C {(shift)}) terminator:<Op_Semi ';'>)
                    (Case
                      to_match: {(DQ ($ VSub_Number '$1'))}
                      arms: [
                        (case_arm
                          pat_list: [{(SQ )}]
                          action: [(C {(usage)})]
                          spids: [16777215 949 954 16777215]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other '*') (/) (Lit_Other '*')}]
                          action: [
                            (C {(die)} 
                              {
                                (DQ ("'") ($ VSub_Number '$1') ("' is not suitable for an origin name"))
                              }
                            )
                          ]
                          spids: [957 960 16777215 972]
                        )
                      ]
                      spids: [938 944 972]
                    )
                    (AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(git)} {(check-ref-format)} {(DQ (heads/) ($ VSub_Number '$1'))})
                        (C {(die)} 
                          {(DQ ("'") ($ VSub_Number '$1') ("' is not suitable for a branch name"))}
                        )
                      ]
                    )
                    (AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_Name '$origin_override'))})
                        (C {(die)} {(DQ ('Do not give more than one --origin options.'))})
                      ]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:origin_override)
                          op: Equal
                          rhs: {(yes)}
                          spids: [1014]
                        )
                      ]
                      spids: [1014]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:origin)
                          op: Equal
                          rhs: {(DQ ($ VSub_Number '$1'))}
                          spids: [1018]
                        )
                      ]
                      spids: [1018]
                    )
                  ]
                  spids: [928 931 1024 16777215]
                )
                (case_arm
                  pat_list: [{(-u)} {(--upload-pack)}]
                  action: [
                    (C {(shift)})
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:upload_pack)
                          op: Equal
                          rhs: {(DQ ('--upload-pack=') ($ VSub_Number '$1'))}
                          spids: [1036]
                        )
                      ]
                      spids: [1036]
                    )
                  ]
                  spids: [1027 1030 1042 16777215]
                )
                (case_arm
                  pat_list: [{(--depth)}]
                  action: [
                    (C {(shift)})
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:depth)
                          op: Equal
                          rhs: {(DQ ('--depth=') ($ VSub_Number '$1'))}
                          spids: [1052]
                        )
                      ]
                      spids: [1052]
                    )
                  ]
                  spids: [1045 1046 1058 16777215]
                )
                (case_arm
                  pat_list: [{(--)}]
                  action: [(C {(shift)}) (ControlFlow token:<ControlFlow_Break break>)]
                  spids: [1061 1062 1070 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [(C {(usage)})]
                  spids: [1073 1074 1079 16777215]
                )
              ]
              spids: [798 804 1082]
            )
            (C {(shift)})
          ]
          spids: [795 1087]
        )
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:repo)
          op: Equal
          rhs: {(DQ ($ VSub_Number '$1'))}
          spids: [1090]
        )
      ]
      spids: [1090]
    )
    (AndOr
      ops: [Op_DPipe]
      children: [
        (C {(test)} {(-n)} {(DQ ($ VSub_Name '$repo'))})
        (C {(die)} {(SQ <'you must specify a repository to clone.'>)})
      ]
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(yes)} {(Lit_Other '=')} {(DQ ($ VSub_Name '$bare'))})]
          action: [
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(yes)} {(Lit_Other '=')} {(DQ ($ VSub_Name '$origin_override'))})]
                  action: [(C {(die)} {(SQ <'--bare and --origin $origin options are incompatible.'>)})]
                  spids: [16777215 1144]
                )
              ]
              spids: [16777215 1154]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:no_checkout) op:Equal rhs:{(yes)} spids:[1157])]
              spids: [1157]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:use_separate_remote)
                  op: Equal
                  rhs: {(EmptyPart)}
                  spids: [1161]
                )
              ]
              spids: [1161]
            )
          ]
          spids: [16777215 1128]
        )
      ]
      spids: [16777215 1163]
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name '$origin'))})]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:origin) op:Equal rhs:{(origin)} spids:[1179])]
              spids: [1179]
            )
          ]
          spids: [16777215 1176]
        )
      ]
      spids: [16777215 1182]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: 
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:base)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [(C {(get_repo_base)} {(DQ ($ VSub_Name '$repo'))})]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [1194 1200]
                          )
                        }
                      spids: [1193]
                    )
                  ]
                  spids: [1193]
                )
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:repo)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name '$base'))}
                  spids: [1206]
                )
              ]
              spids: [1206]
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name '$depth'))})]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:local)
                          op: Equal
                          rhs: {(yes)}
                          spids: [1226]
                        )
                      ]
                      spids: [1226]
                    )
                  ]
                  spids: [16777215 1223]
                )
              ]
              spids: [16777215 1230]
            )
          ]
          spids: [16777215 1203]
        )
        (if_arm
          cond: [(C {(test)} {(-f)} {(DQ ($ VSub_Name '$repo'))})]
          action: [
            (Case
              to_match: {(DQ ($ VSub_Name '$repo'))}
              arms: [
                (case_arm
                  pat_list: [{(/) (Lit_Other '*')}]
                  spids: [1253 1255 1257 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:repo)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name '$PWD') (/) ($ VSub_Name '$repo'))}
                          spids: [1262]
                        )
                      ]
                      spids: [1262]
                    )
                  ]
                  spids: [1259 1260 1269 16777215]
                )
              ]
              spids: [1245 1251 1271]
            )
          ]
          spids: [1232 1242]
        )
      ]
      spids: [16777215 1273]
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Number '$2'))})]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:dir)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number '$2'))}
                  spids: [1292]
                )
              ]
              spids: [1292]
            )
            (AndOr
              ops: [Op_DPipe]
              children: [
                (C {(test)} {($ VSub_Pound '$#')} {(Lit_Other '=')} {(2)})
                (C {(die)} {(DQ ('excess parameter to git-clone'))})
              ]
            )
          ]
          spids: [16777215 1289]
        )
      ]
      else_action: [
        (If
          arms: [
            (if_arm
              cond: [(C {(test)} {(-f)} {(DQ ($ VSub_Name '$repo'))})]
              action: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:dir)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (Pipeline
                                    children: [
                                      (C {(echo)} {(DQ ($ VSub_Name '$repo'))})
                                      (C {(sed)} {(-e)} {(SQ <'s|/*\\.bundle$||'>)} {(-e)} 
                                        {(SQ <'s|.*/||g'>)}
                                      )
                                    ]
                                    negated: F
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [1344 1366]
                          )
                        }
                      spids: [1343]
                    )
                  ]
                  spids: [1343]
                )
              ]
              spids: [16777215 1336]
            )
          ]
          else_action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:dir)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (Pipeline
                                children: [
                                  (C {(echo)} {(DQ ($ VSub_Name '$repo'))})
                                  (C {(sed)} {(-e)} {(SQ <'s|/$||'>)} {(-e)} {(SQ <'s|:*/*\\.git$||'>)} 
                                    {(-e)} {(SQ <'s|.*[/:]||g'>)}
                                  )
                                ]
                                negated: F
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [1373 1402]
                      )
                    }
                  spids: [1372]
                )
              ]
              spids: [1372]
            )
          ]
          spids: [1369 1405]
        )
      ]
      spids: [1314 1407]
    )
    (AndOr
      ops: [Op_DAmp]
      children: [
        (C {(Lit_Other '[')} {(-e)} {(DQ ($ VSub_Name '$dir'))} {(Lit_Other ']')})
        (C {(die)} {(DQ ("destination directory '") ($ VSub_Name '$dir') ("' already exists."))})
      ]
    )
    (AndOr
      ops: [Op_DAmp]
      children: [
        (C {(Lit_Other '[')} {(yes)} {(Lit_Other '=')} {(DQ ($ VSub_Name '$bare'))} {(Lit_Other ']')})
        (C {(unset)} {(GIT_WORK_TREE)})
      ]
    )
    (AndOr
      ops: [Op_DAmp Op_DAmp]
      children: [
        (C {(Lit_Other '[')} {(-n)} {(DQ ($ VSub_Name '$GIT_WORK_TREE'))} {(Lit_Other ']')})
        (C {(Lit_Other '[')} {(-e)} {(DQ ($ VSub_Name '$GIT_WORK_TREE'))} {(Lit_Other ']')})
        (C {(die)} {(DQ ("working tree '") ($ VSub_Name '$GIT_WORK_TREE') ("' already exists."))})
      ]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:D) op:Equal rhs:{(EmptyPart)} spids:[1480])]
      spids: [1480]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:W) op:Equal rhs:{(EmptyPart)} spids:[1482])]
      spids: [1482]
    )
    (FuncDef
      name: cleanup
      body: 
        (BraceGroup
          children: [
            (AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_Name '$D'))})
                (C {(rm)} {(-rf)} {(DQ ($ VSub_Name '$dir'))})
              ]
            )
            (AndOr
              ops: [Op_DAmp Op_DAmp]
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_Name '$W'))})
                (C {(test)} {(-n)} {(DQ ($ VSub_Name '$GIT_WORK_TREE'))})
                (C {(rm)} {(-rf)} {(DQ ($ VSub_Name '$GIT_WORK_TREE'))})
              ]
            )
            (C {(cd)} {(..)})
            (AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_Name '$D'))})
                (C {(rm)} {(-rf)} {(DQ ($ VSub_Name '$D'))})
              ]
            )
            (AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_Name '$W'))})
                (C {(rm)} {(-rf)} {(DQ ($ VSub_Name '$W'))})
              ]
            )
            (ControlFlow token:<ControlFlow_Exit exit> arg_word:{($ VSub_Name '$err')})
          ]
          spids: [1488]
        )
      spids: [1484 1487]
    )
    (C {(trap)} {(SQ <'err=$?; cleanup'>)} {(0)})
    (AndOr
      ops: [Op_DAmp Op_DPipe]
      children: [
        (C {(mkdir)} {(-p)} {(DQ ($ VSub_Name '$dir'))})
        (Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (LhsName name:D)
              op: Equal
              rhs: 
                {
                  (CommandSubPart
                    command_list: 
                      (CommandList
                        children: [
                          (AndOr
                            ops: [Op_DAmp]
                            children: [(C {(cd)} {(DQ ($ VSub_Name '$dir'))}) (C {(pwd)})]
                          )
                        ]
                      )
                    left_token: <Left_CommandSub '$('>
                    spids: [1607 1617]
                  )
                }
              spids: [1606]
            )
          ]
          spids: [1606]
        )
        (C {(usage)})
      ]
    )
    (AndOr
      ops: [Op_DAmp Op_DAmp Op_DAmp Op_DAmp]
      children: [
        (C {(test)} {(-n)} {(DQ ($ VSub_Name '$GIT_WORK_TREE'))})
        (C {(mkdir)} {(-p)} {(DQ ($ VSub_Name '$GIT_WORK_TREE'))})
        (Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (LhsName name:W)
              op: Equal
              rhs: 
                {
                  (CommandSubPart
                    command_list: 
                      (CommandList
                        children: [
                          (AndOr
                            ops: [Op_DAmp]
                            children: [(C {(cd)} {(DQ ($ VSub_Name '$GIT_WORK_TREE'))}) (C {(pwd)})]
                          )
                        ]
                      )
                    left_token: <Left_CommandSub '$('>
                    spids: [1644 1654]
                  )
                }
              spids: [1643]
            )
          ]
          spids: [1643]
        )
        (Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (LhsName name:GIT_WORK_TREE)
              op: Equal
              rhs: {(DQ ($ VSub_Name '$W'))}
              spids: [1658]
            )
          ]
          spids: [1658]
        )
        (C {(export)} {(GIT_WORK_TREE)})
      ]
    )
    (AndOr
      ops: [Op_DAmp Op_DAmp Op_DPipe]
      children: [
        (If
          arms: [
            (if_arm
              cond: [
                (Sentence
                  child: 
                    (AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(test)} {(yes)} {(Lit_Other '=')} {(DQ ($ VSub_Name '$bare'))})
                        (C {(test)} {(-n)} {(DQ ($ VSub_Name '$GIT_WORK_TREE'))})
                      ]
                    )
                  terminator: <Op_Semi ';'>
                )
              ]
              action: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:GIT_DIR)
                      op: Equal
                      rhs: {(DQ ($ VSub_Name '$D'))}
                      spids: [1695]
                    )
                  ]
                  spids: [1695]
                )
              ]
              spids: [16777215 1692]
            )
          ]
          else_action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:GIT_DIR)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name '$D') (/.git))}
                  spids: [1703]
                )
              ]
              spids: [1703]
            )
          ]
          spids: [1700 1709]
        )
        (C {(export)} {(GIT_DIR)})
        (SimpleCommand
          words: [
            {(git-init)}
            {($ VSub_Name '$quiet')}
            {
              (BracedVarSub
                token: <VSub_Name template>
                suffix_op: (StringUnary op_id:VTest_Plus arg_word:{(DQ ($ VSub_Name '$template'))})
                spids: [1729 1735]
              )
            }
          ]
          more_env: [
            (env_pair
              name: GIT_CONFIG
              val: {(DQ ($ VSub_Name '$GIT_DIR') (/config))}
              spids: [1719]
            )
          ]
        )
        (C {(usage)})
      ]
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name '$bare'))})]
          action: [
            (SimpleCommand
              words: [{(git)} {(config)} {(core.bare)} {(true)}]
              more_env: [
                (env_pair
                  name: GIT_CONFIG
                  val: {(DQ ($ VSub_Name '$GIT_DIR') (/config))}
                  spids: [1755]
                )
              ]
            )
          ]
          spids: [16777215 1752]
        )
      ]
      spids: [16777215 1769]
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name '$reference'))})]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:ref_git)
                  op: Equal
                  rhs: {(EmptyPart)}
                  spids: [1785]
                )
              ]
              spids: [1785]
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-d)} {(DQ ($ VSub_Name '$reference'))})]
                  action: [
                    (If
                      arms: [
                        (if_arm
                          cond: [(C {(test)} {(-d)} {(DQ ($ VSub_Name '$reference') (/.git/objects))})]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:ref_git)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name '$reference') (/.git))}
                                  spids: [1817]
                                )
                              ]
                              spids: [1817]
                            )
                          ]
                          spids: [16777215 1814]
                        )
                        (if_arm
                          cond: [(C {(test)} {(-d)} {(DQ ($ VSub_Name '$reference') (/objects))})]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:ref_git)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name '$reference'))}
                                  spids: [1839]
                                )
                              ]
                              spids: [1839]
                            )
                          ]
                          spids: [1824 1836]
                        )
                      ]
                      spids: [16777215 1845]
                    )
                  ]
                  spids: [16777215 1799]
                )
              ]
              spids: [16777215 1848]
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name '$ref_git'))})]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:ref_git)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (AndOr
                                        ops: [Op_DAmp]
                                        children: [
                                          (C {(cd)} {(DQ ($ VSub_Name '$ref_git'))})
                                          (C {(pwd)})
                                        ]
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [1866 1876]
                              )
                            }
                          spids: [1865]
                        )
                      ]
                      spids: [1865]
                    )
                    (SimpleCommand
                      words: [{(echo)} {(DQ ($ VSub_Name '$ref_git') (/objects))}]
                      redirects: [
                        (Redir
                          op_id: Redir_Great
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_Name '$GIT_DIR') (/objects/info/alternates))}
                          spids: [1886]
                        )
                      ]
                    )
                    (Pipeline
                      children: [
                        (Subshell
                          child: 
                            (SimpleCommand
                              words: [
                                {(git)}
                                {(for-each-ref)}
                                {(--format) (Lit_Other '=') (SQ <'%(objectname) %(*objectname)'>)}
                              ]
                              more_env: [
                                (env_pair
                                  name: GIT_DIR
                                  val: {(DQ ($ VSub_Name '$ref_git'))}
                                  spids: [1896]
                                )
                              ]
                            )
                          spids: [1893 1914]
                        )
                        (While
                          cond: [(C {(read)} {(a)} {(b)})]
                          body: 
                            (DoGroup
                              children: [
                                (AndOr
                                  ops: [Op_DPipe]
                                  children: [
                                    (C {(test)} {(-z)} {(DQ ($ VSub_Name '$a'))})
                                    (C {(git)} {(update-ref)} 
                                      {(DQ (refs/reference-tmp/) ($ VSub_Name '$a'))} {(DQ ($ VSub_Name '$a'))}
                                    )
                                  ]
                                )
                                (AndOr
                                  ops: [Op_DPipe]
                                  children: [
                                    (C {(test)} {(-z)} {(DQ ($ VSub_Name '$b'))})
                                    (C {(git)} {(update-ref)} 
                                      {(DQ (refs/reference-tmp/) ($ VSub_Name '$b'))} {(DQ ($ VSub_Name '$b'))}
                                    )
                                  ]
                                )
                              ]
                              spids: [1928 1981]
                            )
                        )
                      ]
                      negated: F
                    )
                  ]
                  spids: [16777215 1862]
                )
              ]
              else_action: [
                (C {(die)} 
                  {
                    (DQ ("reference repository '") ($ VSub_Name '$reference') 
                      ("' is not a local directory.")
                    )
                  }
                )
              ]
              spids: [1984 1996]
            )
          ]
          spids: [16777215 1782]
        )
      ]
      spids: [16777215 1998]
    )
    (C {(rm)} {(-f)} {(DQ ($ VSub_Name '$GIT_DIR') (/CLONE_HEAD))})
    (Case
      to_match: {(DQ ($ VSub_Name '$local'))}
      arms: [
        (case_arm
          pat_list: [{(yes)}]
          action: [
            (AndOr
              ops: [Op_DPipe]
              children: [
                (Subshell
                  child: (C {(cd)} {(DQ ($ VSub_Name '$repo') (/objects))})
                  spids: [2026 2035]
                )
                (C {(die)} {(DQ ("cannot chdir to local '") ($ VSub_Name '$repo') ("/objects'."))})
              ]
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(DQ ($ VSub_Name '$local_shared'))} {(Lit_Other '=')} {(yes)})]
                  action: [
                    (C {(mkdir)} {(-p)} {(DQ ($ VSub_Name '$GIT_DIR') (/objects/info))})
                    (SimpleCommand
                      words: [{(echo)} {(DQ ($ VSub_Name '$repo') (/objects))}]
                      redirects: [
                        (Redir
                          op_id: Redir_DGreat
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_Name '$GIT_DIR') (/objects/info/alternates))}
                          spids: [2083]
                        )
                      ]
                    )
                  ]
                  spids: [16777215 2063]
                )
              ]
              else_action: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:cpio_quiet_flag)
                      op: Equal
                      rhs: {(DQ )}
                      spids: [2093]
                    )
                  ]
                  spids: [2093]
                )
                (AndOr
                  ops: [Op_DAmp]
                  children: [
                    (Pipeline
                      children: [
                        (SimpleCommand
                          words: [{(cpio)} {(--help)}]
                          redirects: [(Redir op_id:Redir_GreatAnd fd:2 arg_word:{(1)} spids:[2102])]
                        )
                        (SimpleCommand
                          words: [{(grep)} {(--)} {(--quiet)}]
                          redirects: [
                            (Redir
                              op_id: Redir_Great
                              fd: 16777215
                              arg_word: {(/dev/null)}
                              spids: [2113]
                            )
                          ]
                        )
                      ]
                      negated: F
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:cpio_quiet_flag)
                          op: Equal
                          rhs: {(--quiet)}
                          spids: [2120]
                        )
                      ]
                      spids: [2120]
                    )
                  ]
                )
                (AndOr
                  ops: [Op_DAmp Op_DAmp Op_DAmp Op_DAmp Op_DPipe]
                  children: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:l)
                          op: Equal
                          rhs: {(EmptyPart)}
                          spids: [2124]
                        )
                      ]
                      spids: [2124]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (C {(test)} {(DQ ($ VSub_Name '$use_local_hardlink'))} {(Lit_Other '=')} 
                              {(yes)}
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:sample_file)
                                  op: Equal
                                  rhs: 
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (AndOr
                                                ops: [Op_DAmp]
                                                children: [
                                                  (C {(cd)} {(DQ ($ VSub_Name '$repo'))})
                                                  (Pipeline
                                                    children: [
                                                      (C {(find)} {(objects)} {(-type)} {(f)} {(-print)})
                                                      (C {(sed)} {(-e)} {(1q)})
                                                    ]
                                                    negated: F
                                                  )
                                                ]
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub '$('>
                                        spids: [2150 2178]
                                      )
                                    }
                                  spids: [2149]
                                )
                              ]
                              spids: [2149]
                            )
                            (AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {(test)} {(-f)} 
                                  {(DQ ($ VSub_Name '$repo') (/) ($ VSub_Name '$sample_file'))}
                                )
                                (C {(die)} {(DQ ('fatal: cannot clone empty repository'))})
                              ]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (SimpleCommand
                                      words: [
                                        {(ln)}
                                        {(DQ ($ VSub_Name '$repo') (/) ($ VSub_Name '$sample_file'))}
                                        {(DQ ($ VSub_Name '$GIT_DIR') (/objects/sample))}
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_Great
                                          fd: 2
                                          arg_word: {(/dev/null)}
                                          spids: [2224]
                                        )
                                      ]
                                    )
                                  ]
                                  action: [
                                    (C {(rm)} {(-f)} {(DQ ($ VSub_Name '$GIT_DIR') (/objects/sample))})
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:l)
                                          op: Equal
                                          rhs: {(l)}
                                          spids: [2241]
                                        )
                                      ]
                                      spids: [2241]
                                    )
                                  ]
                                  spids: [16777215 2228]
                                )
                                (if_arm
                                  cond: [
                                    (C {(test)} {(-n)} {(DQ ($ VSub_Name '$local_explicitly_asked_for'))})
                                  ]
                                  action: [
                                    (SimpleCommand
                                      words: [
                                        {(echo)}
                                        {
                                          (DQ ('Warning: -l asked but cannot hardlink to ') 
                                            ($ VSub_Name '$repo')
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_GreatAnd
                                          fd: 16777215
                                          arg_word: {(2)}
                                          spids: [2261]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [2245 2256]
                                )
                              ]
                              spids: [16777215 2270]
                            )
                          ]
                          spids: [16777215 2142]
                        )
                      ]
                      spids: [16777215 2273]
                    )
                    (C {(cd)} {(DQ ($ VSub_Name '$repo'))})
                    (Pipeline
                      children: [
                        (C {(find)} {(objects)} {(-type)} {(d)} {(-print)})
                        (Subshell
                          child: 
                            (AndOr
                              ops: [Op_DAmp]
                              children: [
                                (C {(cd)} {(DQ ($ VSub_Name '$GIT_DIR'))})
                                (C {(xargs)} {(mkdir)} {(-p)})
                              ]
                            )
                          spids: [2303 2317]
                        )
                      ]
                      negated: F
                    )
                    (Pipeline
                      children: [
                        (C {(find)} {(objects)} {(KW_Bang '!')} {(-type)} {(d)} {(-print)})
                        (C {(cpio)} {($ VSub_Name '$cpio_quiet_flag')} {(-pumd) ($ VSub_Name '$l')} 
                          {(DQ ($ VSub_Name '$GIT_DIR') (/))}
                        )
                      ]
                      negated: F
                    )
                    (ControlFlow token:<ControlFlow_Exit exit> arg_word:{(1)})
                  ]
                )
              ]
              spids: [2090 2361]
            )
            (AndOr
              ops: [Op_DPipe]
              children: [
                (SimpleCommand
                  words: [{(git-ls-remote)} {(DQ ($ VSub_Name '$repo'))}]
                  redirects: [
                    (Redir
                      op_id: Redir_Great
                      fd: 16777215
                      arg_word: {(DQ ($ VSub_Name '$GIT_DIR') (/CLONE_HEAD))}
                      spids: [2370]
                    )
                  ]
                )
                (ControlFlow token:<ControlFlow_Exit exit> arg_word:{(1)})
              ]
            )
          ]
          spids: [2022 2023 2383 16777215]
        )
        (case_arm
          pat_list: [{(Lit_Other '*')}]
          action: [
            (Case
              to_match: {(DQ ($ VSub_Name '$repo'))}
              arms: [
                (case_arm
                  pat_list: [{(rsync) (Lit_Other ':') (//) (Lit_Other '*')}]
                  action: [
                    (Case
                      to_match: {(DQ ($ VSub_Name '$depth'))}
                      arms: [
                        (case_arm
                          pat_list: [{(DQ )}]
                          spids: [16777215 2416 2418 16777215]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other '*')}]
                          action: [(C {(die)} {(DQ ('shallow over rsync not supported'))})]
                          spids: [2421 2422 2430 16777215]
                        )
                      ]
                      spids: [2405 2411 2433]
                    )
                    (AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(rsync)} {($ VSub_Name '$quiet')} {(-av)} {(--ignore-existing)} {(--exclude)} 
                          {(info)} {(DQ ($ VSub_Name '$repo') (/objects/))} {(DQ ($ VSub_Name '$GIT_DIR') (/objects/))}
                        )
                        (ControlFlow token:<ControlFlow_Exit exit>)
                      ]
                    )
                    (AndOr
                      ops: [Op_DPipe]
                      children: [
                        (SimpleCommand
                          words: [
                            {(rsync)}
                            {(-q)}
                            {(DQ ($ VSub_Name '$repo') (/objects/info/alternates))}
                            {(DQ ($ VSub_Name '$GIT_DIR') (/TMP_ALT))}
                          ]
                          redirects: [
                            (Redir
                              op_id: Redir_Great
                              fd: 2
                              arg_word: {(/dev/null)}
                              spids: [2494]
                            )
                          ]
                        )
                        (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: [
                                (Subshell
                                  child: 
                                    (AndOr
                                      ops: [Op_DAmp Op_DAmp]
                                      children: [
                                        (C {(cd)} {(DQ ($ VSub_Name '$D'))})
                                        (C {(.)} {(git-parse-remote)})
                                        (SimpleCommand
                                          words: [{(resolve_alternates)} {(DQ ($ VSub_Name '$repo'))}]
                                          redirects: [
                                            (Redir
                                              op_id: Redir_Less
                                              fd: 16777215
                                              arg_word: {(DQ ($ VSub_Name '$GIT_DIR') (/TMP_ALT))}
                                              spids: [2549]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  spids: [2525 2555]
                                )
                                (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: [2579 2582 2589 16777215]
                                            )
                                          ]
                                          spids: [2570 2576 2591]
                                        )
                                        (Case
                                          to_match: {(DQ ($ VSub_Name '$quiet'))}
                                          arms: [
                                            (case_arm
                                              pat_list: [{(SQ )}]
                                              action: [
                                                (SimpleCommand
                                                  words: [
                                                    {(echo)}
                                                    {
                                                      (DQ ('Getting alternate: ') ($ VSub_Name '$alt'))
                                                    }
                                                  ]
                                                  redirects: [
                                                    (Redir
                                                      op_id: Redir_GreatAnd
                                                      fd: 16777215
                                                      arg_word: {(2)}
                                                      spids: [2609]
                                                    )
                                                  ]
                                                )
                                              ]
                                              spids: [16777215 2605 2617 16777215]
                                            )
                                          ]
                                          spids: [2594 2600 2620]
                                        )
                                        (AndOr
                                          ops: [Op_DPipe]
                                          children: [
                                            (C {(rsync)} {($ VSub_Name '$quiet')} {(-av)} 
                                              {(--ignore-existing)} {(--exclude)} {(info)} {(DQ ($ VSub_Name '$alt'))} {(DQ ($ VSub_Name '$GIT_DIR') (/objects))}
                                            )
                                            (ControlFlow
                                              token: <ControlFlow_Exit exit>
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [2567 2651]
                                    )
                                )
                              ]
                              negated: F
                            )
                            (C {(rm)} {(-f)} {(DQ ($ VSub_Name '$GIT_DIR') (/TMP_ALT))})
                          ]
                          spids: [16777215 2522]
                        )
                      ]
                      spids: [16777215 2664]
                    )
                    (AndOr
                      ops: [Op_DPipe]
                      children: [
                        (SimpleCommand
                          words: [{(git-ls-remote)} {(DQ ($ VSub_Name '$repo'))}]
                          redirects: [
                            (Redir
                              op_id: Redir_Great
                              fd: 16777215
                              arg_word: {(DQ ($ VSub_Name '$GIT_DIR') (/CLONE_HEAD))}
                              spids: [2673]
                            )
                          ]
                        )
                        (ControlFlow
                          token: <ControlFlow_Exit exit>
                          arg_word: {(1)}
                        )
                      ]
                    )
                  ]
                  spids: [2398 2402 2686 16777215]
                )
                (case_arm
                  pat_list: [
                    {(https) (Lit_Other ':') (//) (Lit_Other '*')}
                    {(http) (Lit_Other ':') (//) (Lit_Other '*')}
                    {(ftp) (Lit_Other ':') (//) (Lit_Other '*')}
                  ]
                  action: [
                    (Case
                      to_match: {(DQ ($ VSub_Name '$depth'))}
                      arms: [
                        (case_arm
                          pat_list: [{(DQ )}]
                          spids: [16777215 2717 2719 16777215]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other '*')}]
                          action: [(C {(die)} {(DQ ('shallow over http or ftp not supported'))})]
                          spids: [2722 2723 2731 16777215]
                        )
                      ]
                      spids: [2706 2712 2734]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [(C {(test)} {(-z)} {(DQ ('@@NO_CURL@@'))})]
                          action: [
                            (C {(clone_dumb_http)} {(DQ ($ VSub_Name '$repo'))} {(DQ ($ VSub_Name '$D'))})
                          ]
                          spids: [16777215 2748]
                        )
                      ]
                      else_action: [
                        (C {(die)} 
                          {(DQ ('http transport not supported, rebuild Git with curl support'))}
                        )
                      ]
                      spids: [2762 2772]
                    )
                  ]
                  spids: [2689 2703 2775 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(Lit_Other '[')} {(-f)} {(DQ ($ VSub_Name '$repo'))} 
                                  {(Lit_Other ']')}
                                )
                              terminator: <Op_Semi ';'>
                            )
                          ]
                          action: [
                            (AndOr
                              ops: [Op_DPipe]
                              children: [
                                (SimpleCommand
                                  words: [{(git)} {(bundle)} {(unbundle)} {(DQ ($ VSub_Name '$repo'))}]
                                  redirects: [
                                    (Redir
                                      op_id: Redir_Great
                                      fd: 16777215
                                      arg_word: {(DQ ($ VSub_Name '$GIT_DIR') (/CLONE_HEAD))}
                                      spids: [2809]
                                    )
                                  ]
                                )
                                (C {(die)} 
                                  {(DQ ("unbundle from '") ($ VSub_Name '$repo') ("' failed."))}
                                )
                              ]
                            )
                          ]
                          spids: [16777215 2796]
                        )
                      ]
                      else_action: [
                        (AndOr
                          ops: [Op_DPipe]
                          children: [
                            (Case
                              to_match: {(DQ ($ VSub_Name '$upload_pack'))}
                              arms: [
                                (case_arm
                                  pat_list: [{(SQ )}]
                                  action: [
                                    (C {(git-fetch-pack)} {(--all)} {(-k)} {($ VSub_Name '$quiet')} 
                                      {($ VSub_Name '$depth')} {($ VSub_Name '$no_progress')} {(DQ ($ VSub_Name '$repo'))}
                                    )
                                  ]
                                  spids: [16777215 2842 2859 16777215]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Other '*')}]
                                  action: [
                                    (C {(git-fetch-pack)} {(--all)} {(-k)} {($ VSub_Name '$quiet')} 
                                      {(DQ ($ VSub_Name '$upload_pack'))} {($ VSub_Name '$depth')} {($ VSub_Name '$no_progress')} {(DQ ($ VSub_Name '$repo'))}
                                    )
                                  ]
                                  spids: [2862 2863 2887 16777215]
                                )
                              ]
                              redirects: [
                                (Redir
                                  op_id: Redir_Great
                                  fd: 16777215
                                  arg_word: {(DQ ($ VSub_Name '$GIT_DIR') (/CLONE_HEAD))}
                                  spids: [2892]
                                )
                              ]
                              spids: [2831 2837 2890]
                            )
                            (C {(die)} {(DQ ("fetch-pack from '") ($ VSub_Name '$repo') ("' failed."))})
                          ]
                        )
                      ]
                      spids: [2828 2910]
                    )
                  ]
                  spids: [2778 2779 2913 16777215]
                )
              ]
              spids: [2389 2395 2916]
            )
          ]
          spids: [2385 2386 2919 16777215]
        )
      ]
      spids: [2014 2020 2921]
    )
    (AndOr
      ops: [Op_DAmp]
      children: [
        (C {(test)} {(-d)} {(DQ ($ VSub_Name '$GIT_DIR') (/refs/reference-tmp))})
        (C {(rm)} {(-fr)} {(DQ ($ VSub_Name '$GIT_DIR') (/refs/reference-tmp))})
      ]
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-f)} {(DQ ($ VSub_Name '$GIT_DIR') (/CLONE_HEAD))})]
          action: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (C {(Lit_Other '[')} {(-n)} {(DQ ($ VSub_Name '$use_separate_remote'))} 
                      {(Lit_Other ']')}
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:branch_top)
                          op: Equal
                          rhs: {(DQ (remotes/) ($ VSub_Name '$origin'))}
                          spids: [2978]
                        )
                      ]
                      spids: [2978]
                    )
                  ]
                  spids: [16777215 2975]
                )
              ]
              else_action: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:branch_top)
                      op: Equal
                      rhs: {(DQ (heads))}
                      spids: [2988]
                    )
                  ]
                  spids: [2988]
                )
              ]
              spids: [2985 2994]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:tag_top)
                  op: Equal
                  rhs: {(DQ (tags))}
                  spids: [2997]
                )
              ]
              spids: [2997]
            )
            (While
              cond: [(C {(read)} {(sha1)} {(name)})]
              body: 
                (DoGroup
                  children: [
                    (Case
                      to_match: {(DQ ($ VSub_Name '$name'))}
                      arms: [
                        (case_arm
                          pat_list: [{(Lit_Other '*') (SQ <'^{}'>)}]
                          action: [(ControlFlow token:<ControlFlow_Continue continue>)]
                          spids: [3024 3028 3033 16777215]
                        )
                        (case_arm
                          pat_list: [{(HEAD)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:destname)
                                  op: Equal
                                  rhs: {(DQ (REMOTE_HEAD))}
                                  spids: [3040]
                                )
                              ]
                              spids: [3040]
                            )
                          ]
                          spids: [3036 3037 3045 16777215]
                        )
                        (case_arm
                          pat_list: [{(refs/heads/) (Lit_Other '*')}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:destname)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ (refs/) ($ VSub_Name '$branch_top') (/) 
                                        (BracedVarSub
                                          token: <VSub_Name name>
                                          suffix_op: 
                                            (StringUnary
                                              op_id: VOp1_Pound
                                              arg_word: {(refs) (Lit_Slash /) (heads) (Lit_Slash /)}
                                            )
                                          spids: [3058 3065]
                                        )
                                      )
                                    }
                                  spids: [3053]
                                )
                              ]
                              spids: [3053]
                            )
                          ]
                          spids: [3048 3050 3068 16777215]
                        )
                        (case_arm
                          pat_list: [{(refs/tags/) (Lit_Other '*')}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:destname)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ (refs/) ($ VSub_Name '$tag_top') (/) 
                                        (BracedVarSub
                                          token: <VSub_Name name>
                                          suffix_op: 
                                            (StringUnary
                                              op_id: VOp1_Pound
                                              arg_word: {(refs) (Lit_Slash /) (tags) (Lit_Slash /)}
                                            )
                                          spids: [3081 3088]
                                        )
                                      )
                                    }
                                  spids: [3076]
                                )
                              ]
                              spids: [3076]
                            )
                          ]
                          spids: [3071 3073 3091 16777215]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other '*')}]
                          action: [(ControlFlow token:<ControlFlow_Continue continue>)]
                          spids: [3094 3095 3100 16777215]
                        )
                      ]
                      spids: [3015 3021 3103]
                    )
                    (C {(git)} {(update-ref)} {(-m)} {(DQ ('clone: from ') ($ VSub_Name '$repo'))} 
                      {(DQ ($ VSub_Name '$destname'))} {(DQ ($ VSub_Name '$sha1'))} {(DQ )}
                    )
                  ]
                  spids: [3012 3129]
                )
              redirects: [
                (Redir
                  op_id: Redir_Less
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_Name '$GIT_DIR') (/CLONE_HEAD))}
                  spids: [3131]
                )
              ]
            )
          ]
          spids: [16777215 2955]
        )
      ]
      spids: [16777215 3138]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: (C {(test)} {(-n)} {(DQ ($ VSub_Name '$W'))})
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (AndOr
              ops: [Op_DPipe]
              children: [
                (C {(cd)} {(DQ ($ VSub_Name '$W'))})
                (ControlFlow token:<ControlFlow_Exit exit>)
              ]
            )
          ]
          spids: [16777215 3152]
        )
      ]
      else_action: [
        (AndOr
          ops: [Op_DPipe]
          children: [(C {(cd)} {(DQ ($ VSub_Name '$D'))}) (ControlFlow token:<ControlFlow_Exit exit>)]
        )
      ]
      spids: [3165 3178]
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name '$bare'))})]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:remote_top)
                  op: Equal
                  rhs: {(DQ (refs/remotes/) ($ VSub_Name '$origin'))}
                  spids: [3198]
                )
              ]
              spids: [3198]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:head_sha1)
                  op: Equal
                  rhs: {(EmptyPart)}
                  spids: [3205]
                )
              ]
              spids: [3205]
            )
            (AndOr
              ops: [Op_DPipe]
              children: [
                (C {(test)} {(KW_Bang '!')} {(-r)} {(DQ ($ VSub_Name '$GIT_DIR') (/REMOTE_HEAD))})
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:head_sha1)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [(C {(cat)} {(DQ ($ VSub_Name '$GIT_DIR') (/REMOTE_HEAD))})]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [3222 3229]
                          )
                        }
                      spids: [3221]
                    )
                  ]
                  spids: [3221]
                )
              ]
            )
            (Case
              to_match: {(DQ ($ VSub_Name '$head_sha1'))}
              arms: [
                (case_arm
                  pat_list: [{(SQ <'ref: refs/'>) (Lit_Other '*')}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:head_sha1)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(expr)} {(DQ (z) ($ VSub_Name '$head_sha1'))} 
                                        {(Lit_Other ':')} {(SQ <'zref: refs/heads/\\(.*\\)'>)}
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [3265 3278]
                              )
                            }
                          spids: [3264]
                        )
                      ]
                      spids: [3264]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:head_sha1)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(cat)} 
                                        {
                                          (DQ ($ VSub_Name '$GIT_DIR') (/) ($ VSub_Name '$remote_top') 
                                            (/) ($ VSub_Name '$head_sha1')
                                          )
                                        }
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [3282 3292]
                              )
                            }
                          spids: [3281]
                        )
                      ]
                      spids: [3281]
                    )
                  ]
                  spids: [3242 3245 3295 16777215]
                )
              ]
              spids: [3232 3238 3298]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:head_points_at)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (Pipeline
                                children: [
                                  (Subshell
                                    child: 
                                      (CommandList
                                        children: [
                                          (AndOr
                                            ops: [Op_DAmp]
                                            children: [
                                              (C {(test)} {(-f)} 
                                                {
                                                  (DQ ($ VSub_Name '$GIT_DIR') (/) 
                                                    ($ VSub_Name '$remote_top') (/master)
                                                  )
                                                }
                                              )
                                              (C {(echo)} {(DQ (master))})
                                            ]
                                          )
                                          (AndOr
                                            ops: [Op_DAmp]
                                            children: [
                                              (C {(cd)} 
                                                {
                                                  (DQ ($ VSub_Name '$GIT_DIR') (/) 
                                                    ($ VSub_Name '$remote_top')
                                                  )
                                                }
                                              )
                                              (Pipeline
                                                children: [
                                                  (C {(find)} {(.)} {(-type)} {(f)} {(-print)})
                                                  (C {(sed)} {(-e)} {(SQ <'s/^\\.\\///'>)})
                                                ]
                                                negated: F
                                              )
                                            ]
                                          )
                                        ]
                                      )
                                    spids: [3310 3365]
                                  )
                                  (Subshell
                                    child: 
                                      (CommandList
                                        children: [
                                          (Assignment
                                            keyword: Assign_None
                                            pairs: [
                                              (assign_pair
                                                lhs: (LhsName name:done)
                                                op: Equal
                                                rhs: {(f)}
                                                spids: [3372]
                                              )
                                            ]
                                            spids: [3372]
                                          )
                                          (While
                                            cond: [(C {(read)} {(name)})]
                                            body: 
                                              (DoGroup
                                                children: [
                                                  (AndOr
                                                    ops: [Op_DAmp]
                                                    children: [
                                                      (C {(test)} {(t)} {(Lit_Other '=')} 
                                                        {($ VSub_Name '$done')}
                                                      )
                                                      (ControlFlow
                                                        token: <ControlFlow_Continue continue>
                                                      )
                                                    ]
                                                  )
                                                  (Assignment
                                                    keyword: Assign_None
                                                    pairs: [
                                                      (assign_pair
                                                        lhs: (LhsName name:branch_tip)
                                                        op: Equal
                                                        rhs: 
                                                          {
                                                            (CommandSubPart
                                                              command_list: 
                                                                (CommandList
                                                                  children: [
                                                                    (C {(cat)} 
                                                                      {
                                                                        (DQ ($ VSub_Name '$GIT_DIR') 
                                                                          (/) ($ VSub_Name '$remote_top') (/) ($ VSub_Name '$name')
                                                                        )
                                                                      }
                                                                    )
                                                                  ]
                                                                )
                                                              left_token: <Left_CommandSub '$('>
                                                              spids: [3400 3410]
                                                            )
                                                          }
                                                        spids: [3399]
                                                      )
                                                    ]
                                                    spids: [3399]
                                                  )
                                                  (If
                                                    arms: [
                                                      (if_arm
                                                        cond: [
                                                          (C {(test)} {(DQ ($ VSub_Name '$head_sha1'))} 
                                                            {(Lit_Other '=')} {(DQ ($ VSub_Name '$branch_tip'))}
                                                          )
                                                        ]
                                                        action: [
                                                          (C {(echo)} {(DQ ($ VSub_Name '$name'))})
                                                          (Assignment
                                                            keyword: Assign_None
                                                            pairs: [
                                                              (assign_pair
                                                                lhs: (LhsName name:done)
                                                                op: Equal
                                                                rhs: {(t)}
                                                                spids: [3438]
                                                              )
                                                            ]
                                                            spids: [3438]
                                                          )
                                                        ]
                                                        spids: [16777215 3428]
                                                      )
                                                    ]
                                                    spids: [16777215 3442]
                                                  )
                                                ]
                                                spids: [3383 3445]
                                              )
                                          )
                                        ]
                                      )
                                    spids: [3369 3448]
                                  )
                                ]
                                negated: F
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [3307 3451]
                      )
                    }
                  spids: [3306]
                )
              ]
              spids: [3306]
            )
            (AndOr
              ops: [Op_DAmp Op_DAmp]
              children: [
                (C {(git)} {(config)} {(remote.) (DQ ($ VSub_Name '$origin')) (.url)} 
                  {(DQ ($ VSub_Name '$repo'))}
                )
                (C {(git)} {(config)} {(remote.) (DQ ($ VSub_Name '$origin')) (.fetch)} 
                  {(DQ ('+refs/heads/*:') ($ VSub_Name '$remote_top') ('/*'))} {(SQ <'^$'>)}
                )
                (Case
                  to_match: {(DQ ($ VSub_Name '$head_points_at'))}
                  arms: [
                    (case_arm
                      pat_list: [{(Lit_Other '?') (Lit_Other '*')}]
                      action: [
                        (AndOr
                          ops: [Op_DAmp Op_DAmp]
                          children: [
                            (C {(git)} {(symbolic-ref)} {(HEAD)} 
                              {(DQ (refs/heads/) ($ VSub_Name '$head_points_at'))}
                            )
                            (C {(git)} {(update-ref)} {(HEAD)} {(DQ ($ VSub_Name '$head_sha1'))})
                            (C {(rm)} {(-f)} {(DQ (refs/remotes/) ($ VSub_Name '$origin') (/HEAD))})
                          ]
                        )
                        (AndOr
                          ops: [Op_DAmp Op_DAmp]
                          children: [
                            (C {(git)} {(symbolic-ref)} 
                              {(DQ (refs/remotes/) ($ VSub_Name '$origin') (/HEAD))} {(DQ (refs/remotes/) ($ VSub_Name '$origin') (/) ($ VSub_Name '$head_points_at'))}
                            )
                            (C {(git)} {(config)} 
                              {(branch.) (DQ ($ VSub_Name '$head_points_at')) (.remote)} {(DQ ($ VSub_Name '$origin'))}
                            )
                            (C {(git)} {(config)} 
                              {(branch.) (DQ ($ VSub_Name '$head_points_at')) (.merge)} {(DQ (refs/heads/) ($ VSub_Name '$head_points_at'))}
                            )
                          ]
                        )
                      ]
                      spids: [3520 3522 3629 16777215]
                    )
                    (case_arm
                      pat_list: [{(SQ )}]
                      action: [
                        (If
                          arms: [
                            (if_arm
                              cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name '$head_sha1'))})]
                              action: [
                                (SimpleCommand
                                  words: [
                                    {(echo)}
                                    {
                                      (DQ 
                                        (
'Warning: Remote HEAD refers to nonexistent ref, unable to checkout.'
                                        )
                                      )
                                    }
                                  ]
                                  redirects: [
                                    (Redir
                                      op_id: Redir_GreatAnd
                                      fd: 16777215
                                      arg_word: {(2)}
                                      spids: [3657]
                                    )
                                  ]
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:no_checkout)
                                      op: Equal
                                      rhs: {(t)}
                                      spids: [3665]
                                    )
                                  ]
                                  spids: [3665]
                                )
                              ]
                              spids: [16777215 3648]
                            )
                          ]
                          else_action: [
                            (AndOr
                              ops: [Op_DAmp]
                              children: [
                                (C {(git)} {(update-ref)} {(--no-deref)} {(HEAD)} 
                                  {(DQ ($ VSub_Name '$head_sha1'))}
                                )
                                (C {(rm)} {(-f)} {(DQ (refs/remotes/) ($ VSub_Name '$origin') (/HEAD))})
                              ]
                            )
                          ]
                          spids: [3669 3702]
                        )
                      ]
                      spids: [16777215 3634 3705 16777215]
                    )
                  ]
                  spids: [3511 3517 3708]
                )
              ]
            )
            (Case
              to_match: {(DQ ($ VSub_Name '$no_checkout'))}
              arms: [
                (case_arm
                  pat_list: [{(SQ )}]
                  action: [
                    (AndOr
                      ops: [Op_DAmp Op_DAmp Op_DPipe]
                      children: [
                        (C {(test)} {(DQ (z) ($ VSub_Name '$quiet'))} {(Lit_Other '=')} {(z)})
                        (C {(test)} {(DQ (z) ($ VSub_Name '$no_progress'))} {(Lit_Other '=')} {(z)})
                        (Assignment
                          keyword: Assign_None
                          pairs: [(assign_pair lhs:(LhsName name:v) op:Equal rhs:{(-v)} spids:[3752])]
                          spids: [3752]
                        )
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:v)
                              op: Equal
                              rhs: {(EmptyPart)}
                              spids: [3757]
                            )
                          ]
                          spids: [3757]
                        )
                      ]
                    )
                    (C {(git)} {(read-tree)} {(-m)} {(-u)} {($ VSub_Name '$v')} {(HEAD)} {(HEAD)})
                  ]
                  spids: [16777215 3723 16777215 3775]
                )
              ]
              spids: [3712 3718 3775]
            )
          ]
          spids: [16777215 3191]
        )
      ]
      spids: [16777215 3777]
    )
    (C {(rm)} {(-f)} {(DQ ($ VSub_Name '$GIT_DIR') (/CLONE_HEAD))} 
      {(DQ ($ VSub_Name '$GIT_DIR') (/REMOTE_HEAD))}
    )
    (C {(trap)} {(-)} {(0)})
  ]
)