(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:-1 arg_word:{(2)} spids:[59])]
            )
            (C {(exit)} {(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
                    children: [
                      (Pipeline
                        children: [
                          (C {(echo)} {(DQ ($ VSub_Name "$OPTIONS_SPEC"))})
                          (C {(git)} {(rev-parse)} {(--parseopt)} {(--)} {(DQ ($ VSub_At "$@"))})
                        ]
                        negated: False
                      )
                      (C {(echo)} {(exit)} {($ VSub_QMark "$?")})
                    ]
                    op_id: Op_DPipe
                  )
                ]
              )
            left_token: <Left_CommandSub "$(">
            spids: [95 123]
          )
        )
      }
    )
    (FuncDef
      name: get_repo_base
      body: 
        (BraceGroup
          children: [
            (Subshell
              child: 
                (AndOr
                  children: [
                    (C {(cd)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: (CommandList children:[(C {(/bin/pwd)})])
                            left_token: <Left_CommandSub "$(">
                            spids: [140 142]
                          )
                        )
                      }
                    )
                    (AndOr
                      children: [
                        (C {(cd)} {(DQ ($ VSub_Number "$1"))})
                        (AndOr
                          children: [
                            (C {(cd)} {(DQ ($ VSub_Number "$1") (.git))})
                            (BraceGroup
                              children: [(C {(cd)} {(.git)}) (C {(pwd)})]
                              spids: [166]
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  op_id: Op_DAmp
                )
              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: [-1 221]
        )
      ]
      spids: [-1 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: -1
                  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: [(C {(exit)})]
                  spids: [271 274 278 -1]
                )
                (case_arm
                  pat_list: [{(Lit_Other "*")}]
                  action: [
                    (ControlFlow
                      token: <ControlFlow_Return return>
                      arg_word: {($ VSub_Name "$curl_exit_status")}
                    )
                  ]
                  spids: [281 282 288 -1]
                )
              ]
              spids: [264 268 291]
            )
          ]
          spids: [237]
        )
      spids: [232 236]
    )
    (FuncDef
      name: clone_dumb_http
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(cd)} {(DQ ($ VSub_Number "$2"))})
                (AndOr
                  children: [
                    (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]
                    )
                    (AndOr
                      children: [
                        (C {(mkdir)} {(-p)} {(DQ ($ VSub_Name "$clone_tmp"))})
                        (C {(exit)} {(1)})
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
            (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: [-1 374]
                )
              ]
              spids: [-1 386]
            )
            (AndOr
              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?")
                    )
                  }
                )
              ]
              op_id: Op_DPipe
            )
            (AndOr
              children: [
                (C {(test)} {(DQ (z) ($ VSub_Name "$quiet"))} {(Lit_Other "=")} {(z)})
                (AndOr
                  children: [
                    (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:{(SQ )} spids:[430])]
                      spids: [430]
                    )
                  ]
                  op_id: Op_DPipe
                )
              ]
              op_id: Op_DAmp
            )
            (While
              cond: [(C {(read)} {(sha1)} {(refname)})]
              body: 
                (DoGroup
                  children: [
                    (AndOr
                      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 -1]
                            )
                          ]
                          spids: [464 470 482]
                        )
                      ]
                      op_id: Op_DAmp
                    )
                    (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 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [(ControlFlow token:<ControlFlow_Continue continue>)]
                          spids: [516 517 521 -1]
                        )
                      ]
                      spids: [485 493 524]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (AndOr
                              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]
                                )
                              ]
                              op_id: Op_DAmp
                            )
                          ]
                          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: [-1 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
                      children: [
                        (C {(git-http-fetch)} {($ VSub_Name "$v")} {(-a)} {(-w)} 
                          {(DQ ($ VSub_Name "$tname"))} {(DQ ($ VSub_Name "$sha1"))} {(DQ ($ VSub_Number "$1"))}
                        )
                        (C {(exit)} {(1)})
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  spids: [442 606]
                )
              redirects: [
                (Redir
                  op_id: Redir_Less
                  fd: -1
                  arg_word: {(DQ ($ VSub_Name "$clone_tmp") (/refs))}
                  spids: [608]
                )
              ]
            )
            (C {(rm)} {(-fr)} {(DQ ($ VSub_Name "$clone_tmp"))})
            (AndOr
              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))})
              ]
              op_id: Op_DPipe
            )
            (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 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [
                            (AndOr
                              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))})
                              ]
                              op_id: Op_DPipe
                            )
                          ]
                          spids: [694 695 725 -1]
                        )
                      ]
                      spids: [675 681 728]
                    )
                  ]
                  spids: [-1 661]
                )
              ]
              spids: [-1 731]
            )
          ]
          spids: [301]
        )
      spids: [296 300]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:quiet) op:Equal rhs:{(SQ )} 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:{(SQ )} spids:[751])]
      spids: [751]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:upload_pack) op:Equal rhs:{(SQ )} spids:[753])]
      spids: [753]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:bare) op:Equal rhs:{(SQ )} spids:[755])]
      spids: [755]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:reference) op:Equal rhs:{(SQ )} spids:[757])]
      spids: [757]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:origin) op:Equal rhs:{(SQ )} spids:[759])]
      spids: [759]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:origin_override) op:Equal rhs:{(SQ )} 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:{(SQ )} spids:[766])]
      spids: [766]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:no_progress) op:Equal rhs:{(SQ )} spids:[768])]
      spids: [768]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:local_explicitly_asked_for)
          op: Equal
          rhs: {(SQ )}
          spids: [770]
        )
      ]
      spids: [770]
    )
    (AndOr
      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]
        )
      ]
      op_id: Op_DPipe
    )
    (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 -1]
                )
                (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 -1]
                )
                (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 -1]
                )
                (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 -1]
                )
                (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 -1]
                )
                (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 -1]
                )
                (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 -1]
                )
                (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 -1]
                )
                (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 -1]
                )
                (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: [-1 949 954 -1]
                        )
                        (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 -1 972]
                        )
                      ]
                      spids: [938 944 972]
                    )
                    (AndOr
                      children: [
                        (C {(git)} {(check-ref-format)} {(DQ (heads/) ($ VSub_Number "$1"))})
                        (C {(die)} 
                          {(DQ ("'") ($ VSub_Number "$1") ("' is not suitable for a branch name"))}
                        )
                      ]
                      op_id: Op_DPipe
                    )
                    (AndOr
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_Name "$origin_override"))})
                        (C {(die)} {(DQ ("Do not give more than one --origin options."))})
                      ]
                      op_id: Op_DPipe
                    )
                    (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 -1]
                )
                (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 -1]
                )
                (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 -1]
                )
                (case_arm
                  pat_list: [{(--)}]
                  action: [(C {(shift)}) (ControlFlow token:<ControlFlow_Break break>)]
                  spids: [1061 1062 1070 -1]
                )
                (case_arm
                  pat_list: [{(Lit_Other "*")}]
                  action: [(C {(usage)})]
                  spids: [1073 1074 1079 -1]
                )
              ]
              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
      children: [
        (C {(test)} {(-n)} {(DQ ($ VSub_Name "$repo"))})
        (C {(die)} {(SQ <"you must specify a repository to clone.">)})
      ]
      op_id: Op_DPipe
    )
    (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: [-1 1144]
                )
              ]
              spids: [-1 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: {(SQ )}
                  spids: [1161]
                )
              ]
              spids: [1161]
            )
          ]
          spids: [-1 1128]
        )
      ]
      spids: [-1 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: [-1 1176]
        )
      ]
      spids: [-1 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: [-1 1223]
                )
              ]
              spids: [-1 1230]
            )
          ]
          spids: [-1 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:[125312551257-1])
                (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 -1]
                )
              ]
              spids: [1245 1251 1271]
            )
          ]
          spids: [1232 1242]
        )
      ]
      spids: [-1 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
              children: [
                (C {(test)} {($ VSub_Pound "$#")} {(Lit_Other "=")} {(2)})
                (C {(die)} {(DQ ("excess parameter to git-clone"))})
              ]
              op_id: Op_DPipe
            )
          ]
          spids: [-1 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: False
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [1344 1366]
                          )
                        }
                      spids: [1343]
                    )
                  ]
                  spids: [1343]
                )
              ]
              spids: [-1 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: False
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [1373 1402]
                      )
                    }
                  spids: [1372]
                )
              ]
              spids: [1372]
            )
          ]
          spids: [1369 1405]
        )
      ]
      spids: [1314 1407]
    )
    (AndOr
      children: [
        (C {(Lit_Other "[")} {(-e)} {(DQ ($ VSub_Name "$dir"))} {(Lit_Other "]")})
        (C {(die)} {(DQ ("destination directory '") ($ VSub_Name "$dir") ("' already exists."))})
      ]
      op_id: Op_DAmp
    )
    (AndOr
      children: [
        (C {(Lit_Other "[")} {(yes)} {(Lit_Other "=")} {(DQ ($ VSub_Name "$bare"))} {(Lit_Other "]")})
        (C {(unset)} {(GIT_WORK_TREE)})
      ]
      op_id: Op_DAmp
    )
    (AndOr
      children: [
        (C {(Lit_Other "[")} {(-n)} {(DQ ($ VSub_Name "$GIT_WORK_TREE"))} {(Lit_Other "]")})
        (AndOr
          children: [
            (C {(Lit_Other "[")} {(-e)} {(DQ ($ VSub_Name "$GIT_WORK_TREE"))} {(Lit_Other "]")})
            (C {(die)} {(DQ ("working tree '") ($ VSub_Name "$GIT_WORK_TREE") ("' already exists."))})
          ]
          op_id: Op_DAmp
        )
      ]
      op_id: Op_DAmp
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:D) op:Equal rhs:{(SQ )} spids:[1480])]
      spids: [1480]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:W) op:Equal rhs:{(SQ )} spids:[1482])]
      spids: [1482]
    )
    (FuncDef
      name: cleanup
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_Name "$D"))})
                (C {(rm)} {(-rf)} {(DQ ($ VSub_Name "$dir"))})
              ]
              op_id: Op_DAmp
            )
            (AndOr
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_Name "$W"))})
                (AndOr
                  children: [
                    (C {(test)} {(-n)} {(DQ ($ VSub_Name "$GIT_WORK_TREE"))})
                    (C {(rm)} {(-rf)} {(DQ ($ VSub_Name "$GIT_WORK_TREE"))})
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
            (C {(cd)} {(..)})
            (AndOr
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$D"))})
                (C {(rm)} {(-rf)} {(DQ ($ VSub_Name "$D"))})
              ]
              op_id: Op_DAmp
            )
            (AndOr
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$W"))})
                (C {(rm)} {(-rf)} {(DQ ($ VSub_Name "$W"))})
              ]
              op_id: Op_DAmp
            )
            (C {(exit)} {($ VSub_Name "$err")})
          ]
          spids: [1488]
        )
      spids: [1484 1487]
    )
    (C {(trap)} {(SQ <"err=$?; cleanup">)} {(0)})
    (AndOr
      children: [
        (C {(mkdir)} {(-p)} {(DQ ($ VSub_Name "$dir"))})
        (AndOr
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:D)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (AndOr
                                children: [(C {(cd)} {(DQ ($ VSub_Name "$dir"))}) (C {(pwd)})]
                                op_id: Op_DAmp
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [1607 1617]
                      )
                    }
                  spids: [1606]
                )
              ]
              spids: [1606]
            )
            (C {(usage)})
          ]
          op_id: Op_DPipe
        )
      ]
      op_id: Op_DAmp
    )
    (AndOr
      children: [
        (C {(test)} {(-n)} {(DQ ($ VSub_Name "$GIT_WORK_TREE"))})
        (AndOr
          children: [
            (C {(mkdir)} {(-p)} {(DQ ($ VSub_Name "$GIT_WORK_TREE"))})
            (AndOr
              children: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:W)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (AndOr
                                    children: [
                                      (C {(cd)} {(DQ ($ VSub_Name "$GIT_WORK_TREE"))})
                                      (C {(pwd)})
                                    ]
                                    op_id: Op_DAmp
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [1644 1654]
                          )
                        }
                      spids: [1643]
                    )
                  ]
                  spids: [1643]
                )
                (AndOr
                  children: [
                    (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)})
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
          ]
          op_id: Op_DAmp
        )
      ]
      op_id: Op_DAmp
    )
    (AndOr
      children: [
        (If
          arms: [
            (if_arm
              cond: [
                (Sentence
                  child: 
                    (AndOr
                      children: [
                        (C {(test)} {(yes)} {(Lit_Other "=")} {(DQ ($ VSub_Name "$bare"))})
                        (C {(test)} {(-n)} {(DQ ($ VSub_Name "$GIT_WORK_TREE"))})
                      ]
                      op_id: Op_DPipe
                    )
                  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: [-1 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]
        )
        (AndOr
          children: [
            (C {(export)} {(GIT_DIR)})
            (AndOr
              children: [
                (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)})
              ]
              op_id: Op_DPipe
            )
          ]
          op_id: Op_DAmp
        )
      ]
      op_id: Op_DAmp
    )
    (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: [-1 1752]
        )
      ]
      spids: [-1 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:{(SQ )} 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: [-1 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: [-1 1845]
                    )
                  ]
                  spids: [-1 1799]
                )
              ]
              spids: [-1 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
                                        children: [
                                          (C {(cd)} {(DQ ($ VSub_Name "$ref_git"))})
                                          (C {(pwd)})
                                        ]
                                        op_id: Op_DAmp
                                      )
                                    ]
                                  )
                                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: -1
                          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
                                  children: [
                                    (C {(test)} {(-z)} {(DQ ($ VSub_Name "$a"))})
                                    (C {(git)} {(update-ref)} 
                                      {(DQ (refs/reference-tmp/) ($ VSub_Name "$a"))} {(DQ ($ VSub_Name "$a"))}
                                    )
                                  ]
                                  op_id: Op_DPipe
                                )
                                (AndOr
                                  children: [
                                    (C {(test)} {(-z)} {(DQ ($ VSub_Name "$b"))})
                                    (C {(git)} {(update-ref)} 
                                      {(DQ (refs/reference-tmp/) ($ VSub_Name "$b"))} {(DQ ($ VSub_Name "$b"))}
                                    )
                                  ]
                                  op_id: Op_DPipe
                                )
                              ]
                              spids: [1928 1981]
                            )
                        )
                      ]
                      negated: False
                    )
                  ]
                  spids: [-1 1862]
                )
              ]
              else_action: [
                (C {(die)} 
                  {
                    (DQ ("reference repository '") ($ VSub_Name "$reference") 
                      ("' is not a local directory.")
                    )
                  }
                )
              ]
              spids: [1984 1996]
            )
          ]
          spids: [-1 1782]
        )
      ]
      spids: [-1 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
              children: [
                (Subshell
                  child: (C {(cd)} {(DQ ($ VSub_Name "$repo") (/objects))})
                  spids: [2026 2035]
                )
                (C {(die)} {(DQ ("cannot chdir to local '") ($ VSub_Name "$repo") ("/objects'."))})
              ]
              op_id: Op_DPipe
            )
            (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: -1
                          arg_word: {(DQ ($ VSub_Name "$GIT_DIR") (/objects/info/alternates))}
                          spids: [2083]
                        )
                      ]
                    )
                  ]
                  spids: [-1 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
                  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: -1
                              arg_word: {(/dev/null)}
                              spids: [2113]
                            )
                          ]
                        )
                      ]
                      negated: False
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:cpio_quiet_flag)
                          op: Equal
                          rhs: {(--quiet)}
                          spids: [2120]
                        )
                      ]
                      spids: [2120]
                    )
                  ]
                  op_id: Op_DAmp
                )
                (AndOr
                  children: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(LhsName name:l) op:Equal rhs:{(SQ )} spids:[2124])]
                      spids: [2124]
                    )
                    (AndOr
                      children: [
                        (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
                                                    children: [
                                                      (C {(cd)} {(DQ ($ VSub_Name "$repo"))})
                                                      (Pipeline
                                                        children: [
                                                          (C {(find)} {(objects)} {(-type)} {(f)} 
                                                            {(-print)}
                                                          )
                                                          (C {(sed)} {(-e)} {(1q)})
                                                        ]
                                                        negated: False
                                                      )
                                                    ]
                                                    op_id: Op_DAmp
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub "$(">
                                            spids: [2150 2178]
                                          )
                                        }
                                      spids: [2149]
                                    )
                                  ]
                                  spids: [2149]
                                )
                                (AndOr
                                  children: [
                                    (C {(test)} {(-f)} 
                                      {(DQ ($ VSub_Name "$repo") (/) ($ VSub_Name "$sample_file"))}
                                    )
                                    (C {(die)} {(DQ ("fatal: cannot clone empty repository"))})
                                  ]
                                  op_id: Op_DPipe
                                )
                                (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: [-1 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: -1
                                              arg_word: {(2)}
                                              spids: [2261]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [2245 2256]
                                    )
                                  ]
                                  spids: [-1 2270]
                                )
                              ]
                              spids: [-1 2142]
                            )
                          ]
                          spids: [-1 2273]
                        )
                        (AndOr
                          children: [
                            (C {(cd)} {(DQ ($ VSub_Name "$repo"))})
                            (AndOr
                              children: [
                                (Pipeline
                                  children: [
                                    (C {(find)} {(objects)} {(-type)} {(d)} {(-print)})
                                    (Subshell
                                      child: 
                                        (AndOr
                                          children: [
                                            (C {(cd)} {(DQ ($ VSub_Name "$GIT_DIR"))})
                                            (C {(xargs)} {(mkdir)} {(-p)})
                                          ]
                                          op_id: Op_DAmp
                                        )
                                      spids: [2303 2317]
                                    )
                                  ]
                                  negated: False
                                )
                                (AndOr
                                  children: [
                                    (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: False
                                    )
                                    (C {(exit)} {(1)})
                                  ]
                                  op_id: Op_DPipe
                                )
                              ]
                              op_id: Op_DAmp
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  op_id: Op_DAmp
                )
              ]
              spids: [2090 2361]
            )
            (AndOr
              children: [
                (SimpleCommand
                  words: [{(git-ls-remote)} {(DQ ($ VSub_Name "$repo"))}]
                  redirects: [
                    (Redir
                      op_id: Redir_Great
                      fd: -1
                      arg_word: {(DQ ($ VSub_Name "$GIT_DIR") (/CLONE_HEAD))}
                      spids: [2370]
                    )
                  ]
                )
                (C {(exit)} {(1)})
              ]
              op_id: Op_DPipe
            )
          ]
          spids: [2022 2023 2383 -1]
        )
        (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:[-124162418-1])
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [(C {(die)} {(DQ ("shallow over rsync not supported"))})]
                          spids: [2421 2422 2430 -1]
                        )
                      ]
                      spids: [2405 2411 2433]
                    )
                    (AndOr
                      children: [
                        (C {(rsync)} {($ VSub_Name "$quiet")} {(-av)} {(--ignore-existing)} {(--exclude)} 
                          {(info)} {(DQ ($ VSub_Name "$repo") (/objects/))} {(DQ ($ VSub_Name "$GIT_DIR") (/objects/))}
                        )
                        (C {(exit)})
                      ]
                      op_id: Op_DPipe
                    )
                    (AndOr
                      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))})
                      ]
                      op_id: Op_DPipe
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [(C {(test)} {(-f)} {(DQ ($ VSub_Name "$GIT_DIR") (/TMP_ALT))})]
                          action: [
                            (Pipeline
                              children: [
                                (Subshell
                                  child: 
                                    (AndOr
                                      children: [
                                        (C {(cd)} {(DQ ($ VSub_Name "$D"))})
                                        (AndOr
                                          children: [
                                            (C {(.)} {(git-parse-remote)})
                                            (SimpleCommand
                                              words: [
                                                {(resolve_alternates)}
                                                {(DQ ($ VSub_Name "$repo"))}
                                              ]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_Less
                                                  fd: -1
                                                  arg_word: {(DQ ($ VSub_Name "$GIT_DIR") (/TMP_ALT))}
                                                  spids: [2549]
                                                )
                                              ]
                                            )
                                          ]
                                          op_id: Op_DAmp
                                        )
                                      ]
                                      op_id: Op_DAmp
                                    )
                                  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 -1]
                                            )
                                          ]
                                          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: -1
                                                      arg_word: {(2)}
                                                      spids: [2609]
                                                    )
                                                  ]
                                                )
                                              ]
                                              spids: [-1 2605 2617 -1]
                                            )
                                          ]
                                          spids: [2594 2600 2620]
                                        )
                                        (AndOr
                                          children: [
                                            (C {(rsync)} {($ VSub_Name "$quiet")} {(-av)} 
                                              {(--ignore-existing)} {(--exclude)} {(info)} {(DQ ($ VSub_Name "$alt"))} {(DQ ($ VSub_Name "$GIT_DIR") (/objects))}
                                            )
                                            (C {(exit)})
                                          ]
                                          op_id: Op_DPipe
                                        )
                                      ]
                                      spids: [2567 2651]
                                    )
                                )
                              ]
                              negated: False
                            )
                            (C {(rm)} {(-f)} {(DQ ($ VSub_Name "$GIT_DIR") (/TMP_ALT))})
                          ]
                          spids: [-1 2522]
                        )
                      ]
                      spids: [-1 2664]
                    )
                    (AndOr
                      children: [
                        (SimpleCommand
                          words: [{(git-ls-remote)} {(DQ ($ VSub_Name "$repo"))}]
                          redirects: [
                            (Redir
                              op_id: Redir_Great
                              fd: -1
                              arg_word: {(DQ ($ VSub_Name "$GIT_DIR") (/CLONE_HEAD))}
                              spids: [2673]
                            )
                          ]
                        )
                        (C {(exit)} {(1)})
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  spids: [2398 2402 2686 -1]
                )
                (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:[-127172719-1])
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [(C {(die)} {(DQ ("shallow over http or ftp not supported"))})]
                          spids: [2722 2723 2731 -1]
                        )
                      ]
                      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: [-1 2748]
                        )
                      ]
                      else_action: [
                        (C {(die)} 
                          {(DQ ("http transport not supported, rebuild Git with curl support"))}
                        )
                      ]
                      spids: [2762 2772]
                    )
                  ]
                  spids: [2689 2703 2775 -1]
                )
                (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
                              children: [
                                (SimpleCommand
                                  words: [{(git)} {(bundle)} {(unbundle)} {(DQ ($ VSub_Name "$repo"))}]
                                  redirects: [
                                    (Redir
                                      op_id: Redir_Great
                                      fd: -1
                                      arg_word: {(DQ ($ VSub_Name "$GIT_DIR") (/CLONE_HEAD))}
                                      spids: [2809]
                                    )
                                  ]
                                )
                                (C {(die)} 
                                  {(DQ ("unbundle from '") ($ VSub_Name "$repo") ("' failed."))}
                                )
                              ]
                              op_id: Op_DPipe
                            )
                          ]
                          spids: [-1 2796]
                        )
                      ]
                      else_action: [
                        (AndOr
                          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: [-1 2842 2859 -1]
                                )
                                (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 -1]
                                )
                              ]
                              redirects: [
                                (Redir
                                  op_id: Redir_Great
                                  fd: -1
                                  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."))})
                          ]
                          op_id: Op_DPipe
                        )
                      ]
                      spids: [2828 2910]
                    )
                  ]
                  spids: [2778 2779 2913 -1]
                )
              ]
              spids: [2389 2395 2916]
            )
          ]
          spids: [2385 2386 2919 -1]
        )
      ]
      spids: [2014 2020 2921]
    )
    (AndOr
      children: [
        (C {(test)} {(-d)} {(DQ ($ VSub_Name "$GIT_DIR") (/refs/reference-tmp))})
        (C {(rm)} {(-fr)} {(DQ ($ VSub_Name "$GIT_DIR") (/refs/reference-tmp))})
      ]
      op_id: Op_DAmp
    )
    (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: [-1 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 -1]
                        )
                        (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 -1]
                        )
                        (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 -1]
                        )
                        (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 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [(ControlFlow token:<ControlFlow_Continue continue>)]
                          spids: [3094 3095 3100 -1]
                        )
                      ]
                      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: -1
                  arg_word: {(DQ ($ VSub_Name "$GIT_DIR") (/CLONE_HEAD))}
                  spids: [3131]
                )
              ]
            )
          ]
          spids: [-1 2955]
        )
      ]
      spids: [-1 3138]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$W"))})
              terminator: <Op_Semi ";">
            )
          ]
          action: [(AndOr children:[(C {(cd)} {(DQ ($ VSub_Name "$W"))})(C {(exit)})] op_id:Op_DPipe)]
          spids: [-1 3152]
        )
      ]
      else_action: [
        (AndOr children:[(C {(cd)} {(DQ ($ VSub_Name "$D"))})(C {(exit)})] op_id:Op_DPipe)
      ]
      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:{(SQ )} spids:[3205])]
              spids: [3205]
            )
            (AndOr
              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]
                )
              ]
              op_id: Op_DPipe
            )
            (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 -1]
                )
              ]
              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
                                            children: [
                                              (C {(test)} {(-f)} 
                                                {
                                                  (DQ ($ VSub_Name "$GIT_DIR") (/) 
                                                    ($ VSub_Name "$remote_top") (/master)
                                                  )
                                                }
                                              )
                                              (C {(echo)} {(DQ (master))})
                                            ]
                                            op_id: Op_DAmp
                                          )
                                          (AndOr
                                            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: False
                                              )
                                            ]
                                            op_id: Op_DAmp
                                          )
                                        ]
                                      )
                                    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
                                                    children: [
                                                      (C {(test)} {(t)} {(Lit_Other "=")} 
                                                        {($ VSub_Name "$done")}
                                                      )
                                                      (ControlFlow
                                                        token: <ControlFlow_Continue continue>
                                                      )
                                                    ]
                                                    op_id: Op_DAmp
                                                  )
                                                  (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: [-1 3428]
                                                      )
                                                    ]
                                                    spids: [-1 3442]
                                                  )
                                                ]
                                                spids: [3383 3445]
                                              )
                                          )
                                        ]
                                      )
                                    spids: [3369 3448]
                                  )
                                ]
                                negated: False
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [3307 3451]
                      )
                    }
                  spids: [3306]
                )
              ]
              spids: [3306]
            )
            (AndOr
              children: [
                (C {(git)} {(config)} {(remote.) (DQ ($ VSub_Name "$origin")) (.url)} 
                  {(DQ ($ VSub_Name "$repo"))}
                )
                (AndOr
                  children: [
                    (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
                              children: [
                                (C {(git)} {(symbolic-ref)} {(HEAD)} 
                                  {(DQ (refs/heads/) ($ VSub_Name "$head_points_at"))}
                                )
                                (AndOr
                                  children: [
                                    (C {(git)} {(update-ref)} {(HEAD)} {(DQ ($ VSub_Name "$head_sha1"))})
                                    (C {(rm)} {(-f)} 
                                      {(DQ (refs/remotes/) ($ VSub_Name "$origin") (/HEAD))}
                                    )
                                  ]
                                  op_id: Op_DAmp
                                )
                              ]
                              op_id: Op_DAmp
                            )
                            (AndOr
                              children: [
                                (C {(git)} {(symbolic-ref)} 
                                  {(DQ (refs/remotes/) ($ VSub_Name "$origin") (/HEAD))} {(DQ (refs/remotes/) ($ VSub_Name "$origin") (/) ($ VSub_Name "$head_points_at"))}
                                )
                                (AndOr
                                  children: [
                                    (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"))}
                                    )
                                  ]
                                  op_id: Op_DAmp
                                )
                              ]
                              op_id: Op_DAmp
                            )
                          ]
                          spids: [3520 3522 3629 -1]
                        )
                        (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: -1
                                          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: [-1 3648]
                                )
                              ]
                              else_action: [
                                (AndOr
                                  children: [
                                    (C {(git)} {(update-ref)} {(--no-deref)} {(HEAD)} 
                                      {(DQ ($ VSub_Name "$head_sha1"))}
                                    )
                                    (C {(rm)} {(-f)} 
                                      {(DQ (refs/remotes/) ($ VSub_Name "$origin") (/HEAD))}
                                    )
                                  ]
                                  op_id: Op_DAmp
                                )
                              ]
                              spids: [3669 3702]
                            )
                          ]
                          spids: [-1 3634 3705 -1]
                        )
                      ]
                      spids: [3511 3517 3708]
                    )
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
            (Case
              to_match: {(DQ ($ VSub_Name "$no_checkout"))}
              arms: [
                (case_arm
                  pat_list: [{(SQ )}]
                  action: [
                    (AndOr
                      children: [
                        (C {(test)} {(DQ (z) ($ VSub_Name "$quiet"))} {(Lit_Other "=")} {(z)})
                        (AndOr
                          children: [
                            (C {(test)} {(DQ (z) ($ VSub_Name "$no_progress"))} {(Lit_Other "=")} {(z)})
                            (AndOr
                              children: [
                                (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: {(SQ )}
                                      spids: [3757]
                                    )
                                  ]
                                  spids: [3757]
                                )
                              ]
                              op_id: Op_DPipe
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      op_id: Op_DAmp
                    )
                    (C {(git)} {(read-tree)} {(-m)} {(-u)} {($ VSub_Name "$v")} {(HEAD)} {(HEAD)})
                  ]
                  spids: [-1 3723 -1 3775]
                )
              ]
              spids: [3712 3718 3775]
            )
          ]
          spids: [-1 3191]
        )
      ]
      spids: [-1 3777]
    )
    (C {(rm)} {(-f)} {(DQ ($ VSub_Name "$GIT_DIR") (/CLONE_HEAD))} 
      {(DQ ($ VSub_Name "$GIT_DIR") (/REMOTE_HEAD))}
    )
    (C {(trap)} {(-)} {(0)})
  ]
)