(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:{(EmptyPart)} spids:[59])]
      spids: [59]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:new_name) op:Equal rhs:{(EmptyPart)} spids:[61])]
      spids: [61]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:force) op:Equal rhs:{(EmptyPart)} spids:[63])]
      spids: [63]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:branch) op:Equal rhs:{(EmptyPart)} spids:[65])]
      spids: [65]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:track) op:Equal rhs:{(EmptyPart)} spids:[67])]
      spids: [67]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:newbranch) op:Equal rhs:{(EmptyPart)} spids:[69])]
      spids: [69]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:newbranch_log) op:Equal rhs:{(EmptyPart)} spids:[71])]
      spids: [71]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:merge) op:Equal rhs:{(EmptyPart)} spids:[73])]
      spids: [73]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:quiet) op:Equal rhs:{(EmptyPart)} 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
                      ops: [Op_DAmp]
                      children: [
                        (C {(Lit_Other '[')} {(-z)} {(DQ ($ VSub_Name '$newbranch'))} {(Lit_Other ']')})
                        (C {(die)} {(DQ ('git checkout: -b needs a branch name'))})
                      ]
                    )
                    (AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(git)} {(show-ref)} {(--verify)} {(--quiet)} {(--)} 
                          {(DQ (refs/heads/) ($ VSub_Name '$newbranch'))}
                        )
                        (C {(die)} 
                          {
                            (DQ ('git checkout: branch ') ($ VSub_Name '$newbranch') 
                              (' already exists')
                            )
                          }
                        )
                      ]
                    )
                    (AndOr
                      ops: [Op_DPipe]
                      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.")
                            )
                          }
                        )
                      ]
                    )
                  ]
                  spids: [110 111 191 16777215]
                )
                (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 16777215]
                )
                (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 16777215]
                )
                (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 16777215]
                )
                (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 16777215]
                )
                (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: {(EmptyPart)}
                          spids: [252]
                        )
                      ]
                      spids: [252]
                    )
                  ]
                  spids: [242 245 255 16777215]
                )
                (case_arm
                  pat_list: [{(--)}]
                  action: [(C {(shift)}) (ControlFlow token:<ControlFlow_Break break>)]
                  spids: [258 259 268 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [(C {(usage)})]
                  spids: [271 272 278 16777215]
                )
              ]
              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
              ops: [Op_DAmp]
              children: [
                (C {(Lit_Other '[')} {(-z)} {(DQ ($ VSub_Name '$rev'))} {(Lit_Other ']')})
                (C {(die)} {(DQ ('unknown flag ') ($ VSub_Name '$arg'))})
              ]
            )
            (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: [16777215 376]
                )
              ]
              spids: [16777215 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: [16777215 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: [16777215 453]
    )
    (AndOr
      ops: [Op_DAmp]
      children: [
        (C {(Lit_Other '[')} {(DQ ($ VSub_Number '$1'))} {(Lit_Other '=')} {(DQ (--))} {(Lit_Other ']')})
        (C {(shift)})
      ]
    )
    (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 16777215 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 16777215 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:{(EmptyPart)} 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: [16777215 580]
                )
              ]
              spids: [16777215 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: [16777215 612]
                )
              ]
              spids: [16777215 623]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (C {(test)} {(SQ )} {(KW_Bang '!') (Lit_Other '=')} {(DQ ($ VSub_Name '$new'))})
                  ]
                  action: [
                    (AndOr
                      ops: [Op_DPipe]
                      children: [
                        (Pipeline
                          children: [
                            (C {(git)} {(ls-tree)} {(--full-name)} {(-r)} {(DQ ($ VSub_Name '$new'))} 
                              {(DQ ($ VSub_At '$@'))}
                            )
                            (C {(git)} {(update-index)} {(--index-info)})
                          ]
                          negated: F
                        )
                        (ControlFlow
                          token: <ControlFlow_Exit exit>
                          arg_word: {($ VSub_QMark '$?')}
                        )
                      ]
                    )
                  ]
                  spids: [16777215 641]
                )
              ]
              spids: [16777215 688]
            )
            (AndOr
              ops: [Op_DPipe]
              children: [
                (SimpleCommand
                  words: [
                    {(git)}
                    {(ls-files)}
                    {(--full-name)}
                    {(--error-unmatch)}
                    {(--)}
                    {(DQ ($ VSub_At '$@'))}
                  ]
                  redirects: [
                    (Redir
                      op_id: Redir_Great
                      fd: 16777215
                      arg_word: {(/dev/null)}
                      spids: [710]
                    )
                  ]
                )
                (ControlFlow token:<ControlFlow_Exit exit>)
              ]
            )
            (Pipeline
              children: [
                (C {(git)} {(ls-files)} {(--full-name)} {(--)} {(DQ ($ VSub_At '$@'))})
                (Subshell
                  child: 
                    (AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(cd_to_toplevel)})
                        (C {(git)} {(checkout-index)} {(-f)} {(-u)} {(--stdin)})
                      ]
                    )
                  spids: [733 747]
                )
              ]
              negated: F
            )
            (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: [16777215 771]
                )
              ]
              spids: [16777215 786]
            )
            (ControlFlow token:<ControlFlow_Exit exit> arg_word:{($ VSub_QMark '$?')})
          ]
          spids: [16777215 561]
        )
      ]
      else_action: [
        (If
          arms: [
            (if_arm
              cond: [(C {(test)} {(SQ )} {(KW_Bang '!') (Lit_Other '=')} {(DQ ($ VSub_Name '$new'))})]
              action: [
                (AndOr
                  ops: [Op_DPipe]
                  children: [
                    (SimpleCommand
                      words: [{(git)} {(rev-parse)} {(--verify)} {(DQ ($ VSub_Name '$new') ('^{commit}'))}]
                      redirects: [
                        (Redir
                          op_id: Redir_Great
                          fd: 16777215
                          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.'))})
                  ]
                )
              ]
              spids: [16777215 824]
            )
          ]
          spids: [16777215 854]
        )
      ]
      spids: [794 856]
    )
    (C {(cd_to_toplevel)})
    (AndOr
      ops: [Op_DAmp Op_DAmp]
      children: [
        (C {(Lit_Other '[')} {(-z)} {(DQ ($ VSub_Name '$new'))} {(Lit_Other ']')})
        (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]
        )
      ]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:detached) op:Equal rhs:{(EmptyPart)} spids:[913])]
      spids: [913]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:detach_warn) op:Equal rhs:{(EmptyPart)} spids:[915])]
      spids: [915]
    )
    (FuncDef
      name: describe_detached_head
      body: 
        (BraceGroup
          children: [
            (AndOr
              ops: [Op_DPipe]
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_Name '$quiet'))})
                (BraceGroup
                  children: [
                    (SimpleCommand
                      words: [{(printf)} {(DQ ($ VSub_Number '$1') (' '))}]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:16777215 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:16777215 arg_word:{(2)} spids:[956])]
                      more_env: [(env_pair name:GIT_PAGER val:{(EmptyPart)} spids:[950])]
                    )
                  ]
                  spids: [936]
                )
              ]
            )
          ]
          spids: [923]
        )
      spids: [918 922]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (AndOr
              ops: [Op_DAmp]
              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'))}
                )
              ]
            )
          ]
          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
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(-n)} {(DQ ($ VSub_Name '$oldbranch'))})
                        (C {(test)} {(-z)} {(DQ ($ VSub_Name '$quiet'))})
                      ]
                    )
                  ]
                  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: [16777215 1035]
                )
              ]
              spids: [16777215 1051]
            )
          ]
          spids: [16777215 1005]
        )
        (if_arm
          cond: [
            (AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_Name '$oldbranch'))})
                (C {(test)} {(DQ ($ VSub_Name '$new'))} {(KW_Bang '!') (Lit_Other '=')} 
                  {(DQ ($ VSub_Name '$old'))}
                )
              ]
            )
          ]
          action: [
            (C {(describe_detached_head)} {(SQ <'Previous HEAD position was'>)} 
              {(DQ ($ VSub_Name '$old'))}
            )
          ]
          spids: [1053 1078]
        )
      ]
      spids: [16777215 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: 16777215
                          arg_word: {(2)}
                          spids: [1128]
                        )
                      ]
                    )
                    (SimpleCommand
                      words: [
                        {(echo)}
                        {(DQ ('warning: Forcing checkout of ') ($ VSub_Name '$new_name') (.))}
                      ]
                      redirects: [
                        (Redir
                          op_id: Redir_GreatAnd
                          fd: 16777215
                          arg_word: {(2)}
                          spids: [1138]
                        )
                      ]
                    )
                  ]
                  spids: [16777215 1123]
                )
              ]
              spids: [16777215 1148]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:force) op:Equal rhs:{(1)} spids:[1151])]
              spids: [1151]
            )
          ]
          spids: [16777215 1109]
        )
      ]
      spids: [16777215 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: [16777215 1167]
        )
      ]
      else_action: [
        (SimpleCommand
          words: [{(git)} {(update-index)} {(--refresh)}]
          redirects: [(Redir op_id:Redir_Great fd:16777215 arg_word:{(/dev/null)} spids:[1191])]
        )
        (AndOr
          ops: [Op_DPipe]
          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: [(ControlFlow token:<ControlFlow_Exit exit> arg_word:{(1)})]
                          spids: [1229 1231 1238 16777215]
                        )
                        (case_arm
                          pat_list: [{(1) (Lit_Comma ',')}]
                          spids: [1241 1243 1246 16777215]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other '*')}]
                          action: [
                            (SimpleCommand
                              words: [{(echo)} {(DQ ('Falling back to 3-way merge...'))}]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: 16777215
                                  arg_word: {(2)}
                                  spids: [1258]
                                )
                              ]
                            )
                          ]
                          spids: [1252 1253 1265 16777215]
                        )
                      ]
                      spids: [1218 1226 1268]
                    )
                    (AndOr
                      ops: [Op_DAmp Op_DAmp Op_DPipe]
                      children: [
                        (Pipeline
                          children: [
                            (C {(git)} {(diff-files)} {(--name-only)})
                            (C {(git)} {(update-index)} {(--remove)} {(--stdin)})
                          ]
                          negated: F
                        )
                        (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]
                        )
                        (C {(git)} {(read-tree)} {($ VSub_Name '$v')} {(--reset)} {(-u)} 
                          {($ VSub_Name '$new')}
                        )
                        (ControlFlow token:<ControlFlow_Exit exit>)
                      ]
                    )
                    (AndOr
                      ops: [Op_DAmp Op_DAmp Op_DAmp]
                      children: [
                        (C {(eval)} 
                          {(GITHEAD_) ($ VSub_Name '$new') (Lit_Other '=') 
                            (SQ <'${new_name:-${branch:-$new}}'>)
                          }
                        )
                        (C {(eval)} 
                          {(GITHEAD_) ($ VSub_Name '$work') (Lit_Other '=') (Assign_Local local)}
                        )
                        (C {(export)} {(GITHEAD_) ($ VSub_Name '$new')} 
                          {(GITHEAD_) ($ VSub_Name '$work')}
                        )
                        (C {(git)} {(merge-recursive)} {($ VSub_Name '$old')} {(--)} 
                          {($ VSub_Name '$new')} {($ VSub_Name '$work')}
                        )
                      ]
                    )
                    (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: [16777215 1414 1416 16777215]
                        )
                        (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: F
                                        )
                                        (C {(echo)} {(DQ ($ VSub_Name '$unmerged'))})
                                      ]
                                    )
                                  spids: [1423 1460]
                                )
                                (C {(git)} {(update-index)} {(--index-info)})
                              ]
                              negated: F
                            )
                          ]
                          spids: [1419 1420 1471 16777215]
                        )
                      ]
                      spids: [1403 1409 1474]
                    )
                    (ControlFlow token:<ControlFlow_Exit exit> arg_word:{(0)})
                  ]
                )
              spids: [1215 1482]
            )
          ]
        )
        (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
                  ops: [Op_DAmp]
                  children: [
                    (C {(test)} {(DQ ($ VSub_Name '$saved_err'))} {(Lit_Other '=')} {(0)})
                    (C {(test)} {(-z)} {(DQ ($ VSub_Name '$quiet'))})
                  ]
                )
              ]
              action: [(C {(git)} {(diff-index)} {(--name-status)} {(DQ ($ VSub_Name '$new'))})]
              spids: [16777215 1512]
            )
          ]
          spids: [16777215 1526]
        )
        (Subshell
          child: (ControlFlow token:<ControlFlow_Exit exit> arg_word:{($ VSub_Name '$saved_err')})
          spids: [1529 1533]
        )
      ]
      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
                      ops: [Op_DPipe]
                      children: [
                        (C {(git)} {(branch)} {($ VSub_Name '$track')} {($ VSub_Name '$newbranch_log')} 
                          {(DQ ($ VSub_Name '$newbranch'))} {(DQ ($ VSub_Name '$new_name'))}
                        )
                        (ControlFlow token:<ControlFlow_Exit exit>)
                      ]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:branch)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name '$newbranch'))}
                          spids: [1609]
                        )
                      ]
                      spids: [1609]
                    )
                  ]
                  spids: [16777215 1585]
                )
              ]
              spids: [16777215 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: [16777215 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: 16777215
                                  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: 16777215
                              arg_word: {(2)}
                              spids: [1736]
                            )
                          ]
                        )
                      ]
                      spids: [1731 1753]
                    )
                  ]
                  spids: [16777215 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
                      ops: [Op_DPipe]
                      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'))})
                      ]
                    )
                    (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: 16777215
                                  arg_word: {(2)}
                                  spids: [1838]
                                )
                              ]
                            )
                          ]
                          spids: [16777215 1833]
                        )
                      ]
                      spids: [16777215 1846]
                    )
                    (C {(describe_detached_head)} {(SQ <'HEAD is now at'>)} {(HEAD)})
                  ]
                  spids: [1756 1767]
                )
              ]
              spids: [16777215 1858]
            )
            (C {(rm)} {(-f)} {(DQ ($ VSub_Name '$GIT_DIR') (/MERGE_HEAD))})
          ]
          spids: [16777215 1571]
        )
      ]
      else_action: [(ControlFlow token:<ControlFlow_Exit exit> arg_word:{(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: [16777215 1895]
        )
      ]
      spids: [16777215 1909]
    )
  ]
)