(CommandList
  children: [
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:SUBDIRECTORY_OK) op:Equal rhs:{(Yes)} spids:[16])]
      spids: [16]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:OPTIONS_KEEPDASHDASH) op:Equal rhs:{(SQ )} spids:[19])]
      spids: [19]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:OPTIONS_STUCKLONG) op:Equal rhs:{(Yes)} spids:[21])]
      spids: [21]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:OPTIONS_SPEC)
          op: Equal
          rhs: 
            {
              (DQ ("git pull [options] [<repository> [<refspec>...]]\n") ("\n") 
                ("Fetch one or more remote refs and integrate it/them with the current HEAD.\n") ("--\n") ("v,verbose                  be more verbose\n") 
                ("q,quiet                    be more quiet\n") ("progress                   force progress reporting\n") ("\n") ("  Options related to merging\n") 
                (
"r,rebase?false|true|preserve incorporate changes by rebasing rather than merging\n"
                ) ("n!                         do not show a diffstat at the end of the merge\n") 
                ("stat                       show a diffstat at the end of the merge\n") ("summary                    (synonym to --stat)\n") 
                (
"log?n                      add (at most <n>) entries from shortlog to merge commit message\n"
                ) ("squash                     create a single commit instead of doing a merge\n") 
                ("commit                     perform a commit if the merge succeeds (default)\n") ("e,edit                       edit message before committing\n") 
                ("ff                         allow fast-forward\n") ("ff-only!                   abort if fast-forward is not possible\n") 
                (
"verify-signatures          verify that the named commit has a valid GPG signature\n"
                ) ("s,strategy=strategy        merge strategy to use\n") 
                ("X,strategy-option=option   option for selected merge strategy\n") ("S,gpg-sign?key-id          GPG sign commit\n") ("\n") ("  Options related to fetching\n") 
                ("all                        fetch from all remotes\n") ("a,append                   append to .git/FETCH_HEAD instead of overwriting\n") 
                ("upload-pack=path           path to upload pack on remote end\n") ("f,force                    force overwrite of local branch\n") 
                ("t,tags                     fetch all tags and associated objects\n") ("p,prune                    prune remote-tracking branches no longer on remote\n") 
                ("recurse-submodules?on-demand control recursive fetching of submodules\n") ("dry-run                    dry run\n") ("k,keep                     keep downloaded pack\n") 
                ("depth=depth                deepen history of shallow clone\n") ("unshallow                  convert to a complete repository\n") 
                ("update-shallow             accept refs that update .git/shallow\n") ("refmap=refmap              specify fetch refmap\n")
              )
            }
          spids: [24]
        )
      ]
      spids: [24]
    )
    (AndOr
      children: [
        (C {(test)} {($ VSub_Pound "$#")} {(-gt)} {(0)})
        (Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (LhsName name:args)
              op: Equal
              rhs: {(DQ ($ VSub_Star "$*"))}
              spids: [77]
            )
          ]
          spids: [77]
        )
      ]
      op_id: Op_DAmp
    )
    (C {(.)} {(git-sh-setup)})
    (C {(.)} {(git-sh-i18n)})
    (C {(set_reflog_action)} 
      {
        (DQ (pull) 
          (BracedVarSub
            token: <VSub_Name args>
            suffix_op: (StringUnary op_id:VTest_Plus arg_word:{(" ") ($ VSub_Name "$args")})
            spids: [94 99]
          )
        )
      }
    )
    (C {(require_work_tree_exists)})
    (C {(cd_to_toplevel)})
    (FuncDef
      name: die_conflict
      body: 
        (BraceGroup
          children: [
            (C {(git)} {(diff-index)} {(--cached)} {(--name-status)} {(-r)} {(--ignore-submodules)} {(HEAD)} 
              {(--)}
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} 
                          {
                            (CommandSubPart
                              command_list: 
                                (CommandList
                                  children: [
                                    (AndOr
                                      children: [
                                        (C {(git)} {(config)} {(--bool)} {(--get)} 
                                          {(advice.resolveConflict)}
                                        )
                                        (C {(echo)} {(true)})
                                      ]
                                      op_id: Op_DPipe
                                    )
                                  ]
                                )
                              left_token: <Left_CommandSub "$(">
                              spids: [137 153]
                            )
                          } {(Lit_Other "=")} {(DQ (true))} {(Lit_Other "]")}
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(die)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(gettext)} 
                                    {
                                      (DQ ("Pull is not possible because you have unmerged files.\n") 
                                        (
"Please, fix them up in the work tree, and then use 'git add/rm <file>'\n"
                                        ) ("as appropriate to mark resolution and make a commit.")
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [170 178]
                          )
                        )
                      }
                    )
                  ]
                  spids: [-1 164]
                )
              ]
              else_action: [
                (C {(die)} 
                  {
                    (DQ 
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(gettext)} 
                                {(DQ ("Pull is not possible because you have unmerged files."))}
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [188 194]
                      )
                    )
                  }
                )
              ]
              spids: [182 198]
            )
          ]
          spids: [113]
        )
      spids: [108 112]
    )
    (FuncDef
      name: die_merge
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} 
                          {
                            (CommandSubPart
                              command_list: 
                                (CommandList
                                  children: [
                                    (AndOr
                                      children: [
                                        (C {(git)} {(config)} {(--bool)} {(--get)} 
                                          {(advice.resolveConflict)}
                                        )
                                        (C {(echo)} {(true)})
                                      ]
                                      op_id: Op_DPipe
                                    )
                                  ]
                                )
                              left_token: <Left_CommandSub "$(">
                              spids: [215 231]
                            )
                          } {(Lit_Other "=")} {(DQ (true))} {(Lit_Other "]")}
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(die)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(gettext)} 
                                    {
                                      (DQ 
                                        (
"You have not concluded your merge (MERGE_HEAD exists).\n"
                                        ) ("Please, commit your changes before merging.")
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [248 255]
                          )
                        )
                      }
                    )
                  ]
                  spids: [-1 242]
                )
              ]
              else_action: [
                (C {(die)} 
                  {
                    (DQ 
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(gettext)} 
                                {(DQ ("You have not concluded your merge (MERGE_HEAD exists)."))}
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [265 271]
                      )
                    )
                  }
                )
              ]
              spids: [259 275]
            )
          ]
          spids: [208]
        )
      spids: [203 207]
    )
    (AndOr
      children: [
        (C {(test)} {(-z)} 
          {
            (DQ 
              (CommandSubPart
                command_list: (CommandList children:[(C {(git)} {(ls-files)} {(-u)})])
                left_token: <Left_CommandSub "$(">
                spids: [285 291]
              )
            )
          }
        )
        (C {(die_conflict)})
      ]
      op_id: Op_DPipe
    )
    (AndOr
      children: [(C {(test)} {(-f)} {(DQ ($ VSub_Name "$GIT_DIR") (/MERGE_HEAD))}) (C {(die_merge)})]
      op_id: Op_DAmp
    )
    (FuncDef
      name: bool_or_string_config
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (SimpleCommand
                  words: [{(git)} {(config)} {(--bool)} {(DQ ($ VSub_Number "$1"))}]
                  redirects: [(Redir op_id:Redir_Great fd:2 arg_word:{(/dev/null)} spids:[330])]
                )
                (C {(git)} {(config)} {(DQ ($ VSub_Number "$1"))})
              ]
              op_id: Op_DPipe
            )
          ]
          spids: [317]
        )
      spids: [312 316]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair lhs:(LhsName name:strategy_args) op:Equal rhs:{(SQ )} spids:[346])
        (assign_pair lhs:(LhsName name:diffstat) op:Equal rhs:{(SQ )} spids:[348])
        (assign_pair lhs:(LhsName name:no_commit) op:Equal rhs:{(SQ )} spids:[350])
        (assign_pair lhs:(LhsName name:squash) op:Equal rhs:{(SQ )} spids:[352])
        (assign_pair lhs:(LhsName name:no_ff) op:Equal rhs:{(SQ )} spids:[354])
        (assign_pair lhs:(LhsName name:ff_only) op:Equal rhs:{(SQ )} spids:[356])
      ]
      spids: [346]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair lhs:(LhsName name:log_arg) op:Equal rhs:{(SQ )} spids:[358])
        (assign_pair lhs:(LhsName name:verbosity) op:Equal rhs:{(SQ )} spids:[360])
        (assign_pair lhs:(LhsName name:progress) op:Equal rhs:{(SQ )} spids:[362])
        (assign_pair lhs:(LhsName name:recurse_submodules) op:Equal rhs:{(SQ )} spids:[364])
        (assign_pair lhs:(LhsName name:verify_signatures) op:Equal rhs:{(SQ )} spids:[366])
      ]
      spids: [358]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair lhs:(LhsName name:merge_args) op:Equal rhs:{(SQ )} spids:[368])
        (assign_pair lhs:(LhsName name:edit) op:Equal rhs:{(SQ )} spids:[370])
        (assign_pair lhs:(LhsName name:rebase_args) op:Equal rhs:{(SQ )} spids:[372])
        (assign_pair lhs:(LhsName name:all) op:Equal rhs:{(SQ )} spids:[374])
        (assign_pair lhs:(LhsName name:append) op:Equal rhs:{(SQ )} spids:[376])
        (assign_pair lhs:(LhsName name:upload_pack) op:Equal rhs:{(SQ )} spids:[378])
        (assign_pair lhs:(LhsName name:force) op:Equal rhs:{(SQ )} spids:[380])
        (assign_pair lhs:(LhsName name:tags) op:Equal rhs:{(SQ )} spids:[382])
        (assign_pair lhs:(LhsName name:prune) op:Equal rhs:{(SQ )} spids:[384])
      ]
      spids: [368]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair lhs:(LhsName name:keep) op:Equal rhs:{(SQ )} spids:[386])
        (assign_pair lhs:(LhsName name:depth) op:Equal rhs:{(SQ )} spids:[388])
        (assign_pair lhs:(LhsName name:unshallow) op:Equal rhs:{(SQ )} spids:[390])
        (assign_pair lhs:(LhsName name:update_shallow) op:Equal rhs:{(SQ )} spids:[392])
        (assign_pair lhs:(LhsName name:refmap) op:Equal rhs:{(SQ )} spids:[394])
      ]
      spids: [386]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:curr_branch)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: (CommandList children:[(C {(git)} {(symbolic-ref)} {(-q)} {(HEAD)})])
                left_token: <Left_CommandSub "$(">
                spids: [397 405]
              )
            }
          spids: [396]
        )
      ]
      spids: [396]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:curr_branch_short)
          op: Equal
          rhs: 
            {
              (DQ 
                (BracedVarSub
                  token: <VSub_Name curr_branch>
                  suffix_op: 
                    (StringUnary
                      op_id: VOp1_Pound
                      arg_word: {(refs) (Lit_Slash /) (heads) (Lit_Slash /)}
                    )
                  spids: [409 416]
                )
              )
            }
          spids: [407]
        )
      ]
      spids: [407]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:rebase)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (C {(bool_or_string_config)} 
                        {(branch.) ($ VSub_Name "$curr_branch_short") (.rebase)}
                      )
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [420 426]
              )
            }
          spids: [419]
        )
      ]
      spids: [419]
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$rebase"))})]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:rebase)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [(C {(bool_or_string_config)} {(pull.rebase)})]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [442 446]
                      )
                    }
                  spids: [441]
                )
              ]
              spids: [441]
            )
          ]
          spids: [-1 438]
        )
      ]
      spids: [-1 448]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:pull_ff)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: (CommandList children:[(C {(bool_or_string_config)} {(pull.ff)})])
                left_token: <Left_CommandSub "$(">
                spids: [455 459]
              )
            }
          spids: [454]
        )
      ]
      spids: [454]
    )
    (Case
      to_match: {(DQ ($ VSub_Name "$pull_ff"))}
      arms: [
        (case_arm
          pat_list: [{(true)}]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:no_ff) op:Equal rhs:{(--ff)} spids:[473])]
              spids: [473]
            )
          ]
          spids: [469 470 477 -1]
        )
        (case_arm
          pat_list: [{(false)}]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:no_ff) op:Equal rhs:{(--no-ff)} spids:[483])]
              spids: [483]
            )
          ]
          spids: [479 480 487 -1]
        )
        (case_arm
          pat_list: [{(only)}]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:ff_only) op:Equal rhs:{(--ff-only)} spids:[493])]
              spids: [493]
            )
          ]
          spids: [489 490 497 -1]
        )
      ]
      spids: [461 467 499]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:dry_run) op:Equal rhs:{(SQ )} spids:[503])]
      spids: [503]
    )
    (While
      cond: [(C {(Lit_Other ":")})]
      body: 
        (DoGroup
          children: [
            (Case
              to_match: {(DQ ($ VSub_Number "$1"))}
              arms: [
                (case_arm
                  pat_list: [{(-q)} {(--quiet)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:verbosity)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$verbosity") (" -q"))}
                          spids: [527]
                        )
                      ]
                      spids: [527]
                    )
                  ]
                  spids: [521 524 533 -1]
                )
                (case_arm
                  pat_list: [{(-v)} {(--verbose)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:verbosity)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$verbosity") (" -v"))}
                          spids: [542]
                        )
                      ]
                      spids: [542]
                    )
                  ]
                  spids: [536 539 548 -1]
                )
                (case_arm
                  pat_list: [{(--progress)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:progress)
                          op: Equal
                          rhs: {(--progress)}
                          spids: [555]
                        )
                      ]
                      spids: [555]
                    )
                  ]
                  spids: [551 552 558 -1]
                )
                (case_arm
                  pat_list: [{(--no-progress)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:progress)
                          op: Equal
                          rhs: {(--no-progress)}
                          spids: [565]
                        )
                      ]
                      spids: [565]
                    )
                  ]
                  spids: [561 562 568 -1]
                )
                (case_arm
                  pat_list: [{(-n)} {(--no-stat)} {(--no-summary)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:diffstat)
                          op: Equal
                          rhs: {(--no-stat)}
                          spids: [579]
                        )
                      ]
                      spids: [579]
                    )
                  ]
                  spids: [571 576 582 -1]
                )
                (case_arm
                  pat_list: [{(--stat)} {(--summary)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:diffstat)
                          op: Equal
                          rhs: {(--stat)}
                          spids: [591]
                        )
                      ]
                      spids: [591]
                    )
                  ]
                  spids: [585 588 594 -1]
                )
                (case_arm
                  pat_list: [{(--log)} {(--log) (Lit_Other "=") (Lit_Other "*")} {(--no-log)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:log_arg)
                          op: Equal
                          rhs: {(DQ ($ VSub_Number "$1"))}
                          spids: [607]
                        )
                      ]
                      spids: [607]
                    )
                  ]
                  spids: [597 604 612 -1]
                )
                (case_arm
                  pat_list: [{(--no-commit)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:no_commit)
                          op: Equal
                          rhs: {(--no-commit)}
                          spids: [619]
                        )
                      ]
                      spids: [619]
                    )
                  ]
                  spids: [615 616 622 -1]
                )
                (case_arm
                  pat_list: [{(--commit)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:no_commit)
                          op: Equal
                          rhs: {(--commit)}
                          spids: [629]
                        )
                      ]
                      spids: [629]
                    )
                  ]
                  spids: [625 626 632 -1]
                )
                (case_arm
                  pat_list: [{(-e)} {(--edit)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:edit)
                          op: Equal
                          rhs: {(--edit)}
                          spids: [641]
                        )
                      ]
                      spids: [641]
                    )
                  ]
                  spids: [635 638 644 -1]
                )
                (case_arm
                  pat_list: [{(--no-edit)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:edit)
                          op: Equal
                          rhs: {(--no-edit)}
                          spids: [651]
                        )
                      ]
                      spids: [651]
                    )
                  ]
                  spids: [647 648 654 -1]
                )
                (case_arm
                  pat_list: [{(--squash)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:squash)
                          op: Equal
                          rhs: {(--squash)}
                          spids: [661]
                        )
                      ]
                      spids: [661]
                    )
                  ]
                  spids: [657 658 664 -1]
                )
                (case_arm
                  pat_list: [{(--no-squash)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:squash)
                          op: Equal
                          rhs: {(--no-squash)}
                          spids: [671]
                        )
                      ]
                      spids: [671]
                    )
                  ]
                  spids: [667 668 674 -1]
                )
                (case_arm
                  pat_list: [{(--ff)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:no_ff)
                          op: Equal
                          rhs: {(--ff)}
                          spids: [681]
                        )
                      ]
                      spids: [681]
                    )
                  ]
                  spids: [677 678 684 -1]
                )
                (case_arm
                  pat_list: [{(--no-ff)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:no_ff)
                          op: Equal
                          rhs: {(--no-ff)}
                          spids: [691]
                        )
                      ]
                      spids: [691]
                    )
                  ]
                  spids: [687 688 694 -1]
                )
                (case_arm
                  pat_list: [{(--ff-only)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:ff_only)
                          op: Equal
                          rhs: {(--ff-only)}
                          spids: [701]
                        )
                      ]
                      spids: [701]
                    )
                  ]
                  spids: [697 698 704 -1]
                )
                (case_arm
                  pat_list: [{(-s) (Lit_Other "*")} {(--strategy) (Lit_Other "=") (Lit_Other "*")}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:strategy_args)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$strategy_args") (" ") ($ VSub_Number "$1"))}
                          spids: [716]
                        )
                      ]
                      spids: [716]
                    )
                  ]
                  spids: [707 713 724 -1]
                )
                (case_arm
                  pat_list: [
                    {(-X) (Lit_Other "*")}
                    {(--strategy-option) (Lit_Other "=") (Lit_Other "*")}
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:merge_args)
                          op: Equal
                          rhs: 
                            {
                              (DQ ($ VSub_Name "$merge_args") (" ") 
                                (CommandSubPart
                                  command_list: 
                                    (CommandList
                                      children: [
                                        (C {(git)} {(rev-parse)} {(--sq-quote)} 
                                          {(DQ ($ VSub_Number "$1"))}
                                        )
                                      ]
                                    )
                                  left_token: <Left_CommandSub "$(">
                                  spids: [740 750]
                                )
                              )
                            }
                          spids: [736]
                        )
                      ]
                      spids: [736]
                    )
                  ]
                  spids: [727 733 754 -1]
                )
                (case_arm
                  pat_list: [{(-r) (Lit_Other "*")} {(--rebase) (Lit_Other "=") (Lit_Other "*")}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:rebase)
                          op: Equal
                          rhs: 
                            {
                              (DQ 
                                (BracedVarSub
                                  token: <VSub_Number 1>
                                  suffix_op: (StringUnary op_id:VOp1_Pound arg_word:{("*=")})
                                  spids: [768 772]
                                )
                              )
                            }
                          spids: [766]
                        )
                      ]
                      spids: [766]
                    )
                  ]
                  spids: [757 763 776 -1]
                )
                (case_arm
                  pat_list: [{(--rebase)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:rebase)
                          op: Equal
                          rhs: {(true)}
                          spids: [783]
                        )
                      ]
                      spids: [783]
                    )
                  ]
                  spids: [779 780 787 -1]
                )
                (case_arm
                  pat_list: [{(--no-rebase)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:rebase)
                          op: Equal
                          rhs: {(false)}
                          spids: [794]
                        )
                      ]
                      spids: [794]
                    )
                  ]
                  spids: [790 791 798 -1]
                )
                (case_arm
                  pat_list: [{(--recurse-submodules)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:recurse_submodules)
                          op: Equal
                          rhs: {(--recurse-submodules)}
                          spids: [805]
                        )
                      ]
                      spids: [805]
                    )
                  ]
                  spids: [801 802 809 -1]
                )
                (case_arm
                  pat_list: [{(--recurse-submodules) (Lit_Other "=") (Lit_Other "*")}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:recurse_submodules)
                          op: Equal
                          rhs: {(DQ ($ VSub_Number "$1"))}
                          spids: [818]
                        )
                      ]
                      spids: [818]
                    )
                  ]
                  spids: [812 815 824 -1]
                )
                (case_arm
                  pat_list: [{(--no-recurse-submodules)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:recurse_submodules)
                          op: Equal
                          rhs: {(--no-recurse-submodules)}
                          spids: [831]
                        )
                      ]
                      spids: [831]
                    )
                  ]
                  spids: [827 828 835 -1]
                )
                (case_arm
                  pat_list: [{(--verify-signatures)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:verify_signatures)
                          op: Equal
                          rhs: {(--verify-signatures)}
                          spids: [842]
                        )
                      ]
                      spids: [842]
                    )
                  ]
                  spids: [838 839 846 -1]
                )
                (case_arm
                  pat_list: [{(--no-verify-signatures)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:verify_signatures)
                          op: Equal
                          rhs: {(--no-verify-signatures)}
                          spids: [853]
                        )
                      ]
                      spids: [853]
                    )
                  ]
                  spids: [849 850 857 -1]
                )
                (case_arm
                  pat_list: [{(--gpg-sign)} {(-S)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:gpg_sign_args)
                          op: Equal
                          rhs: {(-S)}
                          spids: [866]
                        )
                      ]
                      spids: [866]
                    )
                  ]
                  spids: [860 863 870 -1]
                )
                (case_arm
                  pat_list: [{(--gpg-sign) (Lit_Other "=") (Lit_Other "*")}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:gpg_sign_args)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(git)} {(rev-parse)} {(--sq-quote)} 
                                        {
                                          (DQ (-S) 
                                            (BracedVarSub
                                              token: <VSub_Number 1>
                                              suffix_op: 
                                                (StringUnary
                                                  op_id: VOp1_Pound
                                                  arg_word: {("--gpg-sign=")}
                                                )
                                              spids: [889 893]
                                            )
                                          )
                                        }
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [880 895]
                              )
                            }
                          spids: [879]
                        )
                      ]
                      spids: [879]
                    )
                  ]
                  spids: [873 876 898 -1]
                )
                (case_arm
                  pat_list: [{(-S) (Lit_Other "*")}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:gpg_sign_args)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(git)} {(rev-parse)} {(--sq-quote)} {(DQ ($ VSub_Number "$1"))})
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [907 917]
                              )
                            }
                          spids: [906]
                        )
                      ]
                      spids: [906]
                    )
                  ]
                  spids: [901 903 920 -1]
                )
                (case_arm
                  pat_list: [{(--dry-run)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:dry_run)
                          op: Equal
                          rhs: {(--dry-run)}
                          spids: [927]
                        )
                      ]
                      spids: [927]
                    )
                  ]
                  spids: [923 924 931 -1]
                )
                (case_arm
                  pat_list: [{(--all)} {(--no-all)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:all)
                          op: Equal
                          rhs: {($ VSub_Number "$1")}
                          spids: [940]
                        )
                      ]
                      spids: [940]
                    )
                  ]
                  spids: [934 937 943 -1]
                )
                (case_arm
                  pat_list: [{(-a)} {(--append)} {(--no-append)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:append)
                          op: Equal
                          rhs: {($ VSub_Number "$1")}
                          spids: [954]
                        )
                      ]
                      spids: [954]
                    )
                  ]
                  spids: [946 951 957 -1]
                )
                (case_arm
                  pat_list: [{(--upload-pack) (Lit_Other "=") (Lit_Other "*")} {(--no-upload-pack)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:upload_pack)
                          op: Equal
                          rhs: {($ VSub_Number "$1")}
                          spids: [968]
                        )
                      ]
                      spids: [968]
                    )
                  ]
                  spids: [960 965 971 -1]
                )
                (case_arm
                  pat_list: [{(-f)} {(--force)} {(--no-force)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:force)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$force") (" ") ($ VSub_Number "$1"))}
                          spids: [982]
                        )
                      ]
                      spids: [982]
                    )
                  ]
                  spids: [974 979 989 -1]
                )
                (case_arm
                  pat_list: [{(-t)} {(--tags)} {(--no-tags)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:tags)
                          op: Equal
                          rhs: {($ VSub_Number "$1")}
                          spids: [1000]
                        )
                      ]
                      spids: [1000]
                    )
                  ]
                  spids: [992 997 1003 -1]
                )
                (case_arm
                  pat_list: [{(-p)} {(--prune)} {(--no-prune)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:prune)
                          op: Equal
                          rhs: {($ VSub_Number "$1")}
                          spids: [1014]
                        )
                      ]
                      spids: [1014]
                    )
                  ]
                  spids: [1006 1011 1017 -1]
                )
                (case_arm
                  pat_list: [{(-k)} {(--keep)} {(--no-keep)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:keep)
                          op: Equal
                          rhs: {($ VSub_Number "$1")}
                          spids: [1028]
                        )
                      ]
                      spids: [1028]
                    )
                  ]
                  spids: [1020 1025 1031 -1]
                )
                (case_arm
                  pat_list: [{(--depth) (Lit_Other "=") (Lit_Other "*")} {(--no-depth)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:depth)
                          op: Equal
                          rhs: {($ VSub_Number "$1")}
                          spids: [1042]
                        )
                      ]
                      spids: [1042]
                    )
                  ]
                  spids: [1034 1039 1045 -1]
                )
                (case_arm
                  pat_list: [{(--unshallow)} {(--no-unshallow)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:unshallow)
                          op: Equal
                          rhs: {($ VSub_Number "$1")}
                          spids: [1054]
                        )
                      ]
                      spids: [1054]
                    )
                  ]
                  spids: [1048 1051 1057 -1]
                )
                (case_arm
                  pat_list: [{(--update-shallow)} {(--no-update-shallow)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:update_shallow)
                          op: Equal
                          rhs: {($ VSub_Number "$1")}
                          spids: [1066]
                        )
                      ]
                      spids: [1066]
                    )
                  ]
                  spids: [1060 1063 1069 -1]
                )
                (case_arm
                  pat_list: [{(--refmap) (Lit_Other "=") (Lit_Other "*")} {(--no-refmap)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:refmap)
                          op: Equal
                          rhs: {($ VSub_Number "$1")}
                          spids: [1080]
                        )
                      ]
                      spids: [1080]
                    )
                  ]
                  spids: [1072 1077 1083 -1]
                )
                (case_arm
                  pat_list: [{(-h)} {(--help-all)}]
                  action: [(C {(usage)})]
                  spids: [1086 1089 1095 -1]
                )
                (case_arm
                  pat_list: [{(--)}]
                  action: [(C {(shift)}) (ControlFlow token:<ControlFlow_Break break>)]
                  spids: [1098 1099 1108 -1]
                )
                (case_arm
                  pat_list: [{(Lit_Other "*")}]
                  action: [(C {(usage)})]
                  spids: [1111 1112 1118 -1]
                )
              ]
              spids: [512 518 1121]
            )
            (C {(shift)})
          ]
          spids: [509 1126]
        )
    )
    (Case
      to_match: {(DQ ($ VSub_Name "$rebase"))}
      arms: [
        (case_arm
          pat_list: [{(preserve)}]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:rebase) op:Equal rhs:{(true)} spids:[1141])]
              spids: [1141]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:rebase_args)
                  op: Equal
                  rhs: {(--preserve-merges)}
                  spids: [1145]
                )
              ]
              spids: [1145]
            )
          ]
          spids: [1137 1138 1149 -1]
        )
        (case_arm pat_list:[{(true)}{(false)}{(SQ )}] spids:[115111571160-1])
        (case_arm
          pat_list: [{(Lit_Other "*")}]
          action: [
            (C {(echo)} {(DQ ("Invalid value for --rebase, should be true, false, or preserve"))})
            (C {(usage)})
            (C {(exit)} {(1)})
          ]
          spids: [1162 1163 1181 -1]
        )
      ]
      spids: [1129 1135 1183]
    )
    (FuncDef
      name: error_on_no_merge_candidates
      body: 
        (BraceGroup
          children: [
            (SimpleCommand
              words: [{(exec)}]
              redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[1196])]
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(true)} {(Lit_Other "=")} {(DQ ($ VSub_Name "$rebase"))})]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:op_type)
                          op: Equal
                          rhs: {(rebase)}
                          spids: [1217]
                        )
                      ]
                      spids: [1217]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:op_prep)
                          op: Equal
                          rhs: {(against)}
                          spids: [1221]
                        )
                      ]
                      spids: [1221]
                    )
                  ]
                  spids: [-1 1214]
                )
              ]
              else_action: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:op_type)
                      op: Equal
                      rhs: {(merge)}
                      spids: [1228]
                    )
                  ]
                  spids: [1228]
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [(assign_pair lhs:(LhsName name:op_prep) op:Equal rhs:{(with)} spids:[1232])]
                  spids: [1232]
                )
              ]
              spids: [1225 1236]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:upstream)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(git)} {(config)} 
                                {(DQ (branch.) ($ VSub_Name "$curr_branch_short") (.merge))}
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [1241 1251]
                      )
                    }
                  spids: [1240]
                )
              ]
              spids: [1240]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:remote)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(git)} {(config)} 
                                {(DQ (branch.) ($ VSub_Name "$curr_branch_short") (.remote))}
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [1255 1265]
                      )
                    }
                  spids: [1254]
                )
              ]
              spids: [1254]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {($ VSub_Pound "$#")} {(-gt)} {(1)} {(Lit_Other "]")})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(Lit_Other "[")} {(DQ ($ VSub_Name "$rebase"))} {(Lit_Other "=")} 
                                  {(true)} {(Lit_Other "]")}
                                )
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [(C {(printf)} {(DQ ("There is no candidate for rebasing against "))})]
                          spids: [-1 1300]
                        )
                      ]
                      else_action: [(C {(printf)} {(DQ ("There are no candidates for merging "))})]
                      spids: [1310 1320]
                    )
                    (C {(echo)} {(DQ ("among the refs that you just fetched."))})
                    (C {(echo)} 
                      {
                        (DQ 
                          (
"Generally this means that you provided a wildcard refspec which had no"
                          )
                        )
                      }
                    )
                    (C {(echo)} {(DQ ("matches on the remote end."))})
                  ]
                  spids: [-1 1282]
                )
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (AndOr
                          children: [
                            (C {(Lit_Other "[")} {($ VSub_Pound "$#")} {(-gt)} {(0)} {(Lit_Other "]")})
                            (C {(Lit_Other "[")} {(DQ ($ VSub_Number "$1"))} 
                              {(KW_Bang "!") (Lit_Other "=")} {(DQ ($ VSub_Name "$remote"))} {(Lit_Other "]")}
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(echo)} 
                      {
                        (DQ ("You asked to pull from the remote '") ($ VSub_Number "$1") 
                          ("', but did not specify")
                        )
                      }
                    )
                    (C {(echo)} {(DQ ("a branch. Because this is not the default configured remote"))})
                    (C {(echo)} 
                      {
                        (DQ 
                          (
"for your current branch, you must specify a branch on the command line."
                          )
                        )
                      }
                    )
                  ]
                  spids: [1344 1374]
                )
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$curr_branch"))} {(-o)} {(-z)} 
                          {(DQ ($ VSub_Name "$upstream"))} {(Lit_Other "]")}
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (C {(.)} {(git-parse-remote)})
                    (C {(error_on_missing_default_upstream)} {(DQ (pull))} {($ VSub_Name "$op_type")} 
                      {($ VSub_Name "$op_prep")} {(DQ ("git pull <remote> <branch>"))}
                    )
                  ]
                  spids: [1400 1421]
                )
              ]
              else_action: [
                (C {(echo)} 
                  {
                    (DQ ("Your configuration specifies to ") ($ VSub_Name "$op_type") (" ") 
                      ($ VSub_Name "$op_prep") (" the ref '") 
                      (BracedVarSub
                        token: <VSub_Name upstream>
                        suffix_op: 
                          (StringUnary
                            op_id: VOp1_Pound
                            arg_word: {(refs) (Lit_Slash /) (heads) (Lit_Slash /)}
                          )
                        spids: [1457 1464]
                      ) ("'")
                    )
                  }
                )
                (C {(echo)} {(DQ ("from the remote, but no such ref was fetched."))})
              ]
              spids: [1446 1476]
            )
            (C {(exit)} {(1)})
          ]
          spids: [1191]
        )
      spids: [1186 1190]
    )
    (AndOr
      children: [
        (C {(test)} {(true)} {(Lit_Other "=")} {(DQ ($ VSub_Name "$rebase"))})
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Pipeline
                      children: [
                        (SimpleCommand
                          words: [{(git)} {(rev-parse)} {(-q)} {(--verify)} {(HEAD)}]
                          redirects: [
                            (Redir
                              op_id: Redir_Great
                              fd: -1
                              arg_word: {(/dev/null)}
                              spids: [1515]
                            )
                          ]
                        )
                      ]
                      negated: True
                    )
                  ]
                  action: [
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (C {(test)} {(-f)} 
                              {
                                (DQ 
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [(C {(git)} {(rev-parse)} {(--git-path)} {(index)})]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [1533 1541]
                                  )
                                )
                              }
                            )
                          ]
                          action: [
                            (C {(die)} 
                              {
                                (DQ 
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(gettext)} 
                                            {
                                              (DQ 
                                                (
"updating an unborn branch with changes added to the index"
                                                )
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [1551 1557]
                                  )
                                )
                              }
                            )
                          ]
                          spids: [-1 1545]
                        )
                      ]
                      spids: [-1 1561]
                    )
                  ]
                  spids: [-1 1519]
                )
              ]
              else_action: [
                (C {(require_clean_work_tree)} {(DQ ("pull with rebase"))} 
                  {(DQ ("Please commit or stash them."))}
                )
              ]
              spids: [1564 1578]
            )
            (AndOr
              children: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:oldremoteref)
                      op: Equal
                      rhs: {(SQ )}
                      spids: [1581]
                    )
                  ]
                  spids: [1581]
                )
                (AndOr
                  children: [
                    (C {(test)} {(-n)} {(DQ ($ VSub_Name "$curr_branch"))})
                    (AndOr
                      children: [
                        (C {(.)} {(git-parse-remote)})
                        (AndOr
                          children: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:remoteref)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (CommandSubPart
                                          command_list: 
                                            (CommandList
                                              children: [
                                                (SimpleCommand
                                                  words: [
                                                    {(get_remote_merge_branch)}
                                                    {(DQ ($ VSub_At "$@"))}
                                                  ]
                                                  redirects: [
                                                    (Redir
                                                      op_id: Redir_Great
                                                      fd: 2
                                                      arg_word: {(/dev/null)}
                                                      spids: [1613]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub "$(">
                                          spids: [1606 1615]
                                        )
                                      )
                                    }
                                  spids: [1604]
                                )
                              ]
                              spids: [1604]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:oldremoteref)
                                  op: Equal
                                  rhs: 
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (SimpleCommand
                                                words: [
                                                  {(git)}
                                                  {(merge-base)}
                                                  {(--fork-point)}
                                                  {(DQ ($ VSub_Name "$remoteref"))}
                                                  {($ VSub_Name "$curr_branch")}
                                                ]
                                                redirects: [
                                                  (Redir
                                                    op_id: Redir_Great
                                                    fd: 2
                                                    arg_word: {(/dev/null)}
                                                    spids: [1635]
                                                  )
                                                ]
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub "$(">
                                        spids: [1622 1637]
                                      )
                                    }
                                  spids: [1621]
                                )
                              ]
                              spids: [1621]
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [1498]
        )
      ]
      op_id: Op_DAmp
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:orig_head)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [(C {(git)} {(rev-parse)} {(-q)} {(--verify)} {(HEAD)})]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [1642 1652]
              )
            }
          spids: [1641]
        )
      ]
      spids: [1641]
    )
    (AndOr
      children: [
        (C {(git)} {(fetch)} {($ VSub_Name "$verbosity")} {($ VSub_Name "$progress")} 
          {($ VSub_Name "$dry_run")} {($ VSub_Name "$recurse_submodules")} {($ VSub_Name "$all")} {($ VSub_Name "$append")} 
          {
            (BracedVarSub
              token: <VSub_Name upload_pack>
              suffix_op: 
                (StringUnary
                  op_id: VTest_ColonPlus
                  arg_word: {(DQ ($ VSub_Name "$upload_pack"))}
                )
              spids: [1671 1677]
            )
          } {($ VSub_Name "$force")} {($ VSub_Name "$tags")} {($ VSub_Name "$prune")} {($ VSub_Name "$keep")} 
          {($ VSub_Name "$depth")} {($ VSub_Name "$unshallow")} {($ VSub_Name "$update_shallow")} {($ VSub_Name "$refmap")} 
          {(--update-head-ok)} {(DQ ($ VSub_At "$@"))}
        )
        (C {(exit)} {(1)})
      ]
      op_id: Op_DPipe
    )
    (AndOr
      children: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$dry_run"))}) (C {(exit)} {(0)})]
      op_id: Op_DPipe
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:curr_head)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [(C {(git)} {(rev-parse)} {(-q)} {(--verify)} {(HEAD)})]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [1724 1734]
              )
            }
          spids: [1723]
        )
      ]
      spids: [1723]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (AndOr
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$orig_head"))})
                (C {(test)} {(DQ ($ VSub_Name "$curr_head"))} {(KW_Bang "!") (Lit_Other "=")} 
                  {(DQ ($ VSub_Name "$orig_head"))}
                )
              ]
              op_id: Op_DAmp
            )
          ]
          action: [
            (SimpleCommand
              words: [
                {(eval_gettextln)}
                {
                  (DQ ("Warning: fetch updated the current branch head.\n") 
                    ("Warning: fast-forwarding your working tree from\n") ("Warning: commit ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (orig_head.)
                  )
                }
              ]
              redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[1792])]
            )
            (C {(git)} {(update-index)} {(-q)} {(--refresh)})
            (AndOr
              children: [
                (C {(git)} {(read-tree)} {(-u)} {(-m)} {(DQ ($ VSub_Name "$orig_head"))} 
                  {(DQ ($ VSub_Name "$curr_head"))}
                )
                (C {(die)} 
                  {
                    (DQ 
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(eval_gettext)} 
                                {
                                  (DQ ("Cannot fast-forward your working tree.\n") 
                                    ("After making sure that you saved anything precious from\n") (Lit_Other "$") (" git diff ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("orig_head\n") 
                                    ("output, run\n") (Lit_Other "$") (" git reset --hard\n") ("to recover.")
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [1827 1842]
                      )
                    )
                  }
                )
              ]
              op_id: Op_DPipe
            )
          ]
          spids: [-1 1761]
        )
      ]
      spids: [-1 1846]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:merge_head)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (Pipeline
                        children: [
                          (C {(sed)} {(-e)} {(SQ <"/\tnot-for-merge\t/d">)} {(-e)} {(SQ <"s/\t.*//">)} 
                            {(DQ ($ VSub_Name "$GIT_DIR")) (/FETCH_HEAD)}
                          )
                          (C {(tr)} {(SQ <"\\012">)} {(SQ <" ">)})
                        ]
                        negated: False
                      )
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [1850 1885]
              )
            }
          spids: [1849]
        )
      ]
      spids: [1849]
    )
    (Case
      to_match: {(DQ ($ VSub_Name "$merge_head"))}
      arms: [
        (case_arm
          pat_list: [{(SQ )}]
          action: [(C {(error_on_no_merge_candidates)} {(DQ ($ VSub_At "$@"))})]
          spids: [-1 1898 1908 -1]
        )
        (case_arm
          pat_list: [{(Lit_Other "?") (Lit_Other "*") (SQ <" ">) (Lit_Other "?") (Lit_Other "*")}]
          action: [
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$orig_head"))})]
                  action: [
                    (C {(die)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(gettext)} 
                                    {(DQ ("Cannot merge multiple branches into empty head"))}
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [1937 1943]
                          )
                        )
                      }
                    )
                  ]
                  spids: [-1 1931]
                )
              ]
              spids: [-1 1947]
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(true)} {(Lit_Other "=")} {(DQ ($ VSub_Name "$rebase"))})]
                  action: [
                    (C {(die)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(gettext)} {(DQ ("Cannot rebase onto multiple branches"))})
                                ]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [1969 1975]
                          )
                        )
                      }
                    )
                  ]
                  spids: [-1 1963]
                )
              ]
              spids: [-1 1979]
            )
          ]
          spids: [1910 1917 1982 -1]
        )
      ]
      spids: [1888 1894 1984]
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$orig_head"))})]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:empty_tree)
                  op: Equal
                  rhs: {(4b825dc642cb6eb9a060e54bf8d69288fbee4904)}
                  spids: [2022]
                )
              ]
              spids: [2022]
            )
            (AndOr
              children: [
                (C {(git)} {(read-tree)} {(-m)} {(-u)} {($ VSub_Name "$empty_tree")} 
                  {($ VSub_Name "$merge_head")}
                )
                (C {(git)} {(update-ref)} {(-m)} {(DQ ("initial pull"))} {(HEAD)} 
                  {($ VSub_Name "$merge_head")} {(DQ ($ VSub_Name "$curr_head"))}
                )
              ]
              op_id: Op_DAmp
            )
            (C {(exit)})
          ]
          spids: [-1 2003]
        )
      ]
      spids: [-1 2062]
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(true)} {(Lit_Other "=")} {(DQ ($ VSub_Name "$rebase"))})]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:o)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(git)} {(show-branch)} {(--merge-base)} {($ VSub_Name "$curr_branch")} 
                                {($ VSub_Name "$merge_head")} {($ VSub_Name "$oldremoteref")}
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [2081 2093]
                      )
                    }
                  spids: [2080]
                )
              ]
              spids: [2080]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (C {(test)} {(DQ ($ VSub_Name "$oldremoteref"))} {(Lit_Other "=")} 
                      {(DQ ($ VSub_Name "$o"))}
                    )
                  ]
                  action: [(C {(unset)} {(oldremoteref)})]
                  spids: [-1 2111]
                )
              ]
              spids: [-1 2119]
            )
          ]
          spids: [-1 2077]
        )
      ]
      spids: [-1 2121]
    )
    (Case
      to_match: {(DQ ($ VSub_Name "$rebase"))}
      arms: [
        (case_arm
          pat_list: [{(true)}]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:eval)
                  op: Equal
                  rhs: 
                    {
                      (DQ ("git-rebase ") ($ VSub_Name "$diffstat") (" ") ($ VSub_Name "$strategy_args") 
                        (" ") ($ VSub_Name "$merge_args") (" ") ($ VSub_Name "$rebase_args") (" ") ($ VSub_Name "$verbosity")
                      )
                    }
                  spids: [2136]
                )
              ]
              spids: [2136]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:eval)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$eval") (" ") ($ VSub_Name "$gpg_sign_args"))}
                  spids: [2151]
                )
              ]
              spids: [2151]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:eval)
                  op: Equal
                  rhs: 
                    {
                      (DQ ($ VSub_Name "$eval") (" --onto ") ($ VSub_Name "$merge_head") (" ") 
                        (BracedVarSub
                          token: <VSub_Name oldremoteref>
                          suffix_op: 
                            (StringUnary
                              op_id: VTest_ColonHyphen
                              arg_word: {($ VSub_Name "$merge_head")}
                            )
                          spids: [2165 2169]
                        )
                      )
                    }
                  spids: [2159]
                )
              ]
              spids: [2159]
            )
          ]
          spids: [2132 2133 2173 -1]
        )
        (case_arm
          pat_list: [{(Lit_Other "*")}]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:eval)
                  op: Equal
                  rhs: 
                    {
                      (DQ ("git-merge ") ($ VSub_Name "$diffstat") (" ") ($ VSub_Name "$no_commit") (" ") 
                        ($ VSub_Name "$verify_signatures") (" ") ($ VSub_Name "$edit") (" ") ($ VSub_Name "$squash") (" ") ($ VSub_Name "$no_ff") (" ") 
                        ($ VSub_Name "$ff_only")
                      )
                    }
                  spids: [2179]
                )
              ]
              spids: [2179]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:eval)
                  op: Equal
                  rhs: 
                    {
                      (DQ ($ VSub_Name "$eval") (" ") ($ VSub_Name "$log_arg") (" ") 
                        ($ VSub_Name "$strategy_args") (" ") ($ VSub_Name "$merge_args") (" ") ($ VSub_Name "$verbosity") (" ") ($ VSub_Name "$progress")
                      )
                    }
                  spids: [2198]
                )
              ]
              spids: [2198]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:eval)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$eval") (" ") ($ VSub_Name "$gpg_sign_args"))}
                  spids: [2214]
                )
              ]
              spids: [2214]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:eval)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$eval") (" FETCH_HEAD"))}
                  spids: [2222]
                )
              ]
              spids: [2222]
            )
          ]
          spids: [2175 2176 2229 -1]
        )
      ]
      spids: [2124 2130 2231]
    )
    (C {(eval)} {(DQ ("exec ") ($ VSub_Name "$eval"))})
  ]
)