(CommandList
  children: [
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:SUBDIRECTORY_OK) op:Equal rhs:{(Yes)} spids:[13])]
      spids: [13]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:OPTIONS_KEEPDASHDASH) op:Equal rhs:{(SQ )} spids:[16])]
      spids: [16]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:OPTIONS_STUCKLONG) op:Equal rhs:{(t)} spids:[18])]
      spids: [18]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:OPTIONS_SPEC)
          op: Equal
          rhs: 
            {
              (DQ 
                (
"git rebase [-i] [options] [--exec <cmd>] [--onto <newbase>] [<upstream>] [<branch>]\n"
                ) ("git rebase [-i] [options] [--exec <cmd>] [--onto <newbase>] --root [<branch>]\n") 
                ("git-rebase --continue | --abort | --skip | --edit-todo\n") ("--\n") (" Available options are\n") 
                ("v,verbose!         display a diffstat of what changed upstream\n") ("q,quiet!           be quiet. implies --no-stat\n") 
                ("autostash          automatically stash/stash pop before and after\n") ("fork-point         use 'merge-base --fork-point' to refine upstream\n") 
                ("onto=!             rebase onto given branch instead of upstream\n") ("p,preserve-merges! try to recreate merges instead of ignoring them\n") 
                ("s,strategy=!       use the given merge strategy\n") ("no-ff!             cherry-pick all commits, even if unchanged\n") 
                ("m,merge!           use merging strategies to rebase\n") ("i,interactive!     let the user edit the list of commits to rebase\n") 
                ("x,exec=!           add exec lines after each commit of the editable list\n") ("k,keep-empty\t   preserve empty commits during rebase\n") 
                ("f,force-rebase!    force rebase even if branch is up to date\n") ("X,strategy-option=! pass the argument through to the merge strategy\n") 
                ("stat!              display a diffstat of what changed upstream\n") ("n,no-stat!         do not show diffstat of what changed upstream\n") 
                ("verify             allow pre-rebase hook to run\n") ("rerere-autoupdate  allow rerere to update index with resolved conflicts\n") 
                ("root!              rebase all reachable commits up to the root(s)\n") ("autosquash         move commits that begin with squash!/fixup! under -i\n") 
                ("committer-date-is-author-date! passed to 'git am'\n") ("ignore-date!       passed to 'git am'\n") ("whitespace=!       passed to 'git apply'\n") 
                ("ignore-whitespace! passed to 'git apply'\n") ("C=!                passed to 'git apply'\n") ("S,gpg-sign?        GPG-sign commits\n") 
                (" Actions:\n") ("continue!          continue\n") ("abort!             abort and check out the original branch\n") 
                ("skip!              skip current patch and continue\n") ("edit-todo!         edit the todo list during an interactive rebase\n")
              )
            }
          spids: [21]
        )
      ]
      spids: [21]
    )
    (C {(.)} {(git-sh-setup)})
    (C {(set_reflog_action)} {(rebase)})
    (C {(require_work_tree_exists)})
    (C {(cd_to_toplevel)})
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:LF) op:Equal rhs:{(SQ <"\n">)} spids:[75])]
      spids: [75]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:ok_to_skip_pre_rebase) op:Equal rhs:{(SQ )} spids:[80])]
      spids: [80]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:resolvemsg)
          op: Equal
          rhs: 
            {
              (DQ ("\n") 
                (CommandSubPart
                  command_list: 
                    (CommandList
                      children: [
                        (C {(gettext)} 
                          {
                            (SQ 
                              <
"When you have resolved this problem, run \"git rebase --continue\".\n"
                              > <"If you prefer to skip this patch, run \"git rebase --skip\" instead.\n"> 
                              <
"To check out the original branch and stop rebasing, run \"git rebase --abort\"."
                              >
                            )
                          }
                        )
                      ]
                    )
                  left_token: <Left_CommandSub "$(">
                  spids: [85 93]
                ) ("\n")
              )
            }
          spids: [82]
        )
      ]
      spids: [82]
    )
    (C {(unset)} {(onto)})
    (C {(unset)} {(restrict_revision)})
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:cmd) op:Equal rhs:{(SQ )} spids:[105])]
      spids: [105]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:strategy) op:Equal rhs:{(SQ )} spids:[107])]
      spids: [107]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:strategy_opts) op:Equal rhs:{(SQ )} spids:[109])]
      spids: [109]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:do_merge) op:Equal rhs:{(SQ )} spids:[111])]
      spids: [111]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:merge_dir)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$GIT_DIR")) (/rebase-merge)}
          spids: [113]
        )
      ]
      spids: [113]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:apply_dir)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$GIT_DIR")) (/rebase-apply)}
          spids: [119]
        )
      ]
      spids: [119]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:verbose) op:Equal rhs:{(SQ )} spids:[125])]
      spids: [125]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:diffstat) op:Equal rhs:{(SQ )} spids:[127])]
      spids: [127]
    )
    (AndOr
      children: [
        (C {(test)} 
          {
            (DQ 
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [(C {(git)} {(config)} {(--bool)} {(rebase.stat)})]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [132 140]
              )
            )
          } {(Lit_Other "=")} {(true)}
        )
        (Assignment
          keyword: Assign_None
          pairs: [(assign_pair lhs:(LhsName name:diffstat) op:Equal rhs:{(t)} spids:[149])]
          spids: [149]
        )
      ]
      op_id: Op_DAmp
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:autostash)
          op: Equal
          rhs: 
            {
              (DQ 
                (CommandSubPart
                  command_list: 
                    (CommandList
                      children: [
                        (AndOr
                          children: [
                            (C {(git)} {(config)} {(--bool)} {(rebase.autostash)})
                            (C {(echo)} {(false)})
                          ]
                          op_id: Op_DPipe
                        )
                      ]
                    )
                  left_token: <Left_CommandSub "$(">
                  spids: [154 168]
                )
              )
            }
          spids: [152]
        )
      ]
      spids: [152]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:fork_point) op:Equal rhs:{(auto)} spids:[171])]
      spids: [171]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:git_am_opt) op:Equal rhs:{(SQ )} spids:[174])]
      spids: [174]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:rebase_root) op:Equal rhs:{(SQ )} spids:[176])]
      spids: [176]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:force_rebase) op:Equal rhs:{(SQ )} spids:[178])]
      spids: [178]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:allow_rerere_autoupdate)
          op: Equal
          rhs: {(SQ )}
          spids: [180]
        )
      ]
      spids: [180]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:in_progress) op:Equal rhs:{(SQ )} spids:[185])]
      spids: [185]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:type) op:Equal rhs:{(SQ )} spids:[190])]
      spids: [190]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:state_dir) op:Equal rhs:{(SQ )} spids:[195])]
      spids: [195]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:action) op:Equal rhs:{(SQ )} spids:[200])]
      spids: [200]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:preserve_merges) op:Equal rhs:{(SQ )} spids:[202])]
      spids: [202]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:autosquash) op:Equal rhs:{(SQ )} spids:[204])]
      spids: [204]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:keep_empty) op:Equal rhs:{(SQ )} spids:[206])]
      spids: [206]
    )
    (AndOr
      children: [
        (C {(test)} 
          {
            (DQ 
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [(C {(git)} {(config)} {(--bool)} {(rebase.autosquash)})]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [211 219]
              )
            )
          } {(Lit_Other "=")} {(DQ (true))}
        )
        (Assignment
          keyword: Assign_None
          pairs: [(assign_pair lhs:(LhsName name:autosquash) op:Equal rhs:{(t)} spids:[230])]
          spids: [230]
        )
      ]
      op_id: Op_DAmp
    )
    (Case
      to_match: 
        {
          (DQ 
            (CommandSubPart
              command_list: 
                (CommandList
                  children: [(C {(git)} {(config)} {(--bool)} {(commit.gpgsign)})]
                )
              left_token: <Left_CommandSub "$(">
              spids: [236 244]
            )
          )
        }
      arms: [
        (case_arm
          pat_list: [{(true)}]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:gpg_sign_opt) op:Equal rhs:{(-S)} spids:[252])]
              spids: [252]
            )
          ]
          spids: [249 250 255 -1]
        )
        (case_arm
          pat_list: [{(Lit_Other "*")}]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:gpg_sign_opt) op:Equal rhs:{(SQ )} spids:[260])]
              spids: [260]
            )
          ]
          spids: [257 258 262 -1]
        )
      ]
      spids: [233 247 264]
    )
    (FuncDef
      name: read_basic_state
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(test)} {(-f)} {(DQ ($ VSub_Name "$state_dir") (/head-name))})
                (AndOr
                  children: [
                    (C {(test)} {(-f)} {(DQ ($ VSub_Name "$state_dir") (/onto))})
                    (AndOr
                      children: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:head_name)
                              op: Equal
                              rhs: 
                                {
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(cat)} {(DQ ($ VSub_Name "$state_dir")) (/head-name)})
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [300 307]
                                  )
                                }
                              spids: [299]
                            )
                          ]
                          spids: [299]
                        )
                        (AndOr
                          children: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:onto)
                                  op: Equal
                                  rhs: 
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (C {(cat)} {(DQ ($ VSub_Name "$state_dir")) (/onto)})
                                            ]
                                          )
                                        left_token: <Left_CommandSub "$(">
                                        spids: [313 320]
                                      )
                                    }
                                  spids: [312]
                                )
                              ]
                              spids: [312]
                            )
                            (AndOr
                              children: [
                                (If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (C {(test)} {(-f)} 
                                          {(DQ ($ VSub_Name "$state_dir")) (/orig-head)}
                                        )
                                      ]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:orig_head)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (CommandSubPart
                                                    command_list: 
                                                      (CommandList
                                                        children: [
                                                          (C {(cat)} 
                                                            {(DQ ($ VSub_Name "$state_dir")) 
                                                              (/orig-head)
                                                            }
                                                          )
                                                        ]
                                                      )
                                                    left_token: <Left_CommandSub "$(">
                                                    spids: [353 360]
                                                  )
                                                }
                                              spids: [352]
                                            )
                                          ]
                                          spids: [352]
                                        )
                                      ]
                                      spids: [-1 349]
                                    )
                                  ]
                                  else_action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:orig_head)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (C {(cat)} 
                                                        {(DQ ($ VSub_Name "$state_dir")) (/head)}
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_CommandSub "$(">
                                                spids: [367 374]
                                              )
                                            }
                                          spids: [366]
                                        )
                                      ]
                                      spids: [366]
                                    )
                                  ]
                                  spids: [363 377]
                                )
                                (AndOr
                                  children: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:GIT_QUIET)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (C {(cat)} 
                                                        {(DQ ($ VSub_Name "$state_dir")) (/quiet)}
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_CommandSub "$(">
                                                spids: [383 390]
                                              )
                                            }
                                          spids: [382]
                                        )
                                      ]
                                      spids: [382]
                                    )
                                    (AndOr
                                      children: [
                                        (C {(test)} {(-f)} {(DQ ($ VSub_Name "$state_dir")) (/verbose)})
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:verbose)
                                              op: Equal
                                              rhs: {(t)}
                                              spids: [406]
                                            )
                                          ]
                                          spids: [406]
                                        )
                                      ]
                                      op_id: Op_DAmp
                                    )
                                  ]
                                  op_id: Op_DAmp
                                )
                              ]
                              op_id: Op_DAmp
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
            (AndOr
              children: [
                (C {(test)} {(-f)} {(DQ ($ VSub_Name "$state_dir")) (/strategy)})
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:strategy)
                      op: Equal
                      rhs: 
                        {
                          (DQ 
                            (CommandSubPart
                              command_list: 
                                (CommandList
                                  children: [(C {(cat)} {(DQ ($ VSub_Name "$state_dir")) (/strategy)})]
                                )
                              left_token: <Left_CommandSub "$(">
                              spids: [423 430]
                            )
                          )
                        }
                      spids: [421]
                    )
                  ]
                  spids: [421]
                )
              ]
              op_id: Op_DAmp
            )
            (AndOr
              children: [
                (C {(test)} {(-f)} {(DQ ($ VSub_Name "$state_dir")) (/strategy_opts)})
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:strategy_opts)
                      op: Equal
                      rhs: 
                        {
                          (DQ 
                            (CommandSubPart
                              command_list: 
                                (CommandList
                                  children: [
                                    (C {(cat)} {(DQ ($ VSub_Name "$state_dir")) (/strategy_opts)})
                                  ]
                                )
                              left_token: <Left_CommandSub "$(">
                              spids: [448 455]
                            )
                          )
                        }
                      spids: [446]
                    )
                  ]
                  spids: [446]
                )
              ]
              op_id: Op_DAmp
            )
            (AndOr
              children: [
                (C {(test)} {(-f)} {(DQ ($ VSub_Name "$state_dir")) (/allow_rerere_autoupdate)})
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:allow_rerere_autoupdate)
                      op: Equal
                      rhs: 
                        {
                          (DQ 
                            (CommandSubPart
                              command_list: 
                                (CommandList
                                  children: [
                                    (C {(cat)} 
                                      {(DQ ($ VSub_Name "$state_dir")) (/allow_rerere_autoupdate)}
                                    )
                                  ]
                                )
                              left_token: <Left_CommandSub "$(">
                              spids: [473 480]
                            )
                          )
                        }
                      spids: [471]
                    )
                  ]
                  spids: [471]
                )
              ]
              op_id: Op_DAmp
            )
            (AndOr
              children: [
                (C {(test)} {(-f)} {(DQ ($ VSub_Name "$state_dir")) (/gpg_sign_opt)})
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:gpg_sign_opt)
                      op: Equal
                      rhs: 
                        {
                          (DQ 
                            (CommandSubPart
                              command_list: 
                                (CommandList
                                  children: [
                                    (C {(cat)} {(DQ ($ VSub_Name "$state_dir")) (/gpg_sign_opt)})
                                  ]
                                )
                              left_token: <Left_CommandSub "$(">
                              spids: [498 505]
                            )
                          )
                        }
                      spids: [496]
                    )
                  ]
                  spids: [496]
                )
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [272]
        )
      spids: [267 271]
    )
    (FuncDef
      name: write_basic_state
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (SimpleCommand
                  words: [{(echo)} {(DQ ($ VSub_Name "$head_name"))}]
                  redirects: [
                    (Redir
                      op_id: Redir_Great
                      fd: -1
                      arg_word: {(DQ ($ VSub_Name "$state_dir")) (/head-name)}
                      spids: [525]
                    )
                  ]
                )
                (AndOr
                  children: [
                    (SimpleCommand
                      words: [{(echo)} {(DQ ($ VSub_Name "$onto"))}]
                      redirects: [
                        (Redir
                          op_id: Redir_Great
                          fd: -1
                          arg_word: {(DQ ($ VSub_Name "$state_dir")) (/onto)}
                          spids: [541]
                        )
                      ]
                    )
                    (AndOr
                      children: [
                        (SimpleCommand
                          words: [{(echo)} {(DQ ($ VSub_Name "$orig_head"))}]
                          redirects: [
                            (Redir
                              op_id: Redir_Great
                              fd: -1
                              arg_word: {(DQ ($ VSub_Name "$state_dir")) (/orig-head)}
                              spids: [557]
                            )
                          ]
                        )
                        (AndOr
                          children: [
                            (SimpleCommand
                              words: [{(echo)} {(DQ ($ VSub_Name "$GIT_QUIET"))}]
                              redirects: [
                                (Redir
                                  op_id: Redir_Great
                                  fd: -1
                                  arg_word: {(DQ ($ VSub_Name "$state_dir")) (/quiet)}
                                  spids: [573]
                                )
                              ]
                            )
                            (AndOr
                              children: [
                                (C {(test)} {(t)} {(Lit_Other "=")} {(DQ ($ VSub_Name "$verbose"))})
                                (SimpleCommand
                                  words: [{(Lit_Other ":")}]
                                  redirects: [
                                    (Redir
                                      op_id: Redir_Great
                                      fd: -1
                                      arg_word: {(DQ ($ VSub_Name "$state_dir")) (/verbose)}
                                      spids: [597]
                                    )
                                  ]
                                )
                              ]
                              op_id: Op_DAmp
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
            (AndOr
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$strategy"))})
                (SimpleCommand
                  words: [{(echo)} {(DQ ($ VSub_Name "$strategy"))}]
                  redirects: [
                    (Redir
                      op_id: Redir_Great
                      fd: -1
                      arg_word: {(DQ ($ VSub_Name "$state_dir")) (/strategy)}
                      spids: [621]
                    )
                  ]
                )
              ]
              op_id: Op_DAmp
            )
            (AndOr
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$strategy_opts"))})
                (SimpleCommand
                  words: [{(echo)} {(DQ ($ VSub_Name "$strategy_opts"))}]
                  redirects: [
                    (Redir
                      op_id: Redir_Great
                      fd: -1
                      arg_word: {(DQ ($ VSub_Name "$state_dir")) (/strategy_opts)}
                      spids: [645]
                    )
                  ]
                )
              ]
              op_id: Op_DAmp
            )
            (AndOr
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$allow_rerere_autoupdate"))})
                (SimpleCommand
                  words: [{(echo)} {(DQ ($ VSub_Name "$allow_rerere_autoupdate"))}]
                  redirects: [
                    (Redir
                      op_id: Redir_Great
                      fd: -1
                      arg_word: {(DQ ($ VSub_Name "$state_dir")) (/allow_rerere_autoupdate)}
                      spids: [671]
                    )
                  ]
                )
              ]
              op_id: Op_DAmp
            )
            (AndOr
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$gpg_sign_opt"))})
                (SimpleCommand
                  words: [{(echo)} {(DQ ($ VSub_Name "$gpg_sign_opt"))}]
                  redirects: [
                    (Redir
                      op_id: Redir_Great
                      fd: -1
                      arg_word: {(DQ ($ VSub_Name "$state_dir")) (/gpg_sign_opt)}
                      spids: [697]
                    )
                  ]
                )
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [516]
        )
      spids: [511 515]
    )
    (FuncDef
      name: output
      body: 
        (BraceGroup
          children: [
            (Case
              to_match: {(DQ ($ VSub_Name "$verbose"))}
              arms: [
                (case_arm
                  pat_list: [{(SQ )}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:output)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (SimpleCommand
                                        words: [{(DQ ($ VSub_At "$@"))}]
                                        redirects: [
                                          (Redir
                                            op_id: Redir_GreatAnd
                                            fd: 2
                                            arg_word: {(1)}
                                            spids: [735]
                                          )
                                        ]
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [730 738]
                              )
                            }
                          spids: [729]
                        )
                      ]
                      spids: [729]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:status)
                          op: Equal
                          rhs: {($ VSub_QMark "$?")}
                          spids: [741]
                        )
                      ]
                      spids: [741]
                    )
                    (AndOr
                      children: [
                        (C {(test)} {($ VSub_Name "$status")} {(KW_Bang "!") (Lit_Other "=")} {(0)})
                        (C {(printf)} {(DQ ("%s") (EscapedLiteralPart token:<Lit_EscapedChar "\\n">))} 
                          {(DQ ($ VSub_Name "$output"))}
                        )
                      ]
                      op_id: Op_DAmp
                    )
                    (ControlFlow
                      token: <ControlFlow_Return return>
                      arg_word: {($ VSub_Name "$status")}
                    )
                  ]
                  spids: [-1 726 773 -1]
                )
                (case_arm
                  pat_list: [{(Lit_Other "*")}]
                  action: [(C {(DQ ($ VSub_At "$@"))})]
                  spids: [776 777 785 -1]
                )
              ]
              spids: [715 721 788]
            )
          ]
          spids: [712]
        )
      spids: [707 711]
    )
    (FuncDef
      name: move_to_original_branch
      body: 
        (BraceGroup
          children: [
            (Case
              to_match: {(DQ ($ VSub_Name "$head_name"))}
              arms: [
                (case_arm
                  pat_list: [{(refs/) (Lit_Other "*")}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:message)
                          op: Equal
                          rhs: 
                            {
                              (DQ ("rebase finished: ") ($ VSub_Name "$head_name") (" onto ") 
                                ($ VSub_Name "$onto")
                              )
                            }
                          spids: [815]
                        )
                      ]
                      spids: [815]
                    )
                    (AndOr
                      children: [
                        (C {(git)} {(update-ref)} {(-m)} {(DQ ($ VSub_Name "$message"))} 
                          {($ VSub_Name "$head_name")} 
                          {
                            (CommandSubPart
                              command_list: 
                                (CommandList
                                  children: [(C {(git)} {(rev-parse)} {(HEAD)})]
                                )
                              left_token: <Left_CommandSub "$(">
                              spids: [838 844]
                            )
                          } {($ VSub_Name "$orig_head")}
                        )
                        (AndOr
                          children: [
                            (C {(git)} {(symbolic-ref)} {(-m)} 
                              {(DQ ("rebase finished: returning to ") ($ VSub_Name "$head_name"))} {(HEAD)} {($ VSub_Name "$head_name")}
                            )
                            (C {(die)} 
                              {
                                (DQ 
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(eval_gettext)} 
                                            {
                                              (DQ ("Could not move back to ") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\$">
                                                ) (head_name)
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [876 884]
                                  )
                                )
                              }
                            )
                          ]
                          op_id: Op_DPipe
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  spids: [810 812 888 -1]
                )
              ]
              spids: [801 807 891]
            )
          ]
          spids: [798]
        )
      spids: [793 797]
    )
    (FuncDef
      name: apply_autostash
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-f)} {(DQ ($ VSub_Name "$state_dir") (/autostash))})]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:stash_sha1)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(cat)} {(DQ ($ VSub_Name "$state_dir") (/autostash))})
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [920 927]
                              )
                            }
                          spids: [919]
                        )
                      ]
                      spids: [919]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (SimpleCommand
                              words: [{(git)} {(stash)} {(apply)} {($ VSub_Name "$stash_sha1")}]
                              redirects: [
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: 2
                                  arg_word: {(1)}
                                  spids: [940]
                                )
                                (Redir
                                  op_id: Redir_Great
                                  fd: -1
                                  arg_word: {(/dev/null)}
                                  spids: [943]
                                )
                              ]
                            )
                          ]
                          action: [
                            (C {(echo)} 
                              {
                                (DQ 
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [(C {(gettext)} {(SQ <"Applied autostash.">)})]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [953 959]
                                  )
                                )
                              }
                            )
                          ]
                          spids: [-1 947]
                        )
                      ]
                      else_action: [
                        (AndOr
                          children: [
                            (C {(git)} {(stash)} {(store)} {(-m)} {(DQ (autostash))} {(-q)} 
                              {($ VSub_Name "$stash_sha1")}
                            )
                            (C {(die)} 
                              {
                                (DQ 
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(eval_gettext)} 
                                            {
                                              (DQ ("Cannot store ") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\$">
                                                ) (stash_sha1)
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [988 996]
                                  )
                                )
                              }
                            )
                          ]
                          op_id: Op_DPipe
                        )
                        (C {(gettext)} 
                          {
                            (SQ <"Applying autostash resulted in conflicts.\n"> 
                              <"Your changes are safe in the stash.\n"> <"You can run \"git stash pop\" or \"git stash drop\" at any time.\n">
                            )
                          }
                        )
                      ]
                      spids: [963 1009]
                    )
                  ]
                  spids: [-1 916]
                )
              ]
              spids: [-1 1012]
            )
          ]
          spids: [901]
        )
      spids: [896 900]
    )
    (FuncDef
      name: finish_rebase
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(apply_autostash)})
                (AndOr
                  children: [
                    (BraceGroup
                      children: [
                        (Sentence
                          child: 
                            (AndOr
                              children: [(C {(git)} {(gc)} {(--auto)}) (C {(true)})]
                              op_id: Op_DPipe
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      spids: [1030]
                    )
                    (C {(rm)} {(-rf)} {(DQ ($ VSub_Name "$state_dir"))})
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [1022]
        )
      spids: [1017 1021]
    )
    (FuncDef
      name: run_specific_rebase
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(DQ ($ VSub_Name "$interactive_rebase"))} 
                          {(Lit_Other "=")} {(implied)} {(Lit_Other "]")}
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:GIT_EDITOR)
                          op: Equal
                          rhs: {(Lit_Other ":")}
                          spids: [1085]
                        )
                      ]
                      spids: [1085]
                    )
                    (C {(export)} {(GIT_EDITOR)})
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:autosquash)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [1094]
                        )
                      ]
                      spids: [1094]
                    )
                  ]
                  spids: [-1 1082]
                )
              ]
              spids: [-1 1097]
            )
            (C {(.)} {(git-rebase--) ($ VSub_Name "$type")})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:ret)
                  op: Equal
                  rhs: {($ VSub_QMark "$?")}
                  spids: [1106]
                )
              ]
              spids: [1106]
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {($ VSub_Name "$ret")} {(-eq)} {(0)})]
                  action: [(C {(finish_rebase)})]
                  spids: [-1 1121]
                )
                (if_arm
                  cond: [(C {(test)} {($ VSub_Name "$ret")} {(-eq)} {(2)})]
                  action: [
                    (AndOr
                      children: [
                        (C {(apply_autostash)})
                        (AndOr
                          children: [
                            (C {(rm)} {(-rf)} {(DQ ($ VSub_Name "$state_dir"))})
                            (C {(die)} {(DQ ("Nothing to do"))})
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  spids: [1127 1141]
                )
              ]
              spids: [-1 1167]
            )
            (C {(exit)} {($ VSub_Name "$ret")})
          ]
          spids: [1064]
        )
      spids: [1059 1063]
    )
    (FuncDef
      name: run_pre_rebase_hook
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (AndOr
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_Name "$ok_to_skip_pre_rebase"))})
                        (C {(test)} {(-x)} 
                          {
                            (DQ 
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(git)} {(rev-parse)} {(--git-path)} {(hooks/pre-rebase)})
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [1203 1211]
                              )
                            )
                          }
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  action: [
                    (AndOr
                      children: [
                        (C 
                          {
                            (DQ 
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(git)} {(rev-parse)} {(--git-path)} {(hooks/pre-rebase)})
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [1219 1227]
                              )
                            )
                          } 
                          {
                            (BracedVarSub
                              token: <VSub_Number 1>
                              suffix_op: (StringUnary op_id:VTest_Plus arg_word:{(DQ ($ VSub_At "$@"))})
                              spids: [1230 1236]
                            )
                          }
                        )
                        (C {(die)} 
                          {
                            (DQ 
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(gettext)} {(DQ ("The pre-rebase hook refused to rebase."))})
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [1244 1250]
                              )
                            )
                          }
                        )
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  spids: [-1 1215]
                )
              ]
              spids: [-1 1254]
            )
          ]
          spids: [1182]
        )
      spids: [1177 1181]
    )
    (AndOr
      children: [
        (C {(test)} {(-f)} {(DQ ($ VSub_Name "$apply_dir")) (/applying)})
        (C {(die)} 
          {
            (DQ 
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (C {(gettext)} {(DQ ("It looks like git-am is in progress. Cannot rebase."))})
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [1274 1280]
              )
            )
          }
        )
      ]
      op_id: Op_DAmp
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-d)} {(DQ ($ VSub_Name "$apply_dir"))})]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:type) op:Equal rhs:{(am)} spids:[1297])]
              spids: [1297]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:state_dir)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$apply_dir"))}
                  spids: [1301]
                )
              ]
              spids: [1301]
            )
          ]
          spids: [-1 1294]
        )
        (if_arm
          cond: [(C {(test)} {(-d)} {(DQ ($ VSub_Name "$merge_dir"))})]
          action: [
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-f)} {(DQ ($ VSub_Name "$merge_dir")) (/interactive)})]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:type)
                          op: Equal
                          rhs: {(interactive)}
                          spids: [1334]
                        )
                      ]
                      spids: [1334]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:interactive_rebase)
                          op: Equal
                          rhs: {(explicit)}
                          spids: [1338]
                        )
                      ]
                      spids: [1338]
                    )
                  ]
                  spids: [-1 1331]
                )
              ]
              else_action: [
                (Assignment
                  keyword: Assign_None
                  pairs: [(assign_pair lhs:(LhsName name:type) op:Equal rhs:{(merge)} spids:[1345])]
                  spids: [1345]
                )
              ]
              spids: [1342 1349]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:state_dir)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$merge_dir"))}
                  spids: [1352]
                )
              ]
              spids: [1352]
            )
          ]
          spids: [1306 1316]
        )
      ]
      spids: [-1 1357]
    )
    (AndOr
      children: [
        (C {(test)} {(-n)} {(DQ ($ VSub_Name "$type"))})
        (Assignment
          keyword: Assign_None
          pairs: [(assign_pair lhs:(LhsName name:in_progress) op:Equal rhs:{(t)} spids:[1369])]
          spids: [1369]
        )
      ]
      op_id: Op_DAmp
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:total_argc)
          op: Equal
          rhs: {($ VSub_Pound "$#")}
          spids: [1373]
        )
      ]
      spids: [1373]
    )
    (While
      cond: [(C {(test)} {($ VSub_Pound "$#")} {(KW_Bang "!") (Lit_Other "=")} {(0)})]
      body: 
        (DoGroup
          children: [
            (Case
              to_match: {(DQ ($ VSub_Number "$1"))}
              arms: [
                (case_arm
                  pat_list: [{(--no-verify)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:ok_to_skip_pre_rebase)
                          op: Equal
                          rhs: {(yes)}
                          spids: [1403]
                        )
                      ]
                      spids: [1403]
                    )
                  ]
                  spids: [1399 1400 1407 -1]
                )
                (case_arm
                  pat_list: [{(--verify)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:ok_to_skip_pre_rebase)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [1414]
                        )
                      ]
                      spids: [1414]
                    )
                  ]
                  spids: [1410 1411 1417 -1]
                )
                (case_arm
                  pat_list: [{(--continue)} {(--skip)} {(--abort)} {(--edit-todo)}]
                  action: [
                    (AndOr
                      children: [(C {(test)} {($ VSub_Name "$total_argc")} {(-eq)} {(2)}) (C {(usage)})]
                      op_id: Op_DPipe
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:action)
                          op: Equal
                          rhs: 
                            {
                              (BracedVarSub
                                token: <VSub_Number 1>
                                suffix_op: (StringUnary op_id:VOp1_DPound arg_word:{(--)})
                                spids: [1444 1448]
                              )
                            }
                          spids: [1443]
                        )
                      ]
                      spids: [1443]
                    )
                  ]
                  spids: [1420 1427 1451 -1]
                )
                (case_arm
                  pat_list: [{(--onto) (Lit_Other "=") (Lit_Other "*")}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:onto)
                          op: Equal
                          rhs: 
                            {
                              (DQ 
                                (BracedVarSub
                                  token: <VSub_Number 1>
                                  suffix_op: (StringUnary op_id:VOp1_Pound arg_word:{("--onto=")})
                                  spids: [1462 1466]
                                )
                              )
                            }
                          spids: [1460]
                        )
                      ]
                      spids: [1460]
                    )
                  ]
                  spids: [1454 1457 1470 -1]
                )
                (case_arm
                  pat_list: [{(--exec) (Lit_Other "=") (Lit_Other "*")}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:cmd)
                          op: Equal
                          rhs: 
                            {
                              (DQ (${ VSub_Name cmd) ("exec ") 
                                (BracedVarSub
                                  token: <VSub_Number 1>
                                  suffix_op: (StringUnary op_id:VOp1_Pound arg_word:{("--exec=")})
                                  spids: [1485 1489]
                                ) (${ VSub_Name LF)
                              )
                            }
                          spids: [1479]
                        )
                      ]
                      spids: [1479]
                    )
                    (AndOr
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_Name "$interactive_rebase"))})
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:interactive_rebase)
                              op: Equal
                              rhs: {(implied)}
                              spids: [1506]
                            )
                          ]
                          spids: [1506]
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  spids: [1473 1476 1510 -1]
                )
                (case_arm
                  pat_list: [{(--interactive)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:interactive_rebase)
                          op: Equal
                          rhs: {(explicit)}
                          spids: [1517]
                        )
                      ]
                      spids: [1517]
                    )
                  ]
                  spids: [1513 1514 1521 -1]
                )
                (case_arm
                  pat_list: [{(--keep-empty)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:keep_empty)
                          op: Equal
                          rhs: {(yes)}
                          spids: [1528]
                        )
                      ]
                      spids: [1528]
                    )
                  ]
                  spids: [1524 1525 1532 -1]
                )
                (case_arm
                  pat_list: [{(--preserve-merges)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:preserve_merges)
                          op: Equal
                          rhs: {(t)}
                          spids: [1539]
                        )
                      ]
                      spids: [1539]
                    )
                    (AndOr
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_Name "$interactive_rebase"))})
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:interactive_rebase)
                              op: Equal
                              rhs: {(implied)}
                              spids: [1553]
                            )
                          ]
                          spids: [1553]
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  spids: [1535 1536 1557 -1]
                )
                (case_arm
                  pat_list: [{(--autosquash)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:autosquash)
                          op: Equal
                          rhs: {(t)}
                          spids: [1564]
                        )
                      ]
                      spids: [1564]
                    )
                  ]
                  spids: [1560 1561 1568 -1]
                )
                (case_arm
                  pat_list: [{(--no-autosquash)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:autosquash)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [1575]
                        )
                      ]
                      spids: [1575]
                    )
                  ]
                  spids: [1571 1572 1578 -1]
                )
                (case_arm
                  pat_list: [{(--fork-point)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:fork_point)
                          op: Equal
                          rhs: {(t)}
                          spids: [1585]
                        )
                      ]
                      spids: [1585]
                    )
                  ]
                  spids: [1581 1582 1589 -1]
                )
                (case_arm
                  pat_list: [{(--no-fork-point)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:fork_point)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [1596]
                        )
                      ]
                      spids: [1596]
                    )
                  ]
                  spids: [1592 1593 1599 -1]
                )
                (case_arm
                  pat_list: [{(--merge)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:do_merge)
                          op: Equal
                          rhs: {(t)}
                          spids: [1606]
                        )
                      ]
                      spids: [1606]
                    )
                  ]
                  spids: [1602 1603 1610 -1]
                )
                (case_arm
                  pat_list: [{(--strategy-option) (Lit_Other "=") (Lit_Other "*")}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:strategy_opts)
                          op: Equal
                          rhs: 
                            {
                              (DQ ($ VSub_Name "$strategy_opts") (" ") 
                                (CommandSubPart
                                  command_list: 
                                    (CommandList
                                      children: [
                                        (C {(git)} {(rev-parse)} {(--sq-quote)} 
                                          {
                                            (DQ (--) 
                                              (BracedVarSub
                                                token: <VSub_Number 1>
                                                suffix_op: 
                                                  (StringUnary
                                                    op_id: VOp1_Pound
                                                    arg_word: {("--strategy-option=")}
                                                  )
                                                spids: [1632 1636]
                                              )
                                            )
                                          }
                                        )
                                      ]
                                    )
                                  left_token: <Left_CommandSub "$(">
                                  spids: [1623 1638]
                                )
                              )
                            }
                          spids: [1619]
                        )
                      ]
                      spids: [1619]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:do_merge)
                          op: Equal
                          rhs: {(t)}
                          spids: [1642]
                        )
                      ]
                      spids: [1642]
                    )
                    (AndOr
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_Name "$strategy"))})
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:strategy)
                              op: Equal
                              rhs: {(recursive)}
                              spids: [1656]
                            )
                          ]
                          spids: [1656]
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  spids: [1613 1616 1660 -1]
                )
                (case_arm
                  pat_list: [{(--strategy) (Lit_Other "=") (Lit_Other "*")}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:strategy)
                          op: Equal
                          rhs: 
                            {
                              (DQ 
                                (BracedVarSub
                                  token: <VSub_Number 1>
                                  suffix_op: (StringUnary op_id:VOp1_Pound arg_word:{("--strategy=")})
                                  spids: [1671 1675]
                                )
                              )
                            }
                          spids: [1669]
                        )
                      ]
                      spids: [1669]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:do_merge)
                          op: Equal
                          rhs: {(t)}
                          spids: [1679]
                        )
                      ]
                      spids: [1679]
                    )
                  ]
                  spids: [1663 1666 1683 -1]
                )
                (case_arm
                  pat_list: [{(--no-stat)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:diffstat)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [1690]
                        )
                      ]
                      spids: [1690]
                    )
                  ]
                  spids: [1686 1687 1693 -1]
                )
                (case_arm
                  pat_list: [{(--stat)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:diffstat)
                          op: Equal
                          rhs: {(t)}
                          spids: [1700]
                        )
                      ]
                      spids: [1700]
                    )
                  ]
                  spids: [1696 1697 1704 -1]
                )
                (case_arm
                  pat_list: [{(--autostash)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:autostash)
                          op: Equal
                          rhs: {(true)}
                          spids: [1711]
                        )
                      ]
                      spids: [1711]
                    )
                  ]
                  spids: [1707 1708 1715 -1]
                )
                (case_arm
                  pat_list: [{(--no-autostash)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:autostash)
                          op: Equal
                          rhs: {(false)}
                          spids: [1722]
                        )
                      ]
                      spids: [1722]
                    )
                  ]
                  spids: [1718 1719 1726 -1]
                )
                (case_arm
                  pat_list: [{(--verbose)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:verbose)
                          op: Equal
                          rhs: {(t)}
                          spids: [1733]
                        )
                      ]
                      spids: [1733]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:diffstat)
                          op: Equal
                          rhs: {(t)}
                          spids: [1737]
                        )
                      ]
                      spids: [1737]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:GIT_QUIET)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [1741]
                        )
                      ]
                      spids: [1741]
                    )
                  ]
                  spids: [1729 1730 1744 -1]
                )
                (case_arm
                  pat_list: [{(--quiet)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:GIT_QUIET)
                          op: Equal
                          rhs: {(t)}
                          spids: [1751]
                        )
                      ]
                      spids: [1751]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:git_am_opt)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$git_am_opt") (" -q"))}
                          spids: [1755]
                        )
                      ]
                      spids: [1755]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:verbose)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [1762]
                        )
                      ]
                      spids: [1762]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:diffstat)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [1765]
                        )
                      ]
                      spids: [1765]
                    )
                  ]
                  spids: [1747 1748 1768 -1]
                )
                (case_arm
                  pat_list: [{(--whitespace) (Lit_Other "=") (Lit_Other "*")}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:git_am_opt)
                          op: Equal
                          rhs: 
                            {
                              (DQ ($ VSub_Name "$git_am_opt") (" --whitespace=") 
                                (BracedVarSub
                                  token: <VSub_Number 1>
                                  suffix_op: 
                                    (StringUnary
                                      op_id: VOp1_Pound
                                      arg_word: {("--whitespace=")}
                                    )
                                  spids: [1781 1785]
                                )
                              )
                            }
                          spids: [1777]
                        )
                      ]
                      spids: [1777]
                    )
                    (Case
                      to_match: 
                        {
                          (DQ 
                            (BracedVarSub
                              token: <VSub_Number 1>
                              suffix_op: (StringUnary op_id:VOp1_Pound arg_word:{("--whitespace=")})
                              spids: [1792 1796]
                            )
                          )
                        }
                      arms: [
                        (case_arm
                          pat_list: [{(fix)} {(strip)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:force_rebase)
                                  op: Equal
                                  rhs: {(t)}
                                  spids: [1808]
                                )
                              ]
                              spids: [1808]
                            )
                          ]
                          spids: [1802 1805 1812 -1]
                        )
                      ]
                      spids: [1789 1799 1815]
                    )
                  ]
                  spids: [1771 1774 1818 -1]
                )
                (case_arm
                  pat_list: [{(--ignore-whitespace)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:git_am_opt)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$git_am_opt") (" ") ($ VSub_Number "$1"))}
                          spids: [1825]
                        )
                      ]
                      spids: [1825]
                    )
                  ]
                  spids: [1821 1822 1833 -1]
                )
                (case_arm
                  pat_list: [{(--committer-date-is-author-date)} {(--ignore-date)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:git_am_opt)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$git_am_opt") (" ") ($ VSub_Number "$1"))}
                          spids: [1842]
                        )
                      ]
                      spids: [1842]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:force_rebase)
                          op: Equal
                          rhs: {(t)}
                          spids: [1850]
                        )
                      ]
                      spids: [1850]
                    )
                  ]
                  spids: [1836 1839 1854 -1]
                )
                (case_arm
                  pat_list: [{(-C) (Lit_Other "*")}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:git_am_opt)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$git_am_opt") (" ") ($ VSub_Number "$1"))}
                          spids: [1862]
                        )
                      ]
                      spids: [1862]
                    )
                  ]
                  spids: [1857 1859 1870 -1]
                )
                (case_arm
                  pat_list: [{(--root)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:rebase_root)
                          op: Equal
                          rhs: {(t)}
                          spids: [1877]
                        )
                      ]
                      spids: [1877]
                    )
                  ]
                  spids: [1873 1874 1881 -1]
                )
                (case_arm
                  pat_list: [{(--force-rebase)} {(--no-ff)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:force_rebase)
                          op: Equal
                          rhs: {(t)}
                          spids: [1890]
                        )
                      ]
                      spids: [1890]
                    )
                  ]
                  spids: [1884 1887 1894 -1]
                )
                (case_arm
                  pat_list: [{(--rerere-autoupdate)} {(--no-rerere-autoupdate)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:allow_rerere_autoupdate)
                          op: Equal
                          rhs: {(DQ ($ VSub_Number "$1"))}
                          spids: [1903]
                        )
                      ]
                      spids: [1903]
                    )
                  ]
                  spids: [1897 1900 1909 -1]
                )
                (case_arm
                  pat_list: [{(--gpg-sign)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:gpg_sign_opt)
                          op: Equal
                          rhs: {(-S)}
                          spids: [1916]
                        )
                      ]
                      spids: [1916]
                    )
                  ]
                  spids: [1912 1913 1920 -1]
                )
                (case_arm
                  pat_list: [{(--gpg-sign) (Lit_Other "=") (Lit_Other "*")}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:gpg_sign_opt)
                          op: Equal
                          rhs: 
                            {
                              (DQ (-S) 
                                (BracedVarSub
                                  token: <VSub_Number 1>
                                  suffix_op: (StringUnary op_id:VOp1_Pound arg_word:{("--gpg-sign=")})
                                  spids: [1932 1936]
                                )
                              )
                            }
                          spids: [1929]
                        )
                      ]
                      spids: [1929]
                    )
                  ]
                  spids: [1923 1926 1940 -1]
                )
                (case_arm
                  pat_list: [{(--)}]
                  action: [(C {(shift)}) (ControlFlow token:<ControlFlow_Break break>)]
                  spids: [1943 1944 1953 -1]
                )
              ]
              spids: [1390 1396 1956]
            )
            (C {(shift)})
          ]
          spids: [1387 1961]
        )
    )
    (AndOr
      children: [(C {(test)} {($ VSub_Pound "$#")} {(-gt)} {(2)}) (C {(usage)})]
      op_id: Op_DAmp
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name "$action"))})]
          action: [
            (AndOr
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_Name "$in_progress"))})
                (C {(die)} 
                  {
                    (DQ 
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [(C {(gettext)} {(DQ ("No rebase in progress?"))})]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [2002 2008]
                      )
                    )
                  }
                )
              ]
              op_id: Op_DAmp
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (AndOr
                      children: [
                        (C {(test)} {(DQ ($ VSub_Name "$type"))} {(Lit_Other "=")} {(interactive)})
                        (C {(test)} {(DQ ($ VSub_Name "$GIT_REFLOG_ACTION"))} {(Lit_Other "=")} 
                          {(rebase)}
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:GIT_REFLOG_ACTION)
                          op: Equal
                          rhs: {(DQ ("rebase -i (") ($ VSub_Name "$action") (")"))}
                          spids: [2044]
                        )
                      ]
                      spids: [2044]
                    )
                    (C {(export)} {(GIT_REFLOG_ACTION)})
                  ]
                  spids: [-1 2041]
                )
              ]
              spids: [-1 2057]
            )
          ]
          spids: [-1 1986]
        )
      ]
      spids: [-1 2059]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (AndOr
              children: [
                (C {(test)} {(DQ ($ VSub_Name "$action"))} {(Lit_Other "=")} {(DQ (edit-todo))})
                (C {(test)} {(DQ ($ VSub_Name "$type"))} {(KW_Bang "!") (Lit_Other "=")} 
                  {(DQ (interactive))}
                )
              ]
              op_id: Op_DAmp
            )
          ]
          action: [
            (C {(die)} 
              {
                (DQ 
                  (CommandSubPart
                    command_list: 
                      (CommandList
                        children: [
                          (C {(gettext)} 
                            {
                              (DQ 
                                (
"The --edit-todo action can only be used during interactive rebase."
                                )
                              )
                            }
                          )
                        ]
                      )
                    left_token: <Left_CommandSub "$(">
                    spids: [2097 2103]
                  )
                )
              }
            )
          ]
          spids: [-1 2091]
        )
      ]
      spids: [-1 2106]
    )
    (Case
      to_match: {(DQ ($ VSub_Name "$action"))}
      arms: [
        (case_arm
          pat_list: [{(ControlFlow_Continue continue)}]
          action: [
            (AndOr
              children: [
                (SimpleCommand
                  words: [{(git)} {(rev-parse)} {(--verify)} {(HEAD)}]
                  redirects: [(Redir op_id:Redir_Great fd:-1 arg_word:{(/dev/null)} spids:[2133])]
                )
                (C {(die)} 
                  {
                    (DQ 
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [(C {(gettext)} {(DQ ("Cannot read HEAD"))})]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [2142 2148]
                      )
                    )
                  }
                )
              ]
              op_id: Op_DPipe
            )
            (AndOr
              children: [
                (C {(git)} {(update-index)} {(--ignore-submodules)} {(--refresh)})
                (AndOr
                  children: [
                    (C {(git)} {(diff-files)} {(--quiet)} {(--ignore-submodules)})
                    (BraceGroup
                      children: [
                        (C {(echo)} 
                          {
                            (DQ 
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(gettext)} 
                                        {
                                          (DQ ("You must edit all merge conflicts and then\n") 
                                            ("mark them as resolved using git add")
                                          )
                                        }
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [2179 2186]
                              )
                            )
                          }
                        )
                        (C {(exit)} {(1)})
                      ]
                      spids: [2173]
                    )
                  ]
                  op_id: Op_DPipe
                )
              ]
              op_id: Op_DAmp
            )
            (C {(read_basic_state)})
            (C {(run_specific_rebase)})
          ]
          spids: [2117 2118 2204 -1]
        )
        (case_arm
          pat_list: [{(skip)}]
          action: [
            (AndOr
              children: [
                (C {(output)} {(git)} {(reset)} {(--hard)} {(HEAD)})
                (C {(exit)} {($ VSub_QMark "$?")})
              ]
              op_id: Op_DPipe
            )
            (C {(read_basic_state)})
            (C {(run_specific_rebase)})
          ]
          spids: [2206 2207 2233 -1]
        )
        (case_arm
          pat_list: [{(abort)}]
          action: [
            (C {(git)} {(rerere)} {(clear)})
            (C {(read_basic_state)})
            (Case
              to_match: {(DQ ($ VSub_Name "$head_name"))}
              arms: [
                (case_arm
                  pat_list: [{(refs/) (Lit_Other "*")}]
                  action: [
                    (AndOr
                      children: [
                        (C {(git)} {(symbolic-ref)} {(-m)} {(DQ ("rebase: aborting"))} {(HEAD)} 
                          {($ VSub_Name "$head_name")}
                        )
                        (C {(die)} 
                          {
                            (DQ 
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(eval_gettext)} 
                                        {
                                          (DQ ("Could not move back to ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\$">
                                            ) (head_name)
                                          )
                                        }
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [2283 2291]
                              )
                            )
                          }
                        )
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  spids: [2258 2260 2295 -1]
                )
              ]
              spids: [2249 2255 2298]
            )
            (C {(output)} {(git)} {(reset)} {(--hard)} {($ VSub_Name "$orig_head")})
            (C {(finish_rebase)})
            (C {(exit)})
          ]
          spids: [2235 2236 2318 -1]
        )
        (case_arm
          pat_list: [{(edit-todo)}]
          action: [(C {(run_specific_rebase)})]
          spids: [2320 2321 2327 -1]
        )
      ]
      spids: [2109 2115 2329]
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name "$in_progress"))})]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:state_dir_base)
                  op: Equal
                  rhs: 
                    {
                      (BracedVarSub
                        token: <VSub_Name state_dir>
                        suffix_op: (StringUnary op_id:VOp1_DPound arg_word:{("*") (Lit_Slash /)})
                        spids: [2349 2354]
                      )
                    }
                  spids: [2348]
                )
              ]
              spids: [2348]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:cmd_live_rebase)
                  op: Equal
                  rhs: {(DQ ("git rebase (--continue | --abort | --skip)"))}
                  spids: [2357]
                )
              ]
              spids: [2357]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:cmd_clear_stale_rebase)
                  op: Equal
                  rhs: 
                    {
                      (DQ ("rm -fr ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) 
                        ($ VSub_Name "$state_dir") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">)
                      )
                    }
                  spids: [2363]
                )
              ]
              spids: [2363]
            )
            (C {(die)} 
              {
                (DQ ("\n") 
                  (CommandSubPart
                    command_list: 
                      (CommandList
                        children: [
                          (C {(eval_gettext)} 
                            {
                              (SQ 
                                <
"It seems that there is already a $state_dir_base directory, and\n"
                                > <"I wonder if you are in the middle of another rebase.  If that is the\n"> <"case, please try\n"> 
                                <"\t$cmd_live_rebase\n"> <"If that is not the case, please\n"> <"\t$cmd_clear_stale_rebase\n"> 
                                <
"and run me again.  I am stopping in case you still have something\n"
                                > <"valuable there.">
                              )
                            }
                          )
                        ]
                      )
                    left_token: <Left_CommandSub "$(">
                    spids: [2376 2389]
                  )
                )
              }
            )
          ]
          spids: [-1 2345]
        )
      ]
      spids: [-1 2392]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (AndOr
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$rebase_root"))})
                (C {(test)} {(-z)} {(DQ ($ VSub_Name "$onto"))})
              ]
              op_id: Op_DAmp
            )
          ]
          action: [
            (AndOr
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_Name "$interactive_rebase"))})
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:interactive_rebase)
                      op: Equal
                      rhs: {(implied)}
                      spids: [2428]
                    )
                  ]
                  spids: [2428]
                )
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [-1 2415]
        )
      ]
      spids: [-1 2431]
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name "$interactive_rebase"))})]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:type) op:Equal rhs:{(interactive)} spids:[2447])]
              spids: [2447]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:state_dir)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$merge_dir"))}
                  spids: [2451]
                )
              ]
              spids: [2451]
            )
          ]
          spids: [-1 2444]
        )
        (if_arm
          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name "$do_merge"))})]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:type) op:Equal rhs:{(merge)} spids:[2469])]
              spids: [2469]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:state_dir)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$merge_dir"))}
                  spids: [2473]
                )
              ]
              spids: [2473]
            )
          ]
          spids: [2456 2466]
        )
      ]
      else_action: [
        (Assignment
          keyword: Assign_None
          pairs: [(assign_pair lhs:(LhsName name:type) op:Equal rhs:{(am)} spids:[2481])]
          spids: [2481]
        )
        (Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (LhsName name:state_dir)
              op: Equal
              rhs: {(DQ ($ VSub_Name "$apply_dir"))}
              spids: [2485]
            )
          ]
          spids: [2485]
        )
      ]
      spids: [2478 2490]
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$rebase_root"))})]
          action: [
            (Case
              to_match: {(DQ ($ VSub_Pound "$#"))}
              arms: [
                (case_arm
                  pat_list: [{(0)}]
                  action: [
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Pipeline
                              children: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:upstream_name)
                                      op: Equal
                                      rhs: 
                                        {
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (SimpleCommand
                                                    words: [
                                                      {(git)}
                                                      {(rev-parse)}
                                                      {(--symbolic-full-name)}
                                                      {(--verify)}
                                                      {(-q)}
                                                      {(Lit_Other "@") (Lit_LBrace "{") (upstream) 
                                                        (Lit_RBrace "}")
                                                      }
                                                    ]
                                                    redirects: [
                                                      (Redir
                                                        op_id: Redir_Great
                                                        fd: 2
                                                        arg_word: {(/dev/null)}
                                                        spids: [2542]
                                                      )
                                                    ]
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub "$(">
                                            spids: [2524 2544]
                                          )
                                        }
                                      spids: [2523]
                                    )
                                  ]
                                  spids: [2523]
                                )
                              ]
                              negated: True
                            )
                          ]
                          action: [
                            (C {(.)} {(git-parse-remote)})
                            (C {(error_on_missing_default_upstream)} {(DQ (rebase))} {(DQ (rebase))} 
                              {(DQ (against))} 
                              {
                                (DQ ("git rebase ") 
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [(C {(gettext)} {(SQ <"<branch>">)})]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [2573 2579]
                                  )
                                )
                              }
                            )
                          ]
                          spids: [-1 2547]
                        )
                      ]
                      spids: [-1 2583]
                    )
                    (AndOr
                      children: [
                        (C {(test)} {(DQ ($ VSub_Name "$fork_point"))} {(Lit_Other "=")} {(auto)})
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:fork_point)
                              op: Equal
                              rhs: {(t)}
                              spids: [2599]
                            )
                          ]
                          spids: [2599]
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  spids: [2515 2516 2603 -1]
                )
                (case_arm
                  pat_list: [{(Lit_Other "*")}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:upstream_name)
                          op: Equal
                          rhs: {(DQ ($ VSub_Number "$1"))}
                          spids: [2609]
                        )
                      ]
                      spids: [2609]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (C {(test)} {(DQ ($ VSub_Name "$upstream_name"))} {(Lit_Other "=")} {(DQ (-))})
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:upstream_name)
                                  op: Equal
                                  rhs: {(DQ ("@{-1}"))}
                                  spids: [2633]
                                )
                              ]
                              spids: [2633]
                            )
                          ]
                          spids: [-1 2630]
                        )
                      ]
                      spids: [-1 2639]
                    )
                    (C {(shift)})
                  ]
                  spids: [2606 2607 2645 -1]
                )
              ]
              spids: [2506 2512 2648]
            )
            (AndOr
              children: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:upstream)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [(C {(peel_committish)} {(DQ (${ VSub_Name upstream_name))})]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [2652 2660]
                          )
                        }
                      spids: [2651]
                    )
                  ]
                  spids: [2651]
                )
                (C {(die)} 
                  {
                    (DQ 
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(eval_gettext)} 
                                {
                                  (DQ ("invalid upstream ") 
                                    (EscapedLiteralPart
                                      token: <Lit_EscapedChar "\\$">
                                    ) (upstream_name)
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [2668 2676]
                      )
                    )
                  }
                )
              ]
              op_id: Op_DPipe
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:upstream_arg)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$upstream_name"))}
                  spids: [2680]
                )
              ]
              spids: [2680]
            )
          ]
          spids: [-1 2503]
        )
      ]
      else_action: [
        (If
          arms: [
            (if_arm
              cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$onto"))})]
              action: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:empty_tree)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [(C {(git)} {(hash-object)} {(-t)} {(tree)} {(/dev/null)})]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [2703 2713]
                          )
                        }
                      spids: [2702]
                    )
                  ]
                  spids: [2702]
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:onto)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (SimpleCommand
                                    words: [{(git)} {(commit-tree)} {($ VSub_Name "$empty_tree")}]
                                    redirects: [
                                      (Redir
                                        op_id: Redir_Less
                                        fd: -1
                                        arg_word: {(/dev/null)}
                                        spids: [2724]
                                      )
                                    ]
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [2717 2726]
                          )
                        }
                      spids: [2716]
                    )
                  ]
                  spids: [2716]
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:squash_onto)
                      op: Equal
                      rhs: {(DQ ($ VSub_Name "$onto"))}
                      spids: [2729]
                    )
                  ]
                  spids: [2729]
                )
              ]
              spids: [-1 2699]
            )
          ]
          spids: [-1 2735]
        )
        (C {(unset)} {(upstream_name)})
        (C {(unset)} {(upstream)})
        (AndOr
          children: [(C {(test)} {($ VSub_Pound "$#")} {(-gt)} {(1)}) (C {(usage)})]
          op_id: Op_DAmp
        )
        (Assignment
          keyword: Assign_None
          pairs: [(assign_pair lhs:(LhsName name:upstream_arg) op:Equal rhs:{(--root)} spids:[2761])]
          spids: [2761]
        )
      ]
      spids: [2685 2764]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:onto_name)
          op: Equal
          rhs: 
            {
              (BracedVarSub
                token: <VSub_Name onto>
                suffix_op: 
                  (StringUnary
                    op_id: VTest_Hyphen
                    arg_word: {(DQ ($ VSub_Name "$upstream_name"))}
                  )
                spids: [2771 2777]
              )
            }
          spids: [2770]
        )
      ]
      spids: [2770]
    )
    (Case
      to_match: {(DQ ($ VSub_Name "$onto_name"))}
      arms: [
        (case_arm
          pat_list: [{(Lit_Other "*") (...) (Lit_Other "*")}]
          action: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (AndOr
                      children: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:left)
                              op: Equal
                              rhs: 
                                {
                                  (BracedVarSub
                                    token: <VSub_Name onto_name>
                                    suffix_op: (StringUnary op_id:VOp1_Percent arg_word:{("...*")})
                                    spids: [2796 2800]
                                  )
                                }
                              spids: [2795]
                            )
                            (assign_pair
                              lhs: (LhsName name:right)
                              op: Equal
                              rhs: 
                                {
                                  (BracedVarSub
                                    token: <VSub_Name onto_name>
                                    suffix_op: (StringUnary op_id:VOp1_Pound arg_word:{("*...")})
                                    spids: [2803 2807]
                                  )
                                }
                              spids: [2802]
                            )
                          ]
                          spids: [2795]
                        )
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:onto)
                              op: Equal
                              rhs: 
                                {
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(git)} {(merge-base)} {(--all)} 
                                            {
                                              (BracedVarSub
                                                token: <VSub_Name left>
                                                suffix_op: 
                                                  (StringUnary
                                                    op_id: VTest_ColonHyphen
                                                    arg_word: {(HEAD)}
                                                  )
                                                spids: [2820 2824]
                                              )
                                            } 
                                            {
                                              (BracedVarSub
                                                token: <VSub_Name right>
                                                suffix_op: 
                                                  (StringUnary
                                                    op_id: VTest_ColonHyphen
                                                    arg_word: {(HEAD)}
                                                  )
                                                spids: [2826 2830]
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [2813 2831]
                                  )
                                }
                              spids: [2812]
                            )
                          ]
                          spids: [2812]
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  action: [
                    (Case
                      to_match: {(DQ ($ VSub_Name "$onto"))}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(Lit_Other "?") (Lit_Other "*") (DQ ($ VSub_Name "$LF")) (Lit_Other "?") 
                              (Lit_Other "*")
                            }
                          ]
                          action: [
                            (C {(die)} 
                              {
                                (DQ 
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(eval_gettext)} 
                                            {
                                              (DQ (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) 
                                                ("onto_name: there are more than one merge bases")
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [2859 2866]
                                  )
                                )
                              }
                            )
                          ]
                          spids: [2846 2853 2870 -1]
                        )
                        (case_arm
                          pat_list: [{(SQ )}]
                          action: [
                            (C {(die)} 
                              {
                                (DQ 
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(eval_gettext)} 
                                            {
                                              (DQ (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) 
                                                ("onto_name: there is no merge base")
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [2881 2888]
                                  )
                                )
                              }
                            )
                          ]
                          spids: [-1 2875 2892 -1]
                        )
                      ]
                      spids: [2837 2843 2895]
                    )
                  ]
                  spids: [-1 2834]
                )
              ]
              else_action: [
                (C {(die)} 
                  {
                    (DQ 
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(eval_gettext)} 
                                {
                                  (DQ (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) 
                                    ("onto_name: there is no merge base")
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [2904 2911]
                      )
                    )
                  }
                )
              ]
              spids: [2898 2915]
            )
          ]
          spids: [2787 2790 2918 -1]
        )
        (case_arm
          pat_list: [{(Lit_Other "*")}]
          action: [
            (AndOr
              children: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:onto)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [(C {(peel_committish)} {(DQ ($ VSub_Name "$onto_name"))})]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [2925 2931]
                          )
                        }
                      spids: [2924]
                    )
                  ]
                  spids: [2924]
                )
                (C {(die)} 
                  {
                    (DQ 
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(eval_gettext)} 
                                {
                                  (DQ ("Does not point to a valid commit: ") 
                                    (EscapedLiteralPart
                                      token: <Lit_EscapedChar "\\$">
                                    ) (onto_name)
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [2939 2947]
                      )
                    )
                  }
                )
              ]
              op_id: Op_DPipe
            )
          ]
          spids: [2920 2921 2951 -1]
        )
      ]
      spids: [2779 2785 2953]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:switch_to) op:Equal rhs:{(SQ )} spids:[2968])]
      spids: [2968]
    )
    (Case
      to_match: {(DQ ($ VSub_Pound "$#"))}
      arms: [
        (case_arm
          pat_list: [{(1)}]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:branch_name)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [2986]
                )
              ]
              spids: [2986]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:switch_to)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [2992]
                )
              ]
              spids: [2992]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (AndOr
                      children: [
                        (C {(git)} {(show-ref)} {(--verify)} {(--quiet)} {(--)} 
                          {(DQ (refs/heads/) ($ VSub_Number "$1"))}
                        )
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:orig_head)
                              op: Equal
                              rhs: 
                                {
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(git)} {(rev-parse)} {(-q)} {(--verify)} 
                                            {(DQ (refs/heads/) ($ VSub_Number "$1"))}
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [3020 3033]
                                  )
                                }
                              spids: [3019]
                            )
                          ]
                          spids: [3019]
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:head_name)
                          op: Equal
                          rhs: {(DQ (refs/heads/) ($ VSub_Number "$1"))}
                          spids: [3039]
                        )
                      ]
                      spids: [3039]
                    )
                  ]
                  spids: [-1 3036]
                )
                (if_arm
                  cond: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:orig_head)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(git)} {(rev-parse)} {(-q)} {(--verify)} 
                                        {(DQ ($ VSub_Number "$1"))}
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [3049 3061]
                              )
                            }
                          spids: [3048]
                        )
                      ]
                      spids: [3048]
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:head_name)
                          op: Equal
                          rhs: {(DQ ("detached HEAD"))}
                          spids: [3067]
                        )
                      ]
                      spids: [3067]
                    )
                  ]
                  spids: [3046 3064]
                )
              ]
              else_action: [
                (C {(die)} 
                  {
                    (DQ 
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(eval_gettext)} 
                                {
                                  (DQ ("fatal: no such branch: ") 
                                    (EscapedLiteralPart
                                      token: <Lit_EscapedChar "\\$">
                                    ) (branch_name)
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [3079 3087]
                      )
                    )
                  }
                )
              ]
              spids: [3073 3091]
            )
          ]
          spids: [2978 2979 3094 -1]
        )
        (case_arm
          pat_list: [{(0)}]
          action: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:branch_name)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [(C {(git)} {(symbolic-ref)} {(-q)} {(HEAD)})]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [3107 3115]
                              )
                            }
                          spids: [3106]
                        )
                      ]
                      spids: [3106]
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:head_name)
                          op: Equal
                          rhs: {($ VSub_Name "$branch_name")}
                          spids: [3121]
                        )
                      ]
                      spids: [3121]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:branch_name)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(expr)} {(DQ (z) ($ VSub_Name "$branch_name"))} 
                                        {(Lit_Other ":")} {(SQ <"zrefs/heads/\\(.*\\)">)}
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [3126 3139]
                              )
                            }
                          spids: [3125]
                        )
                      ]
                      spids: [3125]
                    )
                  ]
                  spids: [-1 3118]
                )
              ]
              else_action: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:head_name)
                      op: Equal
                      rhs: {(DQ ("detached HEAD"))}
                      spids: [3145]
                    )
                  ]
                  spids: [3145]
                )
                (Sentence
                  child: 
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:branch_name)
                          op: Equal
                          rhs: {(HEAD)}
                          spids: [3151]
                        )
                      ]
                      spids: [3151]
                    )
                  terminator: <Op_Semi ";">
                )
              ]
              spids: [3142 3159]
            )
            (AndOr
              children: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:orig_head)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [(C {(git)} {(rev-parse)} {(--verify)} {(HEAD)})]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [3163 3171]
                          )
                        }
                      spids: [3162]
                    )
                  ]
                  spids: [3162]
                )
                (C {(exit)})
              ]
              op_id: Op_DPipe
            )
          ]
          spids: [3096 3097 3178 -1]
        )
        (case_arm
          pat_list: [{(Lit_Other "*")}]
          action: [(C {(die)} {(DQ ("BUG: unexpected number of arguments left to parse"))})]
          spids: [3180 3181 3191 -1]
        )
      ]
      spids: [2970 2976 3193]
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(DQ ($ VSub_Name "$fork_point"))} {(Lit_Other "=")} {(t)})]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:new_upstream)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(git)} {(merge-base)} {(--fork-point)} 
                                {(DQ ($ VSub_Name "$upstream_name"))} 
                                {
                                  (DQ 
                                    (BracedVarSub
                                      token: <VSub_Name switch_to>
                                      suffix_op: 
                                        (StringUnary
                                          op_id: VTest_ColonHyphen
                                          arg_word: {(HEAD)}
                                        )
                                      spids: [3226 3230]
                                    )
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [3212 3232]
                      )
                    }
                  spids: [3211]
                )
              ]
              spids: [3211]
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name "$new_upstream"))})]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:restrict_revision)
                          op: Equal
                          rhs: {($ VSub_Name "$new_upstream")}
                          spids: [3249]
                        )
                      ]
                      spids: [3249]
                    )
                  ]
                  spids: [-1 3246]
                )
              ]
              spids: [-1 3253]
            )
          ]
          spids: [-1 3208]
        )
      ]
      spids: [-1 3255]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (AndOr
              children: [
                (C {(test)} {(DQ ($ VSub_Name "$autostash"))} {(Lit_Other "=")} {(true)})
                (Pipeline
                  children: [
                    (Subshell
                      child: (C {(require_clean_work_tree)})
                      redirects: [(Redir op_id:Redir_Great fd:2 arg_word:{(/dev/null)} spids:[3278])]
                      spids: [3274 3276]
                    )
                  ]
                  negated: True
                )
              ]
              op_id: Op_DAmp
            )
          ]
          action: [
            (AndOr
              children: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:stash_sha1)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [(C {(git)} {(stash)} {(create)} {(DQ (autostash))})]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [3285 3295]
                          )
                        }
                      spids: [3284]
                    )
                  ]
                  spids: [3284]
                )
                (C {(die)} 
                  {
                    (DQ 
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [(C {(gettext)} {(SQ <"Cannot autostash">)})]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [3303 3309]
                      )
                    )
                  }
                )
              ]
              op_id: Op_DPipe
            )
            (AndOr
              children: [
                (C {(mkdir)} {(-p)} {(DQ ($ VSub_Name "$state_dir"))})
                (AndOr
                  children: [
                    (SimpleCommand
                      words: [{(echo)} {($ VSub_Name "$stash_sha1")}]
                      redirects: [
                        (Redir
                          op_id: Redir_Great
                          fd: -1
                          arg_word: {(DQ ($ VSub_Name "$state_dir") (/autostash))}
                          spids: [3329]
                        )
                      ]
                    )
                    (AndOr
                      children: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:stash_abbrev)
                              op: Equal
                              rhs: 
                                {
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(git)} {(rev-parse)} {(--short)} 
                                            {($ VSub_Name "$stash_sha1")}
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [3339 3347]
                                  )
                                }
                              spids: [3338]
                            )
                          ]
                          spids: [3338]
                        )
                        (AndOr
                          children: [
                            (C {(echo)} 
                              {
                                (DQ 
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(eval_gettext)} 
                                            {(SQ <"Created autostash: $stash_abbrev">)}
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [3355 3361]
                                  )
                                )
                              }
                            )
                            (C {(git)} {(reset)} {(--hard)})
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [-1 3281]
        )
      ]
      spids: [-1 3373]
    )
    (C {(require_clean_work_tree)} {(DQ (rebase))} 
      {
        (DQ 
          (CommandSubPart
            command_list: 
              (CommandList
                children: [(C {(gettext)} {(DQ ("Please commit or stash them."))})]
              )
            left_token: <Left_CommandSub "$(">
            spids: [3383 3389]
          )
        )
      }
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:mb)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (C {(git)} {(merge-base)} {(DQ ($ VSub_Name "$onto"))} 
                        {(DQ ($ VSub_Name "$orig_head"))}
                      )
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [3410 3422]
              )
            }
          spids: [3409]
        )
      ]
      spids: [3409]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (AndOr
              children: [
                (C {(test)} {(DQ ($ VSub_Name "$type"))} {(KW_Bang "!") (Lit_Other "=")} {(interactive)})
                (AndOr
                  children: [
                    (C {(test)} {(DQ ($ VSub_Name "$upstream"))} {(Lit_Other "=")} 
                      {(DQ ($ VSub_Name "$onto"))}
                    )
                    (AndOr
                      children: [
                        (C {(test)} {(DQ ($ VSub_Name "$mb"))} {(Lit_Other "=")} 
                          {(DQ ($ VSub_Name "$onto"))}
                        )
                        (AndOr
                          children: [
                            (C {(test)} {(-z)} {(DQ ($ VSub_Name "$restrict_revision"))})
                            (Pipeline
                              children: [
                                (Subshell
                                  child: 
                                    (Pipeline
                                      children: [
                                        (C {(git)} {(rev-list)} {(--parents)} 
                                          {(DQ ($ VSub_Name "$onto")) (..) 
                                            (DQ ($ VSub_Name "$orig_head"))
                                          }
                                        )
                                        (C {(sane_grep)} {(DQ (" .* "))})
                                      ]
                                      negated: False
                                    )
                                  redirects: [
                                    (Redir
                                      op_id: Redir_Great
                                      fd: -1
                                      arg_word: {(/dev/null)}
                                      spids: [3509]
                                    )
                                  ]
                                  spids: [3485 3507]
                                )
                              ]
                              negated: True
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
          ]
          action: [
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$force_rebase"))})]
                  action: [
                    (AndOr
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_Name "$switch_to"))})
                        (SimpleCommand
                          words: [{(git)} {(checkout)} {(-q)} {(DQ ($ VSub_Name "$switch_to"))} {(--)}]
                          more_env: [
                            (env_pair
                              name: GIT_REFLOG_ACTION
                              val: 
                                {
                                  (DQ ($ VSub_Name "$GIT_REFLOG_ACTION") (": checkout ") 
                                    ($ VSub_Name "$switch_to")
                                  )
                                }
                              spids: [3545]
                            )
                          ]
                        )
                      ]
                      op_id: Op_DPipe
                    )
                    (C {(say)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ ("Current branch ") 
                                        (EscapedLiteralPart
                                          token: <Lit_EscapedChar "\\$">
                                        ) ("branch_name is up to date.")
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [3570 3578]
                          )
                        )
                      }
                    )
                    (C {(finish_rebase)})
                    (C {(exit)} {(0)})
                  ]
                  spids: [-1 3527]
                )
              ]
              else_action: [
                (C {(say)} 
                  {
                    (DQ 
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(eval_gettext)} 
                                {
                                  (DQ ("Current branch ") 
                                    (EscapedLiteralPart
                                      token: <Lit_EscapedChar "\\$">
                                    ) ("branch_name is up to date, rebase forced.")
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [3596 3604]
                      )
                    )
                  }
                )
              ]
              spids: [3590 3608]
            )
          ]
          spids: [-1 3513]
        )
      ]
      spids: [-1 3610]
    )
    (C {(run_pre_rebase_hook)} {(DQ ($ VSub_Name "$upstream_arg"))} {(DQ ($ VSub_At "$@"))})
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name "$diffstat"))})]
          action: [
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name "$verbose"))})]
                  action: [
                    (C {(echo)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ ("Changes from ") 
                                        (EscapedLiteralPart
                                          token: <Lit_EscapedChar "\\$">
                                        ) ("mb to ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("onto:")
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [3657 3667]
                          )
                        )
                      }
                    )
                  ]
                  spids: [-1 3651]
                )
              ]
              spids: [-1 3671]
            )
            (SimpleCommand
              words: [
                {(git)}
                {(diff)}
                {(--stat)}
                {(--summary)}
                {(DQ ($ VSub_Name "$mb"))}
                {(DQ ($ VSub_Name "$onto"))}
              ]
              more_env: [(env_pair name:GIT_PAGER val:{(SQ )} spids:[3678])]
            )
          ]
          spids: [-1 3637]
        )
      ]
      spids: [-1 3698]
    )
    (AndOr
      children: [
        (C {(test)} {(DQ ($ VSub_Name "$type"))} {(Lit_Other "=")} {(interactive)})
        (C {(run_specific_rebase)})
      ]
      op_id: Op_DAmp
    )
    (C {(say)} 
      {
        (DQ 
          (CommandSubPart
            command_list: 
              (CommandList
                children: [
                  (C {(gettext)} {(DQ ("First, rewinding head to replay your work on top of it..."))})
                ]
              )
            left_token: <Left_CommandSub "$(">
            spids: [3722 3728]
          )
        )
      }
    )
    (AndOr
      children: [
        (SimpleCommand
          words: [{(git)} {(checkout)} {(-q)} {(DQ ($ VSub_Name "$onto") ("^0"))}]
          more_env: [
            (env_pair
              name: GIT_REFLOG_ACTION
              val: {(DQ ($ VSub_Name "$GIT_REFLOG_ACTION") (": checkout ") ($ VSub_Name "$onto_name"))}
              spids: [3732]
            )
          ]
        )
        (C {(die)} {(DQ ("could not detach HEAD"))})
      ]
      op_id: Op_DPipe
    )
    (C {(git)} {(update-ref)} {(ORIG_HEAD)} {($ VSub_Name "$orig_head")})
    (If
      arms: [
        (if_arm
          cond: [
            (C {(test)} {(DQ ($ VSub_Name "$mb"))} {(Lit_Other "=")} {(DQ ($ VSub_Name "$orig_head"))})
          ]
          action: [
            (C {(say)} 
              {
                (DQ 
                  (CommandSubPart
                    command_list: 
                      (CommandList
                        children: [
                          (C {(eval_gettext)} 
                            {
                              (DQ ("Fast-forwarded ") 
                                (EscapedLiteralPart
                                  token: <Lit_EscapedChar "\\$">
                                ) ("branch_name to ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (onto_name.)
                              )
                            }
                          )
                        ]
                      )
                    left_token: <Left_CommandSub "$(">
                    spids: [3795 3805]
                  )
                )
              }
            )
            (C {(move_to_original_branch)})
            (C {(finish_rebase)})
            (C {(exit)} {(0)})
          ]
          spids: [-1 3789]
        )
      ]
      spids: [-1 3819]
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name "$rebase_root"))})]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:revisions)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$onto") (..) ($ VSub_Name "$orig_head"))}
                  spids: [3835]
                )
              ]
              spids: [3835]
            )
          ]
          spids: [-1 3832]
        )
      ]
      else_action: [
        (Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (LhsName name:revisions)
              op: Equal
              rhs: 
                {
                  (DQ 
                    (BracedVarSub
                      token: <VSub_Name restrict_revision>
                      suffix_op: (StringUnary op_id:VTest_Hyphen arg_word:{($ VSub_Name "$upstream")})
                      spids: [3847 3851]
                    ) (..) ($ VSub_Name "$orig_head")
                  )
                }
              spids: [3845]
            )
          ]
          spids: [3845]
        )
      ]
      spids: [3842 3856]
    )
    (C {(run_specific_rebase)})
  ]
)