(CommandList
  children: [
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:OPTIONS_KEEPDASHDASH)
          op: Equal
          rhs: {(EmptyPart)}
          spids: [13]
        )
      ]
      spids: [13]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:OPTIONS_SPEC)
          op: Equal
          rhs: 
            {
              (DQ ('git merge [options] <remote>...\n') ('git merge [options] <msg> HEAD <remote>\n') 
                ('--\n') ('stat                 show a diffstat at the end of the merge\n') 
                ("n                    don't show a diffstat at the end of the merge\n") ('summary              (synonym to --stat)\n') 
                ('log                  add list of one-line log 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') ('ff                   allow fast-forward (default)\n') 
                ('ff-only              abort if fast-forward is not possible\n') ('rerere-autoupdate    update index with any reused conflict resolution\n') 
                ('s,strategy=          merge strategy to use\n') ('X=                   option for selected merge strategy\n') 
                ('m,message=           message to be used for the merge commit (if any)\n')
              )
            }
          spids: [15]
        )
      ]
      spids: [15]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:SUBDIRECTORY_OK) op:Equal rhs:{(Yes)} spids:[36])]
      spids: [36]
    )
    (C {(.)} {(git-sh-setup)})
    (C {(require_work_tree)})
    (C {(cd_to_toplevel)})
    (AndOr
      ops: [Op_DPipe]
      children: [
        (C {(test)} {(-z)} 
          {
            (DQ 
              (CommandSubPart
                command_list: (CommandList children:[(C {(git)} {(ls-files)} {(-u)})])
                left_token: <Left_CommandSub '$('>
                spids: [53 59]
              )
            )
          }
        )
        (C {(die)} {(DQ ('Merge is not possible because you have unmerged files.'))})
      ]
    )
    (AndOr
      ops: [Op_DPipe]
      children: [
        (Pipeline
          children: [(C {(test)} {(-e)} {(DQ ($ VSub_Name '$GIT_DIR') (/MERGE_HEAD))})]
          negated: T
        )
        (C {(die)} {(SQ <'You have not concluded your merge (MERGE_HEAD exists).'>)})
      ]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:LF) op:Equal rhs:{(SQ <'\n'>)} spids:[93])]
      spids: [93]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:all_strategies)
          op: Equal
          rhs: {(SQ <'recur recursive octopus resolve stupid ours subtree'>)}
          spids: [99]
        )
      ]
      spids: [99]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:all_strategies)
          op: Equal
          rhs: {(DQ ($ VSub_Name '$all_strategies') (' recursive-ours recursive-theirs'))}
          spids: [104]
        )
      ]
      spids: [104]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:not_strategies)
          op: Equal
          rhs: {(SQ <'base file index tree'>)}
          spids: [110]
        )
      ]
      spids: [110]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:default_twohead_strategies)
          op: Equal
          rhs: {(SQ <recursive>)}
          spids: [115]
        )
      ]
      spids: [115]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:default_octopus_strategies)
          op: Equal
          rhs: {(SQ <octopus>)}
          spids: [120]
        )
      ]
      spids: [120]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:no_fast_forward_strategies)
          op: Equal
          rhs: {(SQ <'subtree ours'>)}
          spids: [125]
        )
      ]
      spids: [125]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:no_trivial_strategies)
          op: Equal
          rhs: {(SQ <'recursive recur subtree ours recursive-ours recursive-theirs'>)}
          spids: [130]
        )
      ]
      spids: [130]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:use_strategies) op:Equal rhs:{(EmptyPart)} spids:[135])]
      spids: [135]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:xopt) op:Equal rhs:{(EmptyPart)} spids:[137])]
      spids: [137]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:allow_fast_forward) op:Equal rhs:{(t)} spids:[140])]
      spids: [140]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:fast_forward_only)
          op: Equal
          rhs: {(EmptyPart)}
          spids: [143]
        )
      ]
      spids: [143]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:allow_trivial_merge) op:Equal rhs:{(t)} spids:[145])]
      spids: [145]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair lhs:(LhsName name:squash) op:Equal rhs:{(EmptyPart)} spids:[148])
        (assign_pair lhs:(LhsName name:no_commit) op:Equal rhs:{(EmptyPart)} spids:[150])
        (assign_pair lhs:(LhsName name:log_arg) op:Equal rhs:{(EmptyPart)} spids:[152])
        (assign_pair lhs:(LhsName name:rr_arg) op:Equal rhs:{(EmptyPart)} spids:[154])
      ]
      spids: [148]
    )
    (FuncDef
      name: dropsave
      body: 
        (BraceGroup
          children: [
            (AndOr
              ops: [Op_DPipe]
              children: [
                (C {(rm)} {(-f)} {(--)} {(DQ ($ VSub_Name '$GIT_DIR') (/MERGE_HEAD))} 
                  {(DQ ($ VSub_Name '$GIT_DIR') (/MERGE_MSG))} {(DQ ($ VSub_Name '$GIT_DIR') (/MERGE_STASH))} {(DQ ($ VSub_Name '$GIT_DIR') (/MERGE_MODE))}
                )
                (ControlFlow token:<ControlFlow_Exit exit> arg_word:{(1)})
              ]
            )
          ]
          spids: [161]
        )
      spids: [157 160]
    )
    (FuncDef
      name: savestate
      body: 
        (BraceGroup
          children: [
            (SimpleCommand
              words: [{(git)} {(stash)} {(create)}]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_Name '$GIT_DIR') (/MERGE_STASH))}
                  spids: [218]
                )
              ]
            )
          ]
          spids: [205]
        )
      spids: [201 204]
    )
    (FuncDef
      name: restorestate
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-f)} {(DQ ($ VSub_Name '$GIT_DIR') (/MERGE_STASH))})]
                  action: [
                    (SimpleCommand
                      words: [{(git)} {(reset)} {(--hard)} {($ VSub_Name '$head')}]
                      redirects: [
                        (Redir
                          op_id: Redir_Great
                          fd: 16777215
                          arg_word: {(/dev/null)}
                          spids: [257]
                        )
                      ]
                    )
                    (C {(git)} {(stash)} {(apply)} 
                      {
                        (CommandSubPart
                          command_list: 
                            (CommandList
                              children: [(C {(cat)} {(DQ ($ VSub_Name '$GIT_DIR') (/MERGE_STASH))})]
                            )
                          left_token: <Left_CommandSub '$('>
                          spids: [267 274]
                        )
                      }
                    )
                    (SimpleCommand
                      words: [{(git)} {(update-index)} {(--refresh)}]
                      redirects: [
                        (Redir
                          op_id: Redir_Great
                          fd: 16777215
                          arg_word: {(/dev/null)}
                          spids: [283]
                        )
                      ]
                    )
                  ]
                  spids: [16777215 246]
                )
              ]
              spids: [16777215 287]
            )
          ]
          spids: [231]
        )
      spids: [227 230]
    )
    (FuncDef
      name: finish_up_to_date
      body: 
        (BraceGroup
          children: [
            (Case
              to_match: {(DQ ($ VSub_Name '$squash'))}
              arms: [
                (case_arm
                  pat_list: [{(t)}]
                  action: [(C {(echo)} {(DQ ($ VSub_Number '$1') (' (nothing to squash)'))})]
                  spids: [309 310 320 16777215]
                )
                (case_arm
                  pat_list: [{(SQ )}]
                  action: [(C {(echo)} {(DQ ($ VSub_Number '$1'))})]
                  spids: [16777215 325 334 16777215]
                )
              ]
              spids: [300 306 337]
            )
            (C {(dropsave)})
          ]
          spids: [297]
        )
      spids: [292 296]
    )
    (FuncDef
      name: squash_message
      body: 
        (BraceGroup
          children: [
            (C {(echo)} {(Squashed)} {(commit)} {(of)} {(the)} {(following) (Lit_Other ':')})
            (C {(echo)})
            (C {(git)} {(log)} {(--no-merges)} {(--pretty) (Lit_Other '=') (medium)} 
              {(Lit_Other '^') (DQ ($ VSub_Name '$head'))} {($ VSub_Name '$remoteheads')}
            )
          ]
          spids: [350]
        )
      spids: [345 349]
    )
    (FuncDef
      name: finish
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(SQ )} {(Lit_Other '=')} {(DQ ($ VSub_Number '$2'))})]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:rlogm)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name '$GIT_REFLOG_ACTION'))}
                          spids: [415]
                        )
                      ]
                      spids: [415]
                    )
                  ]
                  spids: [16777215 412]
                )
              ]
              else_action: [
                (C {(echo)} {(DQ ($ VSub_Number '$2'))})
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:rlogm)
                      op: Equal
                      rhs: {(DQ ($ VSub_Name '$GIT_REFLOG_ACTION') (': ') ($ VSub_Number '$2'))}
                      spids: [431]
                    )
                  ]
                  spids: [431]
                )
              ]
              spids: [421 439]
            )
            (Case
              to_match: {(DQ ($ VSub_Name '$squash'))}
              arms: [
                (case_arm
                  pat_list: [{(t)}]
                  action: [
                    (C {(echo)} {(DQ ('Squash commit -- not updating HEAD'))})
                    (SimpleCommand
                      words: [{(squash_message)}]
                      redirects: [
                        (Redir
                          op_id: Redir_Great
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_Name '$GIT_DIR') (/SQUASH_MSG))}
                          spids: [464]
                        )
                      ]
                    )
                  ]
                  spids: [451 452 471 16777215]
                )
                (case_arm
                  pat_list: [{(SQ )}]
                  action: [
                    (Case
                      to_match: {(DQ ($ VSub_Name '$merge_msg'))}
                      arms: [
                        (case_arm
                          pat_list: [{(SQ )}]
                          action: [(C {(echo)} {(DQ ('No merge message -- not updating HEAD'))})]
                          spids: [16777215 490 500 16777215]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other '*')}]
                          action: [
                            (AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {(git)} {(update-ref)} {(-m)} {(DQ ($ VSub_Name '$rlogm'))} {(HEAD)} 
                                  {(DQ ($ VSub_Number '$1'))} {(DQ ($ VSub_Name '$head'))}
                                )
                                (ControlFlow
                                  token: <ControlFlow_Exit exit>
                                  arg_word: {(1)}
                                )
                              ]
                            )
                            (C {(git)} {(gc)} {(--auto)})
                          ]
                          spids: [503 504 541 16777215]
                        )
                      ]
                      spids: [479 485 544]
                    )
                  ]
                  spids: [16777215 476 547 16777215]
                )
              ]
              spids: [442 448 550]
            )
            (Case
              to_match: {(DQ ($ VSub_Number '$1'))}
              arms: [
                (case_arm pat_list:[{(SQ )}] spids:[16777215 564 567 16777215])
                (case_arm
                  pat_list: [{(Lit_Other '?') (Lit_Other '*')}]
                  action: [
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (C {(test)} {(DQ ($ VSub_Name '$show_diffstat'))} {(Lit_Other '=')} {(t)})
                          ]
                          action: [
                            (SimpleCommand
                              words: [
                                {(git)}
                                {(diff)}
                                {(--stat)}
                                {(--summary)}
                                {(-M)}
                                {(DQ ($ VSub_Name '$head'))}
                                {(DQ ($ VSub_Number '$1'))}
                              ]
                              more_env: [(env_pair name:GIT_PAGER val:{(SQ )} spids:[595])]
                            )
                          ]
                          spids: [16777215 588]
                        )
                      ]
                      spids: [16777215 618]
                    )
                  ]
                  spids: [570 572 621 16777215]
                )
              ]
              spids: [553 559 624]
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-x)} {(DQ ($ VSub_Name '$GIT_DIR')) (/hooks/post-merge)})]
                  action: [
                    (Case
                      to_match: {(DQ ($ VSub_Name '$squash'))}
                      arms: [
                        (case_arm
                          pat_list: [{(t)}]
                          action: [(C {(DQ ($ VSub_Name '$GIT_DIR')) (/hooks/post-merge)} {(1)})]
                          spids: [656 657 668 16777215]
                        )
                        (case_arm
                          pat_list: [{(SQ )}]
                          action: [(C {(DQ ($ VSub_Name '$GIT_DIR')) (/hooks/post-merge)} {(0)})]
                          spids: [16777215 673 684 16777215]
                        )
                      ]
                      spids: [647 653 687]
                    )
                  ]
                  spids: [16777215 644]
                )
              ]
              spids: [16777215 690]
            )
          ]
          spids: [395]
        )
      spids: [390 394]
    )
    (FuncDef
      name: merge_name
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:remote)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number '$1'))}
                  spids: [703]
                )
              ]
              spids: [703]
            )
            (AndOr
              ops: [Op_DPipe]
              children: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:rh)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (SimpleCommand
                                    words: [
                                      {(git)}
                                      {(rev-parse)}
                                      {(--verify)}
                                      {(DQ ($ VSub_Name '$remote') ('^0'))}
                                    ]
                                    redirects: [
                                      (Redir
                                        op_id: Redir_Great
                                        fd: 2
                                        arg_word: {(/dev/null)}
                                        spids: [722]
                                      )
                                    ]
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [710 724]
                          )
                        }
                      spids: [709]
                    )
                  ]
                  spids: [709]
                )
                (ControlFlow token:<ControlFlow_Return return>)
              ]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (AndOr
                      ops: [Op_DAmp]
                      children: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:truname)
                              op: Equal
                              rhs: 
                                {
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(expr)} {(DQ ($ VSub_Name '$remote'))} {(Lit_Other ':')} 
                                            {(SQ <'\\(.*\\)~[0-9]*$'>)}
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [734 746]
                                  )
                                }
                              spids: [733]
                            )
                          ]
                          spids: [733]
                        )
                        (SimpleCommand
                          words: [
                            {(git)}
                            {(show-ref)}
                            {(-q)}
                            {(--verify)}
                            {(DQ (refs/heads/) ($ VSub_Name '$truname'))}
                          ]
                          redirects: [
                            (Redir
                              op_id: Redir_Great
                              fd: 2
                              arg_word: {(/dev/null)}
                              spids: [764]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  action: [
                    (C {(echo)} 
                      {
                        (DQ ($ VSub_Name '$rh') ("\t\tbranch '") ($ VSub_Name '$truname') 
                          ("' (early part) of .")
                        )
                      }
                    )
                    (ControlFlow token:<ControlFlow_Return return>)
                  ]
                  spids: [16777215 768]
                )
              ]
              spids: [16777215 784]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:found_ref)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (SimpleCommand
                                        words: [
                                          {(git)}
                                          {(rev-parse)}
                                          {(--symbolic-full-name)}
                                          {(--verify)}
                                          {(DQ ($ VSub_Name '$remote'))}
                                        ]
                                        redirects: [
                                          (Redir
                                            op_id: Redir_Great
                                            fd: 2
                                            arg_word: {(/dev/null)}
                                            spids: [805]
                                          )
                                        ]
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [790 807]
                              )
                            }
                          spids: [789]
                        )
                      ]
                      spids: [789]
                    )
                  ]
                  action: [
                    (AndOr
                      ops: [Op_DPipe]
                      children: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:expanded)
                              op: Equal
                              rhs: 
                                {
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(git)} {(check-ref-format)} {(--branch)} 
                                            {(DQ ($ VSub_Name '$remote'))}
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [814 824]
                                  )
                                }
                              spids: [813]
                            )
                          ]
                          spids: [813]
                        )
                        (ControlFlow token:<ControlFlow_Exit exit>)
                      ]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (C {(test)} 
                              {
                                (DQ 
                                  (BracedVarSub
                                    token: <VSub_Name found_ref>
                                    suffix_op: 
                                      (StringUnary
                                        op_id: VOp1_Pound
                                        arg_word: {(refs) (Lit_Slash /) (heads) (Lit_Slash /)}
                                      )
                                    spids: [837 844]
                                  )
                                )
                              } {(KW_Bang '!') (Lit_Other '=')} {(DQ ($ VSub_Name '$found_ref'))}
                            )
                          ]
                          action: [
                            (C {(echo)} 
                              {
                                (DQ ($ VSub_Name '$rh') ("\t\tbranch '") ($ VSub_Name '$expanded') 
                                  ("' of .")
                                )
                              }
                            )
                            (ControlFlow
                              token: <ControlFlow_Return return>
                            )
                          ]
                          spids: [16777215 855]
                        )
                        (if_arm
                          cond: [
                            (C {(test)} 
                              {
                                (DQ 
                                  (BracedVarSub
                                    token: <VSub_Name found_ref>
                                    suffix_op: 
                                      (StringUnary
                                        op_id: VOp1_Pound
                                        arg_word: {(refs) (Lit_Slash /) (remotes) (Lit_Slash /)}
                                      )
                                    spids: [876 883]
                                  )
                                )
                              } {(KW_Bang '!') (Lit_Other '=')} {(DQ ($ VSub_Name '$found_ref'))}
                            )
                          ]
                          action: [
                            (C {(echo)} 
                              {
                                (DQ ($ VSub_Name '$rh') ("\t\tremote branch '") 
                                  ($ VSub_Name '$expanded') ("' of .")
                                )
                              }
                            )
                            (ControlFlow
                              token: <ControlFlow_Return return>
                            )
                          ]
                          spids: [871 894]
                        )
                      ]
                      spids: [16777215 910]
                    )
                  ]
                  spids: [16777215 810]
                )
              ]
              spids: [16777215 913]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(DQ ($ VSub_Name '$remote'))} {(Lit_Other '=')} {(DQ (FETCH_HEAD))})
                        (C {(test)} {(-r)} {(DQ ($ VSub_Name '$GIT_DIR') (/FETCH_HEAD))})
                      ]
                    )
                  ]
                  action: [
                    (C {(sed)} {(-e)} {(SQ <'s/\tnot-for-merge\t/\t\t/'>)} {(-e)} {(1q)} 
                      {(DQ ($ VSub_Name '$GIT_DIR') (/FETCH_HEAD))}
                    )
                    (ControlFlow token:<ControlFlow_Return return>)
                  ]
                  spids: [16777215 942]
                )
              ]
              spids: [16777215 968]
            )
            (C {(echo)} {(DQ ($ VSub_Name '$rh') ("\t\tcommit '") ($ VSub_Name '$remote') ("'"))})
          ]
          spids: [700]
        )
      spids: [695 699]
    )
    (FuncDef
      name: parse_config
      body: 
        (BraceGroup
          children: [
            (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: [{(-n)} {(--no-stat)} {(--no-summary)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:show_diffstat)
                                  op: Equal
                                  rhs: {(false)}
                                  spids: [1023]
                                )
                              ]
                              spids: [1023]
                            )
                          ]
                          spids: [1015 1020 1026 16777215]
                        )
                        (case_arm
                          pat_list: [{(--stat)} {(--summary)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:show_diffstat)
                                  op: Equal
                                  rhs: {(t)}
                                  spids: [1035]
                                )
                              ]
                              spids: [1035]
                            )
                          ]
                          spids: [1029 1032 1038 16777215]
                        )
                        (case_arm
                          pat_list: [{(--log)} {(--no-log)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:log_arg)
                                  op: Equal
                                  rhs: {($ VSub_Number '$1')}
                                  spids: [1047]
                                )
                              ]
                              spids: [1047]
                            )
                          ]
                          spids: [1041 1044 1050 16777215]
                        )
                        (case_arm
                          pat_list: [{(--squash)}]
                          action: [
                            (AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {(test)} {(DQ ($ VSub_Name '$allow_fast_forward'))} {(Lit_Other '=')} 
                                  {(t)}
                                )
                                (C {(die)} {(DQ ('You cannot combine --squash with --no-ff.'))})
                              ]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:squash)
                                  op: Equal
                                  rhs: {(t)}
                                  spids: [1077]
                                )
                                (assign_pair
                                  lhs: (LhsName name:no_commit)
                                  op: Equal
                                  rhs: {(t)}
                                  spids: [1080]
                                )
                              ]
                              spids: [1077]
                            )
                          ]
                          spids: [1053 1054 1083 16777215]
                        )
                        (case_arm
                          pat_list: [{(--no-squash)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:squash)
                                  op: Equal
                                  rhs: {(EmptyPart)}
                                  spids: [1090]
                                )
                                (assign_pair
                                  lhs: (LhsName name:no_commit)
                                  op: Equal
                                  rhs: {(EmptyPart)}
                                  spids: [1092]
                                )
                              ]
                              spids: [1090]
                            )
                          ]
                          spids: [1086 1087 1094 16777215]
                        )
                        (case_arm
                          pat_list: [{(--commit)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:no_commit)
                                  op: Equal
                                  rhs: {(EmptyPart)}
                                  spids: [1101]
                                )
                              ]
                              spids: [1101]
                            )
                          ]
                          spids: [1097 1098 1103 16777215]
                        )
                        (case_arm
                          pat_list: [{(--no-commit)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:no_commit)
                                  op: Equal
                                  rhs: {(t)}
                                  spids: [1110]
                                )
                              ]
                              spids: [1110]
                            )
                          ]
                          spids: [1106 1107 1113 16777215]
                        )
                        (case_arm
                          pat_list: [{(--ff)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:allow_fast_forward)
                                  op: Equal
                                  rhs: {(t)}
                                  spids: [1120]
                                )
                              ]
                              spids: [1120]
                            )
                          ]
                          spids: [1116 1117 1123 16777215]
                        )
                        (case_arm
                          pat_list: [{(--no-ff)}]
                          action: [
                            (AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {(test)} {(DQ ($ VSub_Name '$squash'))} 
                                  {(KW_Bang '!') (Lit_Other '=')} {(t)}
                                )
                                (C {(die)} {(DQ ('You cannot combine --squash with --no-ff.'))})
                              ]
                            )
                            (AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {(test)} {(DQ ($ VSub_Name '$fast_forward_only'))} 
                                  {(KW_Bang '!') (Lit_Other '=')} {(t)}
                                )
                                (C {(die)} {(DQ ('You cannot combine --ff-only with --no-ff.'))})
                              ]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:allow_fast_forward)
                                  op: Equal
                                  rhs: {(f)}
                                  spids: [1172]
                                )
                              ]
                              spids: [1172]
                            )
                          ]
                          spids: [1126 1127 1175 16777215]
                        )
                        (case_arm
                          pat_list: [{(--ff-only)}]
                          action: [
                            (AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {(test)} {(DQ ($ VSub_Name '$allow_fast_forward'))} 
                                  {(KW_Bang '!') (Lit_Other '=')} {(f)}
                                )
                                (C {(die)} {(DQ ('You cannot combine --ff-only with --no-ff.'))})
                              ]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:fast_forward_only)
                                  op: Equal
                                  rhs: {(t)}
                                  spids: [1203]
                                )
                              ]
                              spids: [1203]
                            )
                          ]
                          spids: [1178 1179 1206 16777215]
                        )
                        (case_arm
                          pat_list: [{(--rerere-autoupdate)} {(--no-rerere-autoupdate)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:rr_arg)
                                  op: Equal
                                  rhs: {($ VSub_Number '$1')}
                                  spids: [1215]
                                )
                              ]
                              spids: [1215]
                            )
                          ]
                          spids: [1209 1212 1218 16777215]
                        )
                        (case_arm
                          pat_list: [{(-s)} {(--strategy)}]
                          action: [
                            (C {(shift)})
                            (Case
                              to_match: {(DQ (' ') ($ VSub_Name '$all_strategies') (' '))}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(Lit_Other '*') (DQ (' ') ($ VSub_Number '$1') (' ')) 
                                      (Lit_Other '*')
                                    }
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:use_strategies)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name '$use_strategies') ($ VSub_Number '$1') 
                                                (' ')
                                              )
                                            }
                                          spids: [1251]
                                        )
                                      ]
                                      spids: [1251]
                                    )
                                  ]
                                  spids: [1241 1248 1259 16777215]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Other '*')}]
                                  action: [
                                    (AndOr
                                      ops: [Op_DAmp Op_DPipe]
                                      children: [
                                        (Case
                                          to_match: {(DQ (' ') ($ VSub_Name '$not_strategies') (' '))}
                                          arms: [
                                            (case_arm
                                              pat_list: [
                                                {(Lit_Other '*') 
                                                  (DQ (' ') ($ VSub_Number '$1') (' ')) (Lit_Other '*')
                                                }
                                              ]
                                              action: [(C {(false)})]
                                              spids: [1277 1284 16777215 1290]
                                            )
                                          ]
                                          spids: [1266 1274 1290]
                                        )
                                        (SimpleCommand
                                          words: [{(type)} {(DQ (git-merge-) ($ VSub_Number '$1'))}]
                                          redirects: [
                                            (Redir
                                              op_id: Redir_Great
                                              fd: 16777215
                                              arg_word: {(/dev/null)}
                                              spids: [1302]
                                            )
                                            (Redir
                                              op_id: Redir_GreatAnd
                                              fd: 2
                                              arg_word: {(1)}
                                              spids: [1305]
                                            )
                                          ]
                                        )
                                        (C {(die)} 
                                          {
                                            (DQ ('available strategies are: ') 
                                              ($ VSub_Name '$all_strategies')
                                            )
                                          }
                                        )
                                      ]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:use_strategies)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name '$use_strategies') ($ VSub_Number '$1') 
                                                (' ')
                                              )
                                            }
                                          spids: [1319]
                                        )
                                      ]
                                      spids: [1319]
                                    )
                                  ]
                                  spids: [1262 1263 1327 16777215]
                                )
                              ]
                              spids: [1230 1238 1330]
                            )
                          ]
                          spids: [1221 1224 1333 16777215]
                        )
                        (case_arm
                          pat_list: [{(-X)}]
                          action: [
                            (C {(shift)})
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:xopt)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (BracedVarSub
                                          token: <VSub_Name xopt>
                                          suffix_op: 
                                            (StringUnary
                                              op_id: VTest_ColonPlus
                                              arg_word: {($ VSub_Name '$xopt') (' ')}
                                            )
                                          spids: [1345 1350]
                                        ) 
                                        (CommandSubPart
                                          command_list: 
                                            (CommandList
                                              children: [
                                                (C {(git)} {(rev-parse)} {(--sq-quote)} 
                                                  {(DQ (--) ($ VSub_Number '$1'))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                          spids: [1351 1362]
                                        )
                                      )
                                    }
                                  spids: [1343]
                                )
                              ]
                              spids: [1343]
                            )
                          ]
                          spids: [1336 1337 1366 16777215]
                        )
                        (case_arm
                          pat_list: [{(-m)} {(--message)}]
                          action: [
                            (C {(shift)})
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:merge_msg)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Number '$1'))}
                                  spids: [1378]
                                )
                              ]
                              spids: [1378]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:have_message)
                                  op: Equal
                                  rhs: {(t)}
                                  spids: [1384]
                                )
                              ]
                              spids: [1384]
                            )
                          ]
                          spids: [1369 1372 1388 16777215]
                        )
                        (case_arm
                          pat_list: [{(--)}]
                          action: [(C {(shift)}) (ControlFlow token:<ControlFlow_Break break>)]
                          spids: [1391 1392 1400 16777215]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other '*')}]
                          action: [(C {(usage)})]
                          spids: [1403 1404 1408 16777215]
                        )
                      ]
                      spids: [1006 1012 1411]
                    )
                    (C {(shift)})
                  ]
                  spids: [1003 1417]
                )
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:args_left)
                  op: Equal
                  rhs: {($ VSub_Pound '$#')}
                  spids: [1420]
                )
              ]
              spids: [1420]
            )
          ]
          spids: [988]
        )
      spids: [983 987]
    )
    (AndOr
      ops: [Op_DPipe]
      children: [(C {(test)} {($ VSub_Pound '$#')} {(KW_Bang '!') (Lit_Other '=')} {(0)}) (C {(usage)})]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:have_message) op:Equal rhs:{(EmptyPart)} spids:[1440])]
      spids: [1440]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:branch)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [(C {(git-symbolic-ref)} {(-q)} {(HEAD)})]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [1446 1452]
                      )
                    }
                  spids: [1445]
                )
              ]
              spids: [1445]
            )
          ]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:mergeopts)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(git)} {(config)} 
                                {
                                  (DQ (branch.) 
                                    (BracedVarSub
                                      token: <VSub_Name branch>
                                      suffix_op: 
                                        (StringUnary
                                          op_id: VOp1_Pound
                                          arg_word: {(refs) (Lit_Slash /) (heads) (Lit_Slash /)}
                                        )
                                      spids: [1465 1472]
                                    ) (.mergeoptions)
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [1458 1475]
                      )
                    }
                  spids: [1457]
                )
              ]
              spids: [1457]
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name '$mergeopts'))})]
                  action: [(C {(parse_config)} {($ VSub_Name '$mergeopts')} {(--)})]
                  spids: [16777215 1489]
                )
              ]
              spids: [16777215 1499]
            )
          ]
          spids: [16777215 1454]
        )
      ]
      spids: [16777215 1501]
    )
    (C {(parse_config)} {(DQ ($ VSub_At '$@'))})
    (While
      cond: [
        (Sentence
          child: (C {(test)} {($ VSub_Name '$args_left')} {(-lt)} {($ VSub_Pound '$#')})
          terminator: <Op_Semi ';'>
        )
      ]
      body: 
        (DoGroup
          children: [(Sentence child:(C {(shift)}) terminator:<Op_Semi ';'>)]
          spids: [1521 1526]
        )
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: (C {(test)} {(-z)} {(DQ ($ VSub_Name '$show_diffstat'))})
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} 
                  {
                    (DQ 
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [(C {(git)} {(config)} {(--bool)} {(merge.diffstat)})]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [1546 1554]
                      )
                    )
                  } {(Lit_Other '=')} {(false)}
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:show_diffstat)
                      op: Equal
                      rhs: {(false)}
                      spids: [1563]
                    )
                  ]
                  spids: [1563]
                )
              ]
            )
            (AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} 
                  {
                    (DQ 
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [(C {(git)} {(config)} {(--bool)} {(merge.stat)})]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [1570 1578]
                      )
                    )
                  } {(Lit_Other '=')} {(false)}
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:show_diffstat)
                      op: Equal
                      rhs: {(false)}
                      spids: [1587]
                    )
                  ]
                  spids: [1587]
                )
              ]
            )
            (AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_Name '$show_diffstat'))})
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:show_diffstat)
                      op: Equal
                      rhs: {(t)}
                      spids: [1601]
                    )
                  ]
                  spids: [1601]
                )
              ]
            )
          ]
          spids: [16777215 1540]
        )
      ]
      spids: [16777215 1604]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (AndOr
              ops: [Op_DAmp Op_DAmp Op_DAmp]
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_Name '$have_message'))})
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:second_token)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (SimpleCommand
                                    words: [
                                      {(git)}
                                      {(rev-parse)}
                                      {(--verify)}
                                      {(DQ ($ VSub_Number '$2') ('^0'))}
                                    ]
                                    redirects: [
                                      (Redir
                                        op_id: Redir_Great
                                        fd: 2
                                        arg_word: {(/dev/null)}
                                        spids: [1649]
                                      )
                                    ]
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [1637 1651]
                          )
                        }
                      spids: [1636]
                    )
                  ]
                  spids: [1636]
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:head_commit)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (SimpleCommand
                                    words: [{(git)} {(rev-parse)} {(--verify)} {(DQ (HEAD))}]
                                    redirects: [
                                      (Redir
                                        op_id: Redir_Great
                                        fd: 2
                                        arg_word: {(/dev/null)}
                                        spids: [1668]
                                      )
                                    ]
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [1657 1670]
                          )
                        }
                      spids: [1656]
                    )
                  ]
                  spids: [1656]
                )
                (C {(test)} {(DQ ($ VSub_Name '$second_token'))} {(Lit_Other '=')} 
                  {(DQ ($ VSub_Name '$head_commit'))}
                )
              ]
            )
          ]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:merge_msg)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number '$1'))}
                  spids: [1690]
                )
              ]
              spids: [1690]
            )
            (C {(shift)})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:head_arg)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number '$1'))}
                  spids: [1699]
                )
              ]
              spids: [1699]
            )
            (C {(shift)})
          ]
          spids: [16777215 1687]
        )
        (if_arm
          cond: [
            (Pipeline
              children: [
                (SimpleCommand
                  words: [{(git)} {(rev-parse)} {(--verify)} {(HEAD)}]
                  redirects: [
                    (Redir
                      op_id: Redir_Great
                      fd: 16777215
                      arg_word: {(/dev/null)}
                      spids: [1719]
                    )
                    (Redir op_id:Redir_GreatAnd fd:2 arg_word:{(1)} spids:[1722])
                  ]
                )
              ]
              negated: T
            )
          ]
          action: [
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(1)} {(-ne)} {($ VSub_Pound '$#')})]
                  action: [
                    (SimpleCommand
                      words: [{(echo)} {(DQ ('Can merge only exactly one commit into empty head'))}]
                      redirects: [
                        (Redir
                          op_id: Redir_GreatAnd
                          fd: 16777215
                          arg_word: {(2)}
                          spids: [1756]
                        )
                      ]
                    )
                    (ControlFlow token:<ControlFlow_Exit exit> arg_word:{(1)})
                  ]
                  spids: [16777215 1751]
                )
              ]
              spids: [16777215 1769]
            )
            (AndOr
              ops: [Op_DPipe]
              children: [
                (C {(test)} {(DQ ($ VSub_Name '$squash'))} {(KW_Bang '!') (Lit_Other '=')} {(t)})
                (C {(die)} {(DQ ('Squash commit into empty head not supported yet'))})
              ]
            )
            (AndOr
              ops: [Op_DPipe]
              children: [
                (C {(test)} {(DQ ($ VSub_Name '$allow_fast_forward'))} {(Lit_Other '=')} {(t)})
                (C {(die)} {(DQ ('Non-fast-forward into an empty head does not make sense'))})
              ]
            )
            (AndOr
              ops: [Op_DPipe]
              children: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:rh)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(git)} {(rev-parse)} {(--verify)} {(DQ ($ VSub_Number '$1') ('^0'))})
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [1815 1826]
                          )
                        }
                      spids: [1814]
                    )
                  ]
                  spids: [1814]
                )
                (C {(die)} {(DQ ($ VSub_Number '$1') (' - not something we can merge'))})
              ]
            )
            (AndOr
              ops: [Op_DAmp]
              children: [
                (C {(git)} {(update-ref)} {(-m)} {(DQ ('initial pull'))} {(HEAD)} {(DQ ($ VSub_Name '$rh'))} {(DQ )})
                (C {(git)} {(read-tree)} {(--reset)} {(-u)} {(HEAD)})
              ]
            )
            (ControlFlow token:<ControlFlow_Exit exit>)
          ]
          spids: [1707 1725]
        )
      ]
      else_action: [
        (Assignment
          keyword: Assign_None
          pairs: [(assign_pair lhs:(LhsName name:head_arg) op:Equal rhs:{(HEAD)} spids:[1883])]
          spids: [1883]
        )
        (Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (LhsName name:merge_msg)
              op: Equal
              rhs: 
                {
                  (DQ 
                    (CommandSubPart
                      command_list: 
                        (CommandList
                          children: [
                            (Pipeline
                              children: [
                                (ForEach
                                  iter_name: remote
                                  do_arg_iter: T
                                  body: 
                                    (DoGroup
                                      children: [(C {(merge_name)} {(DQ ($ VSub_Name '$remote'))})]
                                      spids: [1918 1928]
                                    )
                                  spids: [16777215 16777215]
                                )
                                (If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (C {(test)} {(DQ ($ VSub_Name '$have_message'))} 
                                          {(Lit_Other '=')} {(t)}
                                        )
                                      ]
                                      action: [
                                        (C {(git)} {(fmt-merge-msg)} {(-m)} 
                                          {(DQ ($ VSub_Name '$merge_msg'))} {($ VSub_Name '$log_arg')}
                                        )
                                      ]
                                      spids: [16777215 1946]
                                    )
                                  ]
                                  else_action: [
                                    (C {(git)} {(fmt-merge-msg)} {($ VSub_Name '$log_arg')})
                                  ]
                                  spids: [1962 1972]
                                )
                              ]
                              negated: F
                            )
                          ]
                        )
                      left_token: <Left_CommandSub '$('>
                      spids: [1910 1975]
                    )
                  )
                }
              spids: [1908]
            )
          ]
          spids: [1908]
        )
      ]
      spids: [1876 1978]
    )
    (AndOr
      ops: [Op_DPipe]
      children: [
        (Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (LhsName name:head)
              op: Equal
              rhs: 
                {
                  (CommandSubPart
                    command_list: 
                      (CommandList
                        children: [
                          (C {(git)} {(rev-parse)} {(--verify)} 
                            {(DQ ($ VSub_Name '$head_arg')) (Lit_Other '^') (0)}
                          )
                        ]
                      )
                    left_token: <Left_CommandSub '$('>
                    spids: [1981 1993]
                  )
                }
              spids: [1980]
            )
          ]
          spids: [1980]
        )
        (C {(usage)})
      ]
    )
    (Sentence
      child: 
        (AndOr
          ops: [Op_DAmp]
          children: [(C {(test)} {(DQ ($ VSub_Pound '$#'))} {(Lit_Other '=')} {(0)}) (C {(usage)})]
        )
      terminator: <Op_Semi ';'>
    )
    (C {(set_reflog_action)} {(DQ ('merge ') ($ VSub_Star '$*'))})
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:remoteheads) op:Equal rhs:{(EmptyPart)} spids:[2029])]
      spids: [2029]
    )
    (ForEach
      iter_name: remote
      do_arg_iter: T
      body: 
        (DoGroup
          children: [
            (AndOr
              ops: [Op_DPipe]
              children: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:remotehead)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (SimpleCommand
                                    words: [
                                      {(git)}
                                      {(rev-parse)}
                                      {(--verify)}
                                      {(DQ ($ VSub_Name '$remote')) (Lit_Other '^') (0)}
                                    ]
                                    redirects: [
                                      (Redir
                                        op_id: Redir_Great
                                        fd: 2
                                        arg_word: {(/dev/null)}
                                        spids: [2052]
                                      )
                                    ]
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [2039 2054]
                          )
                        }
                      spids: [2038]
                    )
                  ]
                  spids: [2038]
                )
                (C {(die)} {(DQ ($ VSub_Name '$remote') (' - not something we can merge'))})
              ]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:remoteheads)
                  op: Equal
                  rhs: {(DQ (${ VSub_Name remoteheads) ($ VSub_Name '$remotehead') (' '))}
                  spids: [2067]
                )
              ]
              spids: [2067]
            )
            (C {(eval)} {(GITHEAD_) ($ VSub_Name '$remotehead') (Lit_Other '=') (SQ <'"$remote"'>)})
            (C {(export)} {(GITHEAD_) ($ VSub_Name '$remotehead')})
          ]
          spids: [2035 2092]
        )
      spids: [16777215 16777215]
    )
    (Sentence child:(C {(set)} {(x)} {($ VSub_Name '$remoteheads')}) terminator:<Op_Semi ';'>)
    (C {(shift)})
    (Case
      to_match: {(DQ ($ VSub_Name '$use_strategies'))}
      arms: [
        (case_arm
          pat_list: [{(SQ )}]
          action: [
            (Case
              to_match: {(DQ ($ VSub_Pound '$#'))}
              arms: [
                (case_arm
                  pat_list: [{(1)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:var)
                          op: Equal
                          rhs: 
                            {
                              (DQ 
                                (CommandSubPart
                                  command_list: 
                                    (CommandList
                                      children: [(C {(git)} {(config)} {(--get)} {(pull.twohead)})]
                                    )
                                  left_token: <Left_CommandSub '$('>
                                  spids: [2133 2141]
                                )
                              )
                            }
                          spids: [2131]
                        )
                      ]
                      spids: [2131]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name '$var'))})]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:use_strategies)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name '$var'))}
                                  spids: [2159]
                                )
                              ]
                              spids: [2159]
                            )
                          ]
                          spids: [16777215 2156]
                        )
                      ]
                      else_action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:use_strategies)
                              op: Equal
                              rhs: {(DQ ($ VSub_Name '$default_twohead_strategies'))}
                              spids: [2168]
                            )
                          ]
                          spids: [2168]
                        )
                      ]
                      spids: [2165 2174]
                    )
                  ]
                  spids: [2127 2128 2176 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:var)
                          op: Equal
                          rhs: 
                            {
                              (DQ 
                                (CommandSubPart
                                  command_list: 
                                    (CommandList
                                      children: [(C {(git)} {(config)} {(--get)} {(pull.octopus)})]
                                    )
                                  left_token: <Left_CommandSub '$('>
                                  spids: [2185 2193]
                                )
                              )
                            }
                          spids: [2183]
                        )
                      ]
                      spids: [2183]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name '$var'))})]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:use_strategies)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name '$var'))}
                                  spids: [2211]
                                )
                              ]
                              spids: [2211]
                            )
                          ]
                          spids: [16777215 2208]
                        )
                      ]
                      else_action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:use_strategies)
                              op: Equal
                              rhs: {(DQ ($ VSub_Name '$default_octopus_strategies'))}
                              spids: [2220]
                            )
                          ]
                          spids: [2220]
                        )
                      ]
                      spids: [2217 2226]
                    )
                  ]
                  spids: [2179 2180 2228 16777215]
                )
              ]
              spids: [2118 2124 2231]
            )
          ]
          spids: [16777215 2115 2234 16777215]
        )
      ]
      spids: [2105 2111 2236]
    )
    (ForEach
      iter_name: s
      iter_words: [{($ VSub_Name '$use_strategies')}]
      do_arg_iter: F
      body: 
        (DoGroup
          children: [
            (ForEach
              iter_name: ss
              iter_words: [{($ VSub_Name '$no_fast_forward_strategies')}]
              do_arg_iter: F
              body: 
                (DoGroup
                  children: [
                    (Case
                      to_match: {(DQ (' ') ($ VSub_Name '$s') (' '))}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(Lit_Other '*') (DQ (' ') ($ VSub_Name '$ss') (' ')) (Lit_Other '*')}
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:allow_fast_forward)
                                  op: Equal
                                  rhs: {(f)}
                                  spids: [2283]
                                )
                              ]
                              spids: [2283]
                            )
                            (ControlFlow token:<ControlFlow_Break break>)
                          ]
                          spids: [2273 2280 2290 16777215]
                        )
                      ]
                      spids: [2262 2270 2293]
                    )
                  ]
                  spids: [2259 2296]
                )
              spids: [2255 16777215]
            )
            (ForEach
              iter_name: ss
              iter_words: [{($ VSub_Name '$no_trivial_strategies')}]
              do_arg_iter: F
              body: 
                (DoGroup
                  children: [
                    (Case
                      to_match: {(DQ (' ') ($ VSub_Name '$s') (' '))}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(Lit_Other '*') (DQ (' ') ($ VSub_Name '$ss') (' ')) (Lit_Other '*')}
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:allow_trivial_merge)
                                  op: Equal
                                  rhs: {(f)}
                                  spids: [2332]
                                )
                              ]
                              spids: [2332]
                            )
                            (ControlFlow token:<ControlFlow_Break break>)
                          ]
                          spids: [2322 2329 2339 16777215]
                        )
                      ]
                      spids: [2311 2319 2342]
                    )
                  ]
                  spids: [2308 2345]
                )
              spids: [2304 16777215]
            )
          ]
          spids: [2247 2347]
        )
      spids: [2244 16777215]
    )
    (Case
      to_match: {(DQ ($ VSub_Pound '$#'))}
      arms: [
        (case_arm
          pat_list: [{(1)}]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:common)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(git)} {(merge-base)} {(--all)} {($ VSub_Name '$head')} 
                                {(DQ ($ VSub_At '$@'))}
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [2363 2375]
                      )
                    }
                  spids: [2362]
                )
              ]
              spids: [2362]
            )
          ]
          spids: [2358 2359 2378 16777215]
        )
        (case_arm
          pat_list: [{(Lit_Other '*')}]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:common)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(git)} {(merge-base)} {(--all)} {(--octopus)} {($ VSub_Name '$head')} 
                                {(DQ ($ VSub_At '$@'))}
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [2385 2399]
                      )
                    }
                  spids: [2384]
                )
              ]
              spids: [2384]
            )
          ]
          spids: [2380 2381 2402 16777215]
        )
      ]
      spids: [2350 2356 2404]
    )
    (SimpleCommand
      words: [{(echo)} {(DQ ($ VSub_Name '$head'))}]
      redirects: [
        (Redir
          op_id: Redir_Great
          fd: 16777215
          arg_word: {(DQ ($ VSub_Name '$GIT_DIR') (/ORIG_HEAD))}
          spids: [2412]
        )
      ]
    )
    (Case
      to_match: 
        {
          (DQ ($ VSub_Name '$allow_fast_forward') (',') ($ VSub_Pound '$#') (',') ($ VSub_Name '$common') 
            (',') ($ VSub_Name '$no_commit')
          )
        }
      arms: [
        (case_arm
          pat_list: [
            {(Lit_Other '?') (Lit_Comma ',') (Lit_Other '*') (Lit_Comma ',') (SQ ) (Lit_Comma ',') 
              (Lit_Other '*')
            }
          ]
          spids: [2433 2441 2448 16777215]
        )
        (case_arm
          pat_list: [
            {(Lit_Other '?') (Lit_Comma ',') (1) (Lit_Comma ',') (DQ ($ VSub_Number '$1')) 
              (Lit_Comma ',') (Lit_Other '*')
            }
          ]
          action: [
            (C {(finish_up_to_date)} {(DQ ('Already up-to-date.'))})
            (ControlFlow token:<ControlFlow_Exit exit> arg_word:{(0)})
          ]
          spids: [2450 2459 2482 16777215]
        )
        (case_arm
          pat_list: [
            {(t) (Lit_Comma ',') (1) (Lit_Comma ',') (DQ ($ VSub_Name '$head')) (Lit_Comma ',') 
              (Lit_Other '*')
            }
          ]
          action: [
            (C {(echo)} 
              {
                (DQ ('Updating ') 
                  (CommandSubPart
                    command_list: 
                      (CommandList
                        children: [(C {(git)} {(rev-parse)} {(--short)} {($ VSub_Name '$head')})]
                      )
                    left_token: <Left_CommandSub '$('>
                    spids: [2504 2512]
                  ) (..) 
                  (CommandSubPart
                    command_list: 
                      (CommandList
                        children: [(C {(git)} {(rev-parse)} {(--short)} {($ VSub_Number '$1')})]
                      )
                    left_token: <Left_CommandSub '$('>
                    spids: [2514 2522]
                  )
                )
              }
            )
            (SimpleCommand
              words: [{(git)} {(update-index)} {(--refresh)}]
              redirects: [(Redir op_id:Redir_Great fd:2 arg_word:{(/dev/null)} spids:[2532])]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:msg)
                  op: Equal
                  rhs: {(DQ (Fast-forward))}
                  spids: [2536]
                )
              ]
              spids: [2536]
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name '$have_message'))})]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:msg)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name '$msg') (' (no commit created; -m option ignored)'))}
                          spids: [2556]
                        )
                      ]
                      spids: [2556]
                    )
                  ]
                  spids: [16777215 2553]
                )
              ]
              spids: [16777215 2563]
            )
            (AndOr
              ops: [Op_DAmp Op_DAmp Op_DPipe]
              children: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:new_head)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(git)} {(rev-parse)} {(--verify)} {(DQ ($ VSub_Number '$1') ('^0'))})
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [2567 2578]
                          )
                        }
                      spids: [2566]
                    )
                  ]
                  spids: [2566]
                )
                (C {(git)} {(read-tree)} {(-v)} {(-m)} {(-u)} 
                  {(--exclude-per-directory) (Lit_Other '=') (.gitignore)} {($ VSub_Name '$head')} {(DQ ($ VSub_Name '$new_head'))}
                )
                (C {(finish)} {(DQ ($ VSub_Name '$new_head'))} {(DQ ($ VSub_Name '$msg'))})
                (ControlFlow token:<ControlFlow_Exit exit>)
              ]
            )
            (C {(dropsave)})
            (ControlFlow token:<ControlFlow_Exit exit> arg_word:{(0)})
          ]
          spids: [2484 2493 2629 16777215]
        )
        (case_arm
          pat_list: [
            {(Lit_Other '?') (Lit_Comma ',') (1) (Lit_Comma ',') (Lit_Other '?') (Lit_Other '*') 
              (DQ ($ VSub_Name '$LF')) (Lit_Other '?') (Lit_Other '*') (Lit_Comma ',') (Lit_Other '*')
            }
          ]
          spids: [2631 2644 2655 16777215]
        )
        (case_arm
          pat_list: [
            {(Lit_Other '?') (Lit_Comma ',') (1) (Lit_Comma ',') (Lit_Other '*') (Lit_Comma ',')}
          ]
          action: [
            (SimpleCommand
              words: [{(git)} {(update-index)} {(--refresh)}]
              redirects: [(Redir op_id:Redir_Great fd:2 arg_word:{(/dev/null)} spids:[2680])]
            )
            (Case
              to_match: 
                {(DQ ($ VSub_Name '$allow_trivial_merge') (',') ($ VSub_Name '$fast_forward_only'))}
              arms: [
                (case_arm
                  pat_list: [{(t) (Lit_Comma ',')}]
                  action: [
                    (AndOr
                      ops: [Op_DPipe]
                      children: [
                        (SimpleCommand
                          words: [{(git)} {(var)} {(GIT_COMMITTER_IDENT)}]
                          redirects: [
                            (Redir
                              op_id: Redir_Great
                              fd: 16777215
                              arg_word: {(/dev/null)}
                              spids: [2710]
                            )
                          ]
                        )
                        (ControlFlow token:<ControlFlow_Exit exit>)
                      ]
                    )
                    (C {(echo)} {(DQ ('Trying really trivial in-index merge...'))})
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (AndOr
                              ops: [Op_DAmp]
                              children: [
                                (C {(git)} {(read-tree)} {(--trivial)} {(-m)} {(-u)} {(-v)} 
                                  {($ VSub_Name '$common')} {($ VSub_Name '$head')} {(DQ ($ VSub_Number '$1'))}
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:result_tree)
                                      op: Equal
                                      rhs: 
                                        {
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [(C {(git)} {(write-tree)})]
                                              )
                                            left_token: <Left_CommandSub '$('>
                                            spids: [2751 2755]
                                          )
                                        }
                                      spids: [2750]
                                    )
                                  ]
                                  spids: [2750]
                                )
                              ]
                            )
                          ]
                          action: [
                            (C {(echo)} {(DQ (Wonderful.))})
                            (AndOr
                              ops: [Op_DPipe]
                              children: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:result_commit)
                                      op: Equal
                                      rhs: 
                                        {
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (Pipeline
                                                    children: [
                                                      (C {(printf)} {(SQ <'%s\\n'>)} 
                                                        {(DQ ($ VSub_Name '$merge_msg'))}
                                                      )
                                                      (C {(git)} {(commit-tree)} 
                                                        {($ VSub_Name '$result_tree')} {(-p)} {(HEAD)} {(-p)} {(DQ ($ VSub_Number '$1'))}
                                                      )
                                                    ]
                                                    negated: F
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub '$('>
                                            spids: [2769 2802]
                                          )
                                        }
                                      spids: [2768]
                                    )
                                  ]
                                  spids: [2768]
                                )
                                (ControlFlow
                                  token: <ControlFlow_Exit exit>
                                )
                              ]
                            )
                            (C {(finish)} {(DQ ($ VSub_Name '$result_commit'))} {(DQ ('In-index merge'))})
                            (C {(dropsave)})
                            (ControlFlow
                              token: <ControlFlow_Exit exit>
                              arg_word: {(0)}
                            )
                          ]
                          spids: [16777215 2758]
                        )
                      ]
                      spids: [16777215 2828]
                    )
                    (C {(echo)} {(DQ (Nope.))})
                  ]
                  spids: [2695 2697 16777215 2838]
                )
              ]
              spids: [2684 2692 2838]
            )
          ]
          spids: [2657 2663 2841 16777215]
        )
        (case_arm
          pat_list: [{(Lit_Other '*')}]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:up_to_date) op:Equal rhs:{(t)} spids:[2851])]
              spids: [2851]
            )
            (ForEach
              iter_name: remote
              do_arg_iter: T
              body: 
                (DoGroup
                  children: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:common_one)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(git)} {(merge-base)} {(--all)} {($ VSub_Name '$head')} 
                                        {($ VSub_Name '$remote')}
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [2864 2874]
                              )
                            }
                          spids: [2863]
                        )
                      ]
                      spids: [2863]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (C {(test)} {(DQ ($ VSub_Name '$common_one'))} 
                              {(KW_Bang '!') (Lit_Other '=')} {(DQ ($ VSub_Name '$remote'))}
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:up_to_date)
                                  op: Equal
                                  rhs: {(f)}
                                  spids: [2896]
                                )
                              ]
                              spids: [2896]
                            )
                            (ControlFlow token:<ControlFlow_Break break>)
                          ]
                          spids: [16777215 2893]
                        )
                      ]
                      spids: [16777215 2903]
                    )
                  ]
                  spids: [2860 2906]
                )
              spids: [16777215 16777215]
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(DQ ($ VSub_Name '$up_to_date'))} {(Lit_Other '=')} {(t)})]
                  action: [
                    (C {(finish_up_to_date)} {(DQ ('Already up-to-date. Yeeah!'))})
                    (ControlFlow token:<ControlFlow_Exit exit> arg_word:{(0)})
                  ]
                  spids: [16777215 2922]
                )
              ]
              spids: [16777215 2937]
            )
          ]
          spids: [2843 2844 2940 16777215]
        )
      ]
      spids: [2419 2431 2942]
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(DQ ($ VSub_Name '$fast_forward_only'))} {(Lit_Other '=')} {(t)})]
          action: [(C {(die)} {(DQ ('Not possible to fast-forward, aborting.'))})]
          spids: [16777215 2957]
        )
      ]
      spids: [16777215 2966]
    )
    (AndOr
      ops: [Op_DPipe]
      children: [
        (SimpleCommand
          words: [{(git)} {(var)} {(GIT_COMMITTER_IDENT)}]
          redirects: [(Redir op_id:Redir_Great fd:16777215 arg_word:{(/dev/null)} spids:[2978])]
        )
        (ControlFlow token:<ControlFlow_Exit exit>)
      ]
    )
    (Case
      to_match: {(DQ ($ VSub_Name '$use_strategies'))}
      arms: [
        (case_arm
          pat_list: [{(Lit_Other '?') (Lit_Other '*') (SQ <' '>) (Lit_Other '?') (Lit_Other '*')}]
          action: [
            (C {(savestate)})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:single_strategy)
                  op: Equal
                  rhs: {(no)}
                  spids: [3027]
                )
              ]
              spids: [3027]
            )
          ]
          spids: [3010 3017 3031 16777215]
        )
        (case_arm
          pat_list: [{(Lit_Other '*')}]
          action: [
            (C {(rm)} {(-f)} {(DQ ($ VSub_Name '$GIT_DIR') (/MERGE_STASH))})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:single_strategy)
                  op: Equal
                  rhs: {(yes)}
                  spids: [3047]
                )
              ]
              spids: [3047]
            )
          ]
          spids: [3033 3034 3051 16777215]
        )
      ]
      spids: [3002 3008 3053]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair lhs:(LhsName name:result_tree) op:Equal rhs:{(EmptyPart)} spids:[3056])
        (assign_pair lhs:(LhsName name:best_cnt) op:Equal rhs:{(-1)} spids:[3058])
        (assign_pair
          lhs: (LhsName name:best_strategy)
          op: Equal
          rhs: {(EmptyPart)}
          spids: [3061]
        )
        (assign_pair lhs:(LhsName name:wt_strategy) op:Equal rhs:{(EmptyPart)} spids:[3063])
      ]
      spids: [3056]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:merge_was_ok) op:Equal rhs:{(EmptyPart)} spids:[3065])]
      spids: [3065]
    )
    (ForEach
      iter_name: strategy
      iter_words: [{($ VSub_Name '$use_strategies')}]
      do_arg_iter: F
      body: 
        (DoGroup
          children: [
            (AndOr
              ops: [Op_DPipe]
              children: [
                (C {(test)} {(DQ ($ VSub_Name '$wt_strategy'))} {(Lit_Other '=')} {(SQ )})
                (BraceGroup
                  children: [
                    (C {(echo)} {(DQ ('Rewinding the tree to pristine...'))})
                    (C {(restorestate)})
                  ]
                  spids: [3091]
                )
              ]
            )
            (Case
              to_match: {(DQ ($ VSub_Name '$single_strategy'))}
              arms: [
                (case_arm
                  pat_list: [{(no)}]
                  action: [
                    (C {(echo)} {(DQ ('Trying merge strategy ') ($ VSub_Name '$strategy') (...))})
                  ]
                  spids: [3116 3117 3129 16777215]
                )
              ]
              spids: [3107 3113 3132]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:wt_strategy)
                  op: Equal
                  rhs: {($ VSub_Name '$strategy')}
                  spids: [3140]
                )
              ]
              spids: [3140]
            )
            (C {(eval)} 
              {(SQ <'git-merge-$strategy '>) (DQ ($ VSub_Name '$xopt')) 
                (SQ <' $common -- "$head_arg" "$@"'>)
              }
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:exit)
                  op: Equal
                  rhs: {($ VSub_QMark '$?')}
                  spids: [3158]
                )
              ]
              spids: [3158]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(DQ ($ VSub_Name '$no_commit'))} {(Lit_Other '=')} {(t)})
                        (C {(test)} {(DQ ($ VSub_Name '$exit'))} {(Lit_Other '=')} {(0)})
                      ]
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:merge_was_ok)
                          op: Equal
                          rhs: {(t)}
                          spids: [3190]
                        )
                      ]
                      spids: [3190]
                    )
                    (Sentence
                      child: 
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:exit)
                              op: Equal
                              rhs: {(1)}
                              spids: [3194]
                            )
                          ]
                          spids: [3194]
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  spids: [16777215 3187]
                )
              ]
              spids: [16777215 3202]
            )
            (AndOr
              ops: [Op_DPipe]
              children: [
                (C {(test)} {(DQ ($ VSub_Name '$exit'))} {(Lit_Other '=')} {(0)})
                (BraceGroup
                  children: [
                    (If
                      arms: [
                        (if_arm
                          cond: [(C {(test)} {(DQ ($ VSub_Name '$exit'))} {(-eq)} {(1)})]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:cnt)
                                  op: Equal
                                  rhs: 
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (Pipeline
                                                children: [
                                                  (BraceGroup
                                                    children: [
                                                      (C {(git)} {(diff-files)} {(--name-only)})
                                                      (C {(git)} {(ls-files)} {(--unmerged)})
                                                    ]
                                                    spids: [3249]
                                                  )
                                                  (C {(wc)} {(-l)})
                                                ]
                                                negated: F
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub '$('>
                                        spids: [3248 3273]
                                      )
                                    }
                                  spids: [3247]
                                )
                              ]
                              spids: [3247]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (AndOr
                                      ops: [Op_DPipe]
                                      children: [
                                        (C {(test)} {($ VSub_Name '$best_cnt')} {(-le)} {(0)})
                                        (C {(test)} {($ VSub_Name '$cnt')} {(-le)} 
                                          {($ VSub_Name '$best_cnt')}
                                        )
                                      ]
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:best_strategy)
                                          op: Equal
                                          rhs: {($ VSub_Name '$strategy')}
                                          spids: [3300]
                                        )
                                      ]
                                      spids: [3300]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:best_cnt)
                                          op: Equal
                                          rhs: {($ VSub_Name '$cnt')}
                                          spids: [3304]
                                        )
                                      ]
                                      spids: [3304]
                                    )
                                  ]
                                  spids: [16777215 3297]
                                )
                              ]
                              spids: [16777215 3308]
                            )
                          ]
                          spids: [16777215 3244]
                        )
                      ]
                      spids: [16777215 3311]
                    )
                    (ControlFlow token:<ControlFlow_Continue continue>)
                  ]
                  spids: [3218]
                )
              ]
            )
            (AndOr
              ops: [Op_DAmp]
              children: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:result_tree)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: (CommandList children:[(C {(git)} {(write-tree)})])
                            left_token: <Left_CommandSub '$('>
                            spids: [3326 3330]
                          )
                        }
                      spids: [3325]
                    )
                  ]
                  spids: [3325]
                )
                (ControlFlow token:<ControlFlow_Break break>)
              ]
            )
          ]
          spids: [3075 3336]
        )
      spids: [3072 16777215]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (C {(test)} {(SQ )} {(KW_Bang '!') (Lit_Other '=')} {(DQ ($ VSub_Name '$result_tree'))})
          ]
          action: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (C {(test)} {(DQ ($ VSub_Name '$allow_fast_forward'))} {(Lit_Other '=')} {(DQ (t))})
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:parents)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(git)} {(merge-base)} {(--independent)} 
                                        {(DQ ($ VSub_Name '$head'))} {(DQ ($ VSub_At '$@'))}
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [3381 3395]
                              )
                            }
                          spids: [3380]
                        )
                      ]
                      spids: [3380]
                    )
                  ]
                  spids: [16777215 3377]
                )
              ]
              else_action: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:parents)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(git)} {(rev-parse)} {(DQ ($ VSub_Name '$head'))} 
                                    {(DQ ($ VSub_At '$@'))}
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [3402 3414]
                          )
                        }
                      spids: [3401]
                    )
                  ]
                  spids: [3401]
                )
              ]
              spids: [3398 3417]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:parents)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (Pipeline
                                children: [
                                  (C {(echo)} {(DQ ($ VSub_Name '$parents'))})
                                  (C {(sed)} {(-e)} {(SQ <'s/^/-p /'>)})
                                ]
                                negated: F
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [3421 3437]
                      )
                    }
                  spids: [3420]
                )
              ]
              spids: [3420]
            )
            (AndOr
              ops: [Op_DPipe]
              children: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:result_commit)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (Pipeline
                                    children: [
                                      (C {(printf)} {(SQ <'%s\\n'>)} {(DQ ($ VSub_Name '$merge_msg'))})
                                      (C {(git)} {(commit-tree)} {($ VSub_Name '$result_tree')} 
                                        {($ VSub_Name '$parents')}
                                      )
                                    ]
                                    negated: F
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [3441 3461]
                          )
                        }
                      spids: [3440]
                    )
                  ]
                  spids: [3440]
                )
                (ControlFlow token:<ControlFlow_Exit exit>)
              ]
            )
            (C {(finish)} {(DQ ($ VSub_Name '$result_commit'))} 
              {(DQ ('Merge made by ') ($ VSub_Name '$wt_strategy') (.))}
            )
            (C {(dropsave)})
            (ControlFlow token:<ControlFlow_Exit exit> arg_word:{(0)})
          ]
          spids: [16777215 3359]
        )
      ]
      spids: [16777215 3488]
    )
    (Case
      to_match: {(DQ ($ VSub_Name '$best_strategy'))}
      arms: [
        (case_arm
          pat_list: [{(SQ )}]
          action: [
            (C {(restorestate)})
            (Case
              to_match: {(DQ ($ VSub_Name '$use_strategies'))}
              arms: [
                (case_arm
                  pat_list: [
                    {(Lit_Other '?') (Lit_Other '*') (SQ <' '>) (Lit_Other '?') (Lit_Other '*')}
                  ]
                  action: [
                    (SimpleCommand
                      words: [{(echo)} {(DQ ('No merge strategy handled the merge.'))}]
                      redirects: [
                        (Redir
                          op_id: Redir_GreatAnd
                          fd: 16777215
                          arg_word: {(2)}
                          spids: [3531]
                        )
                      ]
                    )
                  ]
                  spids: [3519 3526 3539 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [
                    (SimpleCommand
                      words: [
                        {(echo)}
                        {(DQ ('Merge with strategy ') ($ VSub_Name '$use_strategies') (' failed.'))}
                      ]
                      redirects: [
                        (Redir
                          op_id: Redir_GreatAnd
                          fd: 16777215
                          arg_word: {(2)}
                          spids: [3548]
                        )
                      ]
                    )
                  ]
                  spids: [3542 3543 3558 16777215]
                )
              ]
              spids: [3510 3516 3561]
            )
            (ControlFlow token:<ControlFlow_Exit exit> arg_word:{(2)})
          ]
          spids: [16777215 3504 3569 16777215]
        )
        (case_arm
          pat_list: [{(DQ ($ VSub_Name '$wt_strategy'))}]
          spids: [3572 3574 3581 16777215]
        )
        (case_arm
          pat_list: [{(Lit_Other '*')}]
          action: [
            (C {(echo)} {(DQ ('Rewinding the tree to pristine...'))})
            (C {(restorestate)})
            (C {(echo)} 
              {(DQ ('Using the ') ($ VSub_Name '$best_strategy') (' to prepare resolving by hand.'))}
            )
            (C {(git-merge-) ($ VSub_Name '$best_strategy')} {($ VSub_Name '$common')} {(--)} 
              {(DQ ($ VSub_Name '$head_arg'))} {(DQ ($ VSub_At '$@'))}
            )
          ]
          spids: [3583 3584 3622 16777215]
        )
      ]
      spids: [3494 3500 3624]
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(DQ ($ VSub_Name '$squash'))} {(Lit_Other '=')} {(t)})]
          action: [(C {(finish)})]
          spids: [16777215 3639]
        )
      ]
      else_action: [
        (ForEach
          iter_name: remote
          do_arg_iter: T
          body: (DoGroup children:[(C {(echo)} {($ VSub_Name '$remote')})] spids:[3652 3660])
          redirects: [
            (Redir
              op_id: Redir_Great
              fd: 16777215
              arg_word: {(DQ ($ VSub_Name '$GIT_DIR') (/MERGE_HEAD))}
              spids: [3662]
            )
          ]
          spids: [16777215 16777215]
        )
        (AndOr
          ops: [Op_DPipe]
          children: [
            (SimpleCommand
              words: [{(printf)} {(SQ <'%s\\n'>)} {(DQ ($ VSub_Name '$merge_msg'))}]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_Name '$GIT_DIR') (/MERGE_MSG))}
                  spids: [3679]
                )
              ]
            )
            (C {(die)} {(DQ ('Could not write to ') ($ VSub_Name '$GIT_DIR') (/MERGE_MSG))})
          ]
        )
        (AndOr
          ops: [Op_DPipe]
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (C {(test)} {(DQ ($ VSub_Name '$allow_fast_forward'))} 
                      {(KW_Bang '!') (Lit_Other '=')} {(t)}
                    )
                  ]
                  action: [(C {(printf)} {(DQ ('%s'))} {(no-ff)})]
                  spids: [16777215 3711]
                )
              ]
              else_action: [(C {(Lit_Other ':')})]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_Name '$GIT_DIR') (/MERGE_MODE))}
                  spids: [3731]
                )
              ]
              spids: [3723 3729]
            )
            (C {(die)} {(DQ ('Could not write to ') ($ VSub_Name '$GIT_DIR') (/MERGE_MODE))})
          ]
        )
      ]
      spids: [3644 3748]
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(DQ ($ VSub_Name '$merge_was_ok'))} {(Lit_Other '=')} {(t)})]
          action: [
            (SimpleCommand
              words: [
                {(echo)}
                {(DQ ('Automatic merge went well; stopped before committing as requested'))}
              ]
              redirects: [(Redir op_id:Redir_GreatAnd fd:16777215 arg_word:{(2)} spids:[3768])]
            )
            (ControlFlow token:<ControlFlow_Exit exit> arg_word:{(0)})
          ]
          spids: [16777215 3763]
        )
      ]
      else_action: [
        (BraceGroup
          children: [
            (C {(echo)} {(SQ <'\n'> <'Conflicts:\n'>)})
            (Pipeline
              children: [
                (C {(git)} {(ls-files)} {(--unmerged)})
                (C {(sed)} {(-e)} {(SQ <'s/^[^\t]*\t/\t/'>)})
                (C {(uniq)})
              ]
              negated: F
            )
          ]
          redirects: [
            (Redir
              op_id: Redir_DGreat
              fd: 16777215
              arg_word: {(DQ ($ VSub_Name '$GIT_DIR') (/MERGE_MSG))}
              spids: [3821]
            )
          ]
          spids: [3785]
        )
        (C {(git)} {(rerere)} {($ VSub_Name '$rr_arg')})
        (C {(die)} {(DQ ('Automatic merge failed; fix conflicts and then commit the result.'))})
      ]
      spids: [3782 3841]
    )
  ]
)