(CommandList
  children: [
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:OPTIONS_KEEPDASHDASH) op:Equal rhs:{(t)} spids:[4])]
      spids: [4]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:OPTIONS_SPEC)
          op: Equal
          rhs: 
            {
              (DQ ("git-checkout [options] [<branch>] [<paths>...]\n") ("--\n") 
                ("b=          create a new branch started at <branch>\n") ("l           create the new branch's reflog\n") 
                ("track       arrange that the new branch tracks the remote branch\n") ("f           proceed even if the index or working tree is not HEAD\n") 
                ("m           merge local modifications into the new branch\n") ("q,quiet     be quiet\n")
              )
            }
          spids: [7]
        )
      ]
      spids: [7]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:SUBDIRECTORY_OK) op:Equal rhs:{(Sometimes)} spids:[20])]
      spids: [20]
    )
    (C {(.)} {(git-sh-setup)})
    (C {(require_work_tree)})
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:old_name) op:Equal rhs:{(HEAD)} spids:[30])]
      spids: [30]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:old)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (SimpleCommand
                        words: [{(git)} {(rev-parse)} {(--verify)} {($ VSub_Name "$old_name")}]
                        redirects: [(Redir op_id:Redir_Great fd:2 arg_word:{(/dev/null)} spids:[43])]
                      )
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [34 45]
              )
            }
          spids: [33]
        )
      ]
      spids: [33]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:oldbranch)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (SimpleCommand
                        words: [{(git)} {(symbolic-ref)} {($ VSub_Name "$old_name")}]
                        redirects: [(Redir op_id:Redir_Great fd:2 arg_word:{(/dev/null)} spids:[55])]
                      )
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [48 57]
              )
            }
          spids: [47]
        )
      ]
      spids: [47]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:new) op:Equal rhs:{(SQ )} spids:[59])]
      spids: [59]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:new_name) op:Equal rhs:{(SQ )} spids:[61])]
      spids: [61]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:force) op:Equal rhs:{(SQ )} spids:[63])]
      spids: [63]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:branch) op:Equal rhs:{(SQ )} spids:[65])]
      spids: [65]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:track) op:Equal rhs:{(SQ )} spids:[67])]
      spids: [67]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:newbranch) op:Equal rhs:{(SQ )} spids:[69])]
      spids: [69]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:newbranch_log) op:Equal rhs:{(SQ )} spids:[71])]
      spids: [71]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:merge) op:Equal rhs:{(SQ )} spids:[73])]
      spids: [73]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:quiet) op:Equal rhs:{(SQ )} spids:[75])]
      spids: [75]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:v) op:Equal rhs:{(-v)} spids:[77])]
      spids: [77]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:LF) op:Equal rhs:{(SQ <"\n">)} spids:[80])]
      spids: [80]
    )
    (While
      cond: [
        (Sentence
          child: (C {(test)} {($ VSub_Pound "$#")} {(KW_Bang "!") (Lit_Other "=")} {(0)})
          terminator: <Op_Semi ";">
        )
      ]
      body: 
        (DoGroup
          children: [
            (Case
              to_match: {(DQ ($ VSub_Number "$1"))}
              arms: [
                (case_arm
                  pat_list: [{(-b)}]
                  action: [
                    (C {(shift)})
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:newbranch)
                          op: Equal
                          rhs: {(DQ ($ VSub_Number "$1"))}
                          spids: [117]
                        )
                      ]
                      spids: [117]
                    )
                    (AndOr
                      children: [
                        (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$newbranch"))} {(Lit_Other "]")})
                        (C {(die)} {(DQ ("git checkout: -b needs a branch name"))})
                      ]
                      op_id: Op_DAmp
                    )
                    (AndOr
                      children: [
                        (C {(git)} {(show-ref)} {(--verify)} {(--quiet)} {(--)} 
                          {(DQ (refs/heads/) ($ VSub_Name "$newbranch"))}
                        )
                        (C {(die)} 
                          {
                            (DQ ("git checkout: branch ") ($ VSub_Name "$newbranch") 
                              (" already exists")
                            )
                          }
                        )
                      ]
                      op_id: Op_DAmp
                    )
                    (AndOr
                      children: [
                        (C {(git)} {(check-ref-format)} {(DQ (heads/) ($ VSub_Name "$newbranch"))})
                        (C {(die)} 
                          {
                            (DQ ("git checkout: we do not like '") ($ VSub_Name "$newbranch") 
                              ("' as a branch name.")
                            )
                          }
                        )
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  spids: [110 111 191 -1]
                )
                (case_arm
                  pat_list: [{(-l)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:newbranch_log)
                          op: Equal
                          rhs: {(-l)}
                          spids: [198]
                        )
                      ]
                      spids: [198]
                    )
                  ]
                  spids: [194 195 202 -1]
                )
                (case_arm
                  pat_list: [{(--track)} {(--no-track)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:track)
                          op: Equal
                          rhs: {(DQ ($ VSub_Number "$1"))}
                          spids: [211]
                        )
                      ]
                      spids: [211]
                    )
                  ]
                  spids: [205 208 217 -1]
                )
                (case_arm
                  pat_list: [{(-f)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(LhsName name:force) op:Equal rhs:{(1)} spids:[224])]
                      spids: [224]
                    )
                  ]
                  spids: [220 221 228 -1]
                )
                (case_arm
                  pat_list: [{(-m)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(LhsName name:merge) op:Equal rhs:{(1)} spids:[235])]
                      spids: [235]
                    )
                  ]
                  spids: [231 232 239 -1]
                )
                (case_arm
                  pat_list: [{(-q)} {(--quiet)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(LhsName name:quiet) op:Equal rhs:{(1)} spids:[248])]
                      spids: [248]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(LhsName name:v) op:Equal rhs:{(SQ )} spids:[252])]
                      spids: [252]
                    )
                  ]
                  spids: [242 245 255 -1]
                )
                (case_arm
                  pat_list: [{(--)}]
                  action: [(C {(shift)}) (ControlFlow token:<ControlFlow_Break break>)]
                  spids: [258 259 268 -1]
                )
                (case_arm
                  pat_list: [{(Lit_Other "*")}]
                  action: [(C {(usage)})]
                  spids: [271 272 278 -1]
                )
              ]
              spids: [101 107 281]
            )
            (C {(shift)})
          ]
          spids: [98 286]
        )
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:arg)
          op: Equal
          rhs: {(DQ ($ VSub_Number "$1"))}
          spids: [289]
        )
      ]
      spids: [289]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:rev)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (SimpleCommand
                        words: [{(git)} {(rev-parse)} {(--verify)} {(DQ ($ VSub_Name "$arg"))}]
                        redirects: [(Redir op_id:Redir_Great fd:2 arg_word:{(/dev/null)} spids:[306])]
                      )
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [295 308]
              )
            }
          spids: [294]
        )
      ]
      spids: [294]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:rev)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (SimpleCommand
                                words: [
                                  {(git)}
                                  {(rev-parse)}
                                  {(--verify)}
                                  {(DQ ($ VSub_Name "$rev") ("^0"))}
                                ]
                                redirects: [
                                  (Redir
                                    op_id: Redir_Great
                                    fd: 2
                                    arg_word: {(/dev/null)}
                                    spids: [325]
                                  )
                                ]
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [313 327]
                      )
                    }
                  spids: [312]
                )
              ]
              spids: [312]
            )
          ]
          action: [
            (AndOr
              children: [
                (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$rev"))} {(Lit_Other "]")})
                (C {(die)} {(DQ ("unknown flag ") ($ VSub_Name "$arg"))})
              ]
              op_id: Op_DAmp
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:new_name)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$arg"))}
                  spids: [352]
                )
              ]
              spids: [352]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (C {(git)} {(show-ref)} {(--verify)} {(--quiet)} {(--)} 
                      {(DQ (refs/heads/) ($ VSub_Name "$arg"))}
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:rev)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(git)} {(rev-parse)} {(--verify)} 
                                        {(DQ (refs/heads/) ($ VSub_Name "$arg") ("^0"))}
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [380 392]
                              )
                            }
                          spids: [379]
                        )
                      ]
                      spids: [379]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:branch)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$arg"))}
                          spids: [395]
                        )
                      ]
                      spids: [395]
                    )
                  ]
                  spids: [-1 376]
                )
              ]
              spids: [-1 401]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:new)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$rev"))}
                  spids: [404]
                )
              ]
              spids: [404]
            )
            (C {(shift)})
          ]
          spids: [-1 329]
        )
        (if_arm
          cond: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:rev)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (SimpleCommand
                                words: [
                                  {(git)}
                                  {(rev-parse)}
                                  {(--verify)}
                                  {(DQ ($ VSub_Name "$rev") ("^{tree}"))}
                                ]
                                redirects: [
                                  (Redir
                                    op_id: Redir_Great
                                    fd: 2
                                    arg_word: {(/dev/null)}
                                    spids: [427]
                                  )
                                ]
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [415 429]
                      )
                    }
                  spids: [414]
                )
              ]
              spids: [414]
            )
          ]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:new)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$rev"))}
                  spids: [438]
                )
              ]
              spids: [438]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:new_name)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$rev") ("^{tree}"))}
                  spids: [444]
                )
              ]
              spids: [444]
            )
            (C {(shift)})
          ]
          spids: [412 431]
        )
      ]
      spids: [-1 453]
    )
    (AndOr
      children: [
        (C {(Lit_Other "[")} {(DQ ($ VSub_Number "$1"))} {(Lit_Other "=")} {(DQ (--))} {(Lit_Other "]")})
        (C {(shift)})
      ]
      op_id: Op_DAmp
    )
    (Case
      to_match: {(DQ ($ VSub_Name "$newbranch") (",") ($ VSub_Name "$track"))}
      arms: [
        (case_arm
          pat_list: [{(Lit_Comma ",") (--) (Lit_Other "*")}]
          action: [(C {(die)} {(DQ ("git checkout: --track and --no-track require -b"))})]
          spids: [484 487 -1 496]
        )
      ]
      spids: [474 482 496]
    )
    (Case
      to_match: {(DQ ($ VSub_Name "$force") ($ VSub_Name "$merge"))}
      arms: [
        (case_arm
          pat_list: [{(11)}]
          action: [(C {(die)} {(DQ ("git checkout: -f and -m are incompatible"))})]
          spids: [508 509 -1 518]
        )
      ]
      spids: [499 506 518]
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(DQ ($ VSub_Pound "$#"))} {(-ge)} {(1)})]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:hint) op:Equal rhs:{(SQ )} spids:[564])]
              spids: [564]
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(DQ ($ VSub_Pound "$#"))} {(-eq)} {(1)})]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:hint)
                          op: Equal
                          rhs: 
                            {
                              (DQ ("\n") ("Did you intend to checkout '") ($ VSub_At "$@") 
                                ("' which can not be resolved as commit?")
                              )
                            }
                          spids: [583]
                        )
                      ]
                      spids: [583]
                    )
                  ]
                  spids: [-1 580]
                )
              ]
              spids: [-1 592]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (C {(test)} {(SQ )} {(KW_Bang "!") (Lit_Other "=")} 
                      {(DQ ($ VSub_Name "$newbranch") ($ VSub_Name "$force") ($ VSub_Name "$merge"))}
                    )
                  ]
                  action: [
                    (C {(die)} 
                      {
                        (DQ 
                          (
"git checkout: updating paths is incompatible with switching branches/forcing"
                          ) ($ VSub_Name "$hint")
                        )
                      }
                    )
                  ]
                  spids: [-1 612]
                )
              ]
              spids: [-1 623]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (C {(test)} {(SQ )} {(KW_Bang "!") (Lit_Other "=")} {(DQ ($ VSub_Name "$new"))})
                  ]
                  action: [
                    (AndOr
                      children: [
                        (Pipeline
                          children: [
                            (C {(git)} {(ls-tree)} {(--full-name)} {(-r)} {(DQ ($ VSub_Name "$new"))} 
                              {(DQ ($ VSub_At "$@"))}
                            )
                            (C {(git)} {(update-index)} {(--index-info)})
                          ]
                          negated: False
                        )
                        (C {(exit)} {($ VSub_QMark "$?")})
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  spids: [-1 641]
                )
              ]
              spids: [-1 688]
            )
            (AndOr
              children: [
                (SimpleCommand
                  words: [
                    {(git)}
                    {(ls-files)}
                    {(--full-name)}
                    {(--error-unmatch)}
                    {(--)}
                    {(DQ ($ VSub_At "$@"))}
                  ]
                  redirects: [(Redir op_id:Redir_Great fd:-1 arg_word:{(/dev/null)} spids:[710])]
                )
                (C {(exit)})
              ]
              op_id: Op_DPipe
            )
            (Pipeline
              children: [
                (C {(git)} {(ls-files)} {(--full-name)} {(--)} {(DQ ($ VSub_At "$@"))})
                (Subshell
                  child: 
                    (AndOr
                      children: [
                        (C {(cd_to_toplevel)})
                        (C {(git)} {(checkout-index)} {(-f)} {(-u)} {(--stdin)})
                      ]
                      op_id: Op_DAmp
                    )
                  spids: [733 747]
                )
              ]
              negated: False
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: (C {(test)} {(-x)} {(DQ ($ VSub_Name "$GIT_DIR")) (/hooks/post-checkout)})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(DQ ($ VSub_Name "$GIT_DIR")) (/hooks/post-checkout)} {($ VSub_Name "$old")} 
                      {($ VSub_Name "$old")} {(0)}
                    )
                  ]
                  spids: [-1 771]
                )
              ]
              spids: [-1 786]
            )
            (C {(exit)} {($ VSub_QMark "$?")})
          ]
          spids: [-1 561]
        )
      ]
      else_action: [
        (If
          arms: [
            (if_arm
              cond: [(C {(test)} {(SQ )} {(KW_Bang "!") (Lit_Other "=")} {(DQ ($ VSub_Name "$new"))})]
              action: [
                (AndOr
                  children: [
                    (SimpleCommand
                      words: [{(git)} {(rev-parse)} {(--verify)} {(DQ ($ VSub_Name "$new") ("^{commit}"))}]
                      redirects: [
                        (Redir
                          op_id: Redir_Great
                          fd: -1
                          arg_word: {(/dev/null)}
                          spids: [838]
                        )
                        (Redir
                          op_id: Redir_GreatAnd
                          fd: 2
                          arg_word: {(1)}
                          spids: [841]
                        )
                      ]
                    )
                    (C {(die)} {(DQ ("Cannot switch branch to a non-commit."))})
                  ]
                  op_id: Op_DPipe
                )
              ]
              spids: [-1 824]
            )
          ]
          spids: [-1 854]
        )
      ]
      spids: [794 856]
    )
    (C {(cd_to_toplevel)})
    (AndOr
      children: [
        (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$new"))} {(Lit_Other "]")})
        (AndOr
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:new)
                  op: Equal
                  rhs: {($ VSub_Name "$old")}
                  spids: [880]
                )
              ]
              spids: [880]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:new_name)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$old_name"))}
                  spids: [885]
                )
              ]
              spids: [885]
            )
          ]
          op_id: Op_DAmp
        )
      ]
      op_id: Op_DAmp
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:detached) op:Equal rhs:{(SQ )} spids:[913])]
      spids: [913]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:detach_warn) op:Equal rhs:{(SQ )} spids:[915])]
      spids: [915]
    )
    (FuncDef
      name: describe_detached_head
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$quiet"))})
                (BraceGroup
                  children: [
                    (SimpleCommand
                      words: [{(printf)} {(DQ ($ VSub_Number "$1") (" "))}]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[941])]
                    )
                    (SimpleCommand
                      words: [
                        {(git)}
                        {(log)}
                        {(-1)}
                        {(--pretty) (Lit_Other "=") (oneline)}
                        {(--abbrev-commit)}
                        {(DQ ($ VSub_Number "$2"))}
                        {(--)}
                      ]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[956])]
                      more_env: [(env_pair name:GIT_PAGER val:{(SQ )} spids:[950])]
                    )
                  ]
                  spids: [936]
                )
              ]
              op_id: Op_DPipe
            )
          ]
          spids: [923]
        )
      spids: [918 922]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (AndOr
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_Name "$branch") ($ VSub_Name "$newbranch"))})
                (C {(test)} {(DQ ($ VSub_Name "$new_name"))} {(KW_Bang "!") (Lit_Other "=")} 
                  {(DQ ($ VSub_Name "$old_name"))}
                )
              ]
              op_id: Op_DAmp
            )
          ]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:detached)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$new"))}
                  spids: [1008]
                )
              ]
              spids: [1008]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (AndOr
                      children: [
                        (C {(test)} {(-n)} {(DQ ($ VSub_Name "$oldbranch"))})
                        (C {(test)} {(-z)} {(DQ ($ VSub_Name "$quiet"))})
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:detach_warn)
                          op: Equal
                          rhs: 
                            {
                              (DQ ("Note: moving to ") 
                                (EscapedLiteralPart
                                  token: <Lit_EscapedChar "\\\"">
                                ) ($ VSub_Name "$new_name") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                                (" which isn't a local branch\n") ("If you want to create a new branch from this checkout, you may do so\n") 
                                (
"(now or later) by using -b with the checkout command again. Example:\n"
                                ) ("  git checkout -b <new_branch_name>")
                              )
                            }
                          spids: [1038]
                        )
                      ]
                      spids: [1038]
                    )
                  ]
                  spids: [-1 1035]
                )
              ]
              spids: [-1 1051]
            )
          ]
          spids: [-1 1005]
        )
        (if_arm
          cond: [
            (AndOr
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_Name "$oldbranch"))})
                (C {(test)} {(DQ ($ VSub_Name "$new"))} {(KW_Bang "!") (Lit_Other "=")} 
                  {(DQ ($ VSub_Name "$old"))}
                )
              ]
              op_id: Op_DAmp
            )
          ]
          action: [
            (C {(describe_detached_head)} {(SQ <"Previous HEAD position was">)} 
              {(DQ ($ VSub_Name "$old"))}
            )
          ]
          spids: [1053 1078]
        )
      ]
      spids: [-1 1091]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (C {(Lit_Other "[")} {(DQ (X) ($ VSub_Name "$old"))} {(Lit_Other "=")} {(X)} {(Lit_Other "]")})
          ]
          action: [
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$quiet"))})]
                  action: [
                    (SimpleCommand
                      words: [{(echo)} {(DQ ("warning: You appear to be on a branch yet to be born."))}]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[1128])]
                    )
                    (SimpleCommand
                      words: [
                        {(echo)}
                        {(DQ ("warning: Forcing checkout of ") ($ VSub_Name "$new_name") (.))}
                      ]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[1138])]
                    )
                  ]
                  spids: [-1 1123]
                )
              ]
              spids: [-1 1148]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:force) op:Equal rhs:{(1)} spids:[1151])]
              spids: [1151]
            )
          ]
          spids: [-1 1109]
        )
      ]
      spids: [-1 1154]
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(Lit_Other "[")} {(DQ ($ VSub_Name "$force"))} {(Lit_Other "]")})]
          action: [
            (C {(git)} {(read-tree)} {($ VSub_Name "$v")} {(--reset)} {(-u)} {($ VSub_Name "$new")})
          ]
          spids: [-1 1167]
        )
      ]
      else_action: [
        (SimpleCommand
          words: [{(git)} {(update-index)} {(--refresh)}]
          redirects: [(Redir op_id:Redir_Great fd:-1 arg_word:{(/dev/null)} spids:[1191])]
        )
        (AndOr
          children: [
            (C {(git)} {(read-tree)} {($ VSub_Name "$v")} {(-m)} {(-u)} 
              {(--exclude-per-directory) (Lit_Other "=") (.gitignore)} {($ VSub_Name "$old")} {($ VSub_Name "$new")}
            )
            (Subshell
              child: 
                (CommandList
                  children: [
                    (Case
                      to_match: {(DQ ($ VSub_Name "$merge") (",") ($ VSub_Name "$v"))}
                      arms: [
                        (case_arm
                          pat_list: [{(Lit_Comma ",") (Lit_Other "*")}]
                          action: [(C {(exit)} {(1)})]
                          spids: [1229 1231 1238 -1]
                        )
                        (case_arm
                          pat_list: [{(1) (Lit_Comma ",")}]
                          spids: [1241 1243 1246 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [
                            (SimpleCommand
                              words: [{(echo)} {(DQ ("Falling back to 3-way merge..."))}]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: -1
                                  arg_word: {(2)}
                                  spids: [1258]
                                )
                              ]
                            )
                          ]
                          spids: [1252 1253 1265 -1]
                        )
                      ]
                      spids: [1218 1226 1268]
                    )
                    (AndOr
                      children: [
                        (Pipeline
                          children: [
                            (C {(git)} {(diff-files)} {(--name-only)})
                            (C {(git)} {(update-index)} {(--remove)} {(--stdin)})
                          ]
                          negated: False
                        )
                        (AndOr
                          children: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:work)
                                  op: Equal
                                  rhs: 
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [(C {(git)} {(write-tree)})]
                                          )
                                        left_token: <Left_CommandSub "$(">
                                        spids: [1296 1300]
                                      )
                                    }
                                  spids: [1295]
                                )
                              ]
                              spids: [1295]
                            )
                            (AndOr
                              children: [
                                (C {(git)} {(read-tree)} {($ VSub_Name "$v")} {(--reset)} {(-u)} 
                                  {($ VSub_Name "$new")}
                                )
                                (C {(exit)})
                              ]
                              op_id: Op_DPipe
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      op_id: Op_DAmp
                    )
                    (AndOr
                      children: [
                        (C {(eval)} 
                          {(GITHEAD_) ($ VSub_Name "$new") (Lit_Other "=") 
                            (SQ <"${new_name:-${branch:-$new}}">)
                          }
                        )
                        (AndOr
                          children: [
                            (C {(eval)} 
                              {(GITHEAD_) ($ VSub_Name "$work") (Lit_Other "=") (Assign_Local local)}
                            )
                            (AndOr
                              children: [
                                (C {(export)} {(GITHEAD_) ($ VSub_Name "$new")} 
                                  {(GITHEAD_) ($ VSub_Name "$work")}
                                )
                                (C {(git)} {(merge-recursive)} {($ VSub_Name "$old")} {(--)} 
                                  {($ VSub_Name "$new")} {($ VSub_Name "$work")}
                                )
                              ]
                              op_id: Op_DAmp
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      op_id: Op_DAmp
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:unmerged)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [(C {(git)} {(ls-files)} {(-u)})]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [1383 1389]
                              )
                            }
                          spids: [1382]
                        )
                      ]
                      spids: [1382]
                    )
                    (C {(git)} {(read-tree)} {($ VSub_Name "$v")} {(--reset)} {($ VSub_Name "$new")})
                    (Case
                      to_match: {(DQ ($ VSub_Name "$unmerged"))}
                      arms: [
                        (case_arm pat_list:[{(SQ )}] spids:[-114141416-1])
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [
                            (Pipeline
                              children: [
                                (Subshell
                                  child: 
                                    (CommandList
                                      children: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:z40)
                                              op: Equal
                                              rhs: {(0000000000000000000000000000000000000000)}
                                              spids: [1426]
                                            )
                                          ]
                                          spids: [1426]
                                        )
                                        (Pipeline
                                          children: [
                                            (C {(echo)} {(DQ ($ VSub_Name "$unmerged"))})
                                            (C {(sed)} {(-e)} 
                                              {(SQ <"s/^[0-7]* [0-9a-f]* /">) 
                                                (DQ ("0 ") ($ VSub_Name "$z40") (" /"))
                                              }
                                            )
                                          ]
                                          negated: False
                                        )
                                        (C {(echo)} {(DQ ($ VSub_Name "$unmerged"))})
                                      ]
                                    )
                                  spids: [1423 1460]
                                )
                                (C {(git)} {(update-index)} {(--index-info)})
                              ]
                              negated: False
                            )
                          ]
                          spids: [1419 1420 1471 -1]
                        )
                      ]
                      spids: [1403 1409 1474]
                    )
                    (C {(exit)} {(0)})
                  ]
                )
              spids: [1215 1482]
            )
          ]
          op_id: Op_DPipe
        )
        (Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (LhsName name:saved_err)
              op: Equal
              rhs: {($ VSub_QMark "$?")}
              spids: [1485]
            )
          ]
          spids: [1485]
        )
        (If
          arms: [
            (if_arm
              cond: [
                (AndOr
                  children: [
                    (C {(test)} {(DQ ($ VSub_Name "$saved_err"))} {(Lit_Other "=")} {(0)})
                    (C {(test)} {(-z)} {(DQ ($ VSub_Name "$quiet"))})
                  ]
                  op_id: Op_DAmp
                )
              ]
              action: [(C {(git)} {(diff-index)} {(--name-status)} {(DQ ($ VSub_Name "$new"))})]
              spids: [-1 1512]
            )
          ]
          spids: [-1 1526]
        )
        (Subshell child:(C {(exit)} {($ VSub_Name "$saved_err")}) spids:[15291533])
      ]
      spids: [1182 1535]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: (C {(Lit_Other "[")} {(DQ ($ VSub_QMark "$?"))} {(-eq)} {(0)} {(Lit_Other "]")})
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: (C {(Lit_Other "[")} {(DQ ($ VSub_Name "$newbranch"))} {(Lit_Other "]")})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (AndOr
                      children: [
                        (C {(git)} {(branch)} {($ VSub_Name "$track")} {($ VSub_Name "$newbranch_log")} 
                          {(DQ ($ VSub_Name "$newbranch"))} {(DQ ($ VSub_Name "$new_name"))}
                        )
                        (C {(exit)})
                      ]
                      op_id: Op_DPipe
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:branch)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$newbranch"))}
                          spids: [1609]
                        )
                      ]
                      spids: [1609]
                    )
                  ]
                  spids: [-1 1585]
                )
              ]
              spids: [-1 1615]
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name "$branch"))})]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:old_branch_name)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(expr)} {(DQ (z) ($ VSub_Name "$oldbranch"))} 
                                        {(Lit_Other ":")} {(SQ <"zrefs/heads/\\(.*\\)">)}
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [1633 1646]
                              )
                            }
                          spids: [1632]
                        )
                      ]
                      spids: [1632]
                    )
                    (SimpleCommand
                      words: [
                        {(git)}
                        {(symbolic-ref)}
                        {(-m)}
                        {
                          (DQ ("checkout: moving from ") 
                            (BracedVarSub
                              token: <VSub_Name old_branch_name>
                              suffix_op: 
                                (StringUnary
                                  op_id: VTest_ColonHyphen
                                  arg_word: {($ VSub_Name "$old")}
                                )
                              spids: [1662 1666]
                            ) (" to ") ($ VSub_Name "$branch")
                          )
                        }
                        {(HEAD)}
                        {(DQ (refs/heads/) ($ VSub_Name "$branch"))}
                      ]
                      more_env: [
                        (env_pair
                          name: GIT_DIR
                          val: {(DQ ($ VSub_Name "$GIT_DIR"))}
                          spids: [1649]
                        )
                      ]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name "$quiet"))})]
                          action: [(C {(true)})]
                          spids: [-1 1690]
                        )
                        (if_arm
                          cond: [
                            (C {(test)} {(DQ (refs/heads/) ($ VSub_Name "$branch"))} {(Lit_Other "=")} 
                              {(DQ ($ VSub_Name "$oldbranch"))}
                            )
                          ]
                          action: [
                            (SimpleCommand
                              words: [
                                {(echo)}
                                {
                                  (DQ ("Already on branch ") 
                                    (EscapedLiteralPart
                                      token: <Lit_EscapedChar "\\\"">
                                    ) ($ VSub_Name "$branch") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                                  )
                                }
                              ]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: -1
                                  arg_word: {(2)}
                                  spids: [1720]
                                )
                              ]
                            )
                          ]
                          spids: [1699 1715]
                        )
                      ]
                      else_action: [
                        (SimpleCommand
                          words: [
                            {(echo)}
                            {
                              (DQ ("Switched to") 
                                (BracedVarSub
                                  token: <VSub_Name newbranch>
                                  suffix_op: (StringUnary op_id:VTest_ColonPlus arg_word:{(" a new")})
                                  spids: [1741 1745]
                                ) (" branch ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) ($ VSub_Name "$branch") 
                                (EscapedLiteralPart
                                  token: <Lit_EscapedChar "\\\"">
                                )
                              )
                            }
                          ]
                          redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[1736])]
                        )
                      ]
                      spids: [1731 1753]
                    )
                  ]
                  spids: [-1 1629]
                )
                (if_arm
                  cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name "$detached"))})]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:old_branch_name)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(expr)} {(DQ (z) ($ VSub_Name "$oldbranch"))} 
                                        {(Lit_Other ":")} {(SQ <"zrefs/heads/\\(.*\\)">)}
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [1771 1784]
                              )
                            }
                          spids: [1770]
                        )
                      ]
                      spids: [1770]
                    )
                    (AndOr
                      children: [
                        (C {(git)} {(update-ref)} {(--no-deref)} {(-m)} 
                          {
                            (DQ ("checkout: moving from ") 
                              (BracedVarSub
                                token: <VSub_Name old_branch_name>
                                suffix_op: 
                                  (StringUnary
                                    op_id: VTest_ColonHyphen
                                    arg_word: {($ VSub_Name "$old")}
                                  )
                                spids: [1797 1801]
                              ) (" to ") ($ VSub_Name "$arg")
                            )
                          } {(HEAD)} {(DQ ($ VSub_Name "$detached"))}
                        )
                        (C {(die)} {(DQ ("Cannot detach HEAD"))})
                      ]
                      op_id: Op_DPipe
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name "$detach_warn"))})]
                          action: [
                            (SimpleCommand
                              words: [{(echo)} {(DQ ($ VSub_Name "$detach_warn"))}]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: -1
                                  arg_word: {(2)}
                                  spids: [1838]
                                )
                              ]
                            )
                          ]
                          spids: [-1 1833]
                        )
                      ]
                      spids: [-1 1846]
                    )
                    (C {(describe_detached_head)} {(SQ <"HEAD is now at">)} {(HEAD)})
                  ]
                  spids: [1756 1767]
                )
              ]
              spids: [-1 1858]
            )
            (C {(rm)} {(-f)} {(DQ ($ VSub_Name "$GIT_DIR") (/MERGE_HEAD))})
          ]
          spids: [-1 1571]
        )
      ]
      else_action: [(C {(exit)} {(1)})]
      spids: [1870 1877]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: (C {(test)} {(-x)} {(DQ ($ VSub_Name "$GIT_DIR")) (/hooks/post-checkout)})
              terminator: <Op_Semi ";">
            )
          ]
          action: [
            (C {(DQ ($ VSub_Name "$GIT_DIR")) (/hooks/post-checkout)} {($ VSub_Name "$old")} 
              {($ VSub_Name "$new")} {(1)}
            )
          ]
          spids: [-1 1895]
        )
      ]
      spids: [-1 1909]
    )
  ]
)