(command.CommandList
  children: [
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:SUBDIRECTORY_OK)
          op: assign_op.Equal
          rhs: {<Yes>}
          spids: [13]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:OPTIONS_KEEPDASHDASH)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [16]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:OPTIONS_STUCKLONG)
          op: assign_op.Equal
          rhs: {<t>}
          spids: [18]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:OPTIONS_SPEC)
          op: assign_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]
        )
      ]
    )
    (C {<.>} {<git-sh-setup>})
    (C {<set_reflog_action>} {<rebase>})
    (C {<require_work_tree_exists>})
    (C {<cd_to_toplevel>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:LF)
          op: assign_op.Equal
          rhs: {(SQ <'\n'>)}
          spids: [75]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:ok_to_skip_pre_rebase)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [80]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:resolvemsg)
          op: assign_op.Equal
          rhs: 
            {
              (DQ <'\n'> 
                (command_sub
                  left_token: <Id.Left_DollarParen '$('>
                  command_list: 
                    (command.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".'
                              >
                            )
                          }
                        )
                      ]
                    )
                ) <'\n'>
              )
            }
          spids: [82]
        )
      ]
    )
    (C {<unset>} {<onto>})
    (C {<unset>} {<restrict_revision>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:cmd)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [105]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:strategy)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [107]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:strategy_opts)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [109]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:do_merge)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [111]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:merge_dir)
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_DollarName '$GIT_DIR')) </rebase-merge>}
          spids: [113]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:apply_dir)
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_DollarName '$GIT_DIR')) </rebase-apply>}
          spids: [119]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:verbose)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [125]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:diffstat)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [127]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<test>} 
          {
            (DQ 
              (command_sub
                left_token: <Id.Left_DollarParen '$('>
                command_list: 
                  (command.CommandList
                    children: [(C {<git>} {<config>} {<--bool>} {<rebase.stat>})]
                  )
              )
            )
          } {<Id.Lit_Equals '='>} {<true>}
        )
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:diffstat)
              op: assign_op.Equal
              rhs: {<t>}
              spids: [149]
            )
          ]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:autostash)
          op: assign_op.Equal
          rhs: 
            {
              (DQ 
                (command_sub
                  left_token: <Id.Left_DollarParen '$('>
                  command_list: 
                    (command.CommandList
                      children: [
                        (command.AndOr
                          ops: [Id.Op_DPipe]
                          children: [
                            (C {<git>} {<config>} {<--bool>} {<rebase.autostash>})
                            (C {<echo>} {<false>})
                          ]
                        )
                      ]
                    )
                )
              )
            }
          spids: [152]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:fork_point)
          op: assign_op.Equal
          rhs: {<auto>}
          spids: [171]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:git_am_opt)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [174]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:rebase_root)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [176]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:force_rebase)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [178]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:allow_rerere_autoupdate)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [180]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:in_progress)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [185]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:type)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [190]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:state_dir)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [195]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:action)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [200]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:preserve_merges)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [202]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:autosquash)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [204]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:keep_empty)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [206]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<test>} 
          {
            (DQ 
              (command_sub
                left_token: <Id.Left_DollarParen '$('>
                command_list: 
                  (command.CommandList
                    children: [(C {<git>} {<config>} {<--bool>} {<rebase.autosquash>})]
                  )
              )
            )
          } {<Id.Lit_Equals '='>} {(DQ <true>)}
        )
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:autosquash)
              op: assign_op.Equal
              rhs: {<t>}
              spids: [230]
            )
          ]
        )
      ]
    )
    (command.Case
      to_match: 
        {
          (DQ 
            (command_sub
              left_token: <Id.Left_DollarParen '$('>
              command_list: 
                (command.CommandList
                  children: [(C {<git>} {<config>} {<--bool>} {<commit.gpgsign>})]
                )
            )
          )
        }
      arms: [
        (case_arm
          pat_list: [{<true>}]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:gpg_sign_opt)
                  op: assign_op.Equal
                  rhs: {<-S>}
                  spids: [252]
                )
              ]
            )
          ]
          spids: [249 250 255 -1]
        )
        (case_arm
          pat_list: [{<Id.Lit_Star '*'>}]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:gpg_sign_opt)
                  op: assign_op.Equal
                  rhs: (word.Empty)
                  spids: [260]
                )
              ]
            )
          ]
          spids: [257 258 262 -1]
        )
      ]
    )
    (command.ShFunction
      name: read_basic_state
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp]
              children: [
                (C {<test>} {<-f>} {(DQ ($ Id.VSub_DollarName '$state_dir') </head-name>)})
                (C {<test>} {<-f>} {(DQ ($ Id.VSub_DollarName '$state_dir') </onto>)})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:head_name)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {<cat>} {(DQ ($ Id.VSub_DollarName '$state_dir')) </head-name>})
                                ]
                              )
                          )
                        }
                      spids: [299]
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:onto)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {<cat>} {(DQ ($ Id.VSub_DollarName '$state_dir')) </onto>})
                                ]
                              )
                          )
                        }
                      spids: [312]
                    )
                  ]
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: [
                        (C {<test>} {<-f>} {(DQ ($ Id.VSub_DollarName '$state_dir')) </orig-head>})
                      ]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:orig_head)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {<cat>} 
                                            {(DQ ($ Id.VSub_DollarName '$state_dir')) </orig-head>}
                                          )
                                        ]
                                      )
                                  )
                                }
                              spids: [352]
                            )
                          ]
                        )
                      ]
                      spids: [337 349]
                    )
                  ]
                  else_action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:orig_head)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {<cat>} {(DQ ($ Id.VSub_DollarName '$state_dir')) </head>})
                                    ]
                                  )
                              )
                            }
                          spids: [366]
                        )
                      ]
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:GIT_QUIET)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {<cat>} {(DQ ($ Id.VSub_DollarName '$state_dir')) </quiet>})
                                ]
                              )
                          )
                        }
                      spids: [382]
                    )
                  ]
                )
                (C {<test>} {<-f>} {(DQ ($ Id.VSub_DollarName '$state_dir')) </verbose>})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:verbose)
                      op: assign_op.Equal
                      rhs: {<t>}
                      spids: [406]
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<test>} {<-f>} {(DQ ($ Id.VSub_DollarName '$state_dir')) </strategy>})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:strategy)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (DQ 
                            (command_sub
                              left_token: <Id.Left_DollarParen '$('>
                              command_list: 
                                (command.CommandList
                                  children: [
                                    (C {<cat>} {(DQ ($ Id.VSub_DollarName '$state_dir')) </strategy>})
                                  ]
                                )
                            )
                          )
                        }
                      spids: [421]
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<test>} {<-f>} {(DQ ($ Id.VSub_DollarName '$state_dir')) </strategy_opts>})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:strategy_opts)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (DQ 
                            (command_sub
                              left_token: <Id.Left_DollarParen '$('>
                              command_list: 
                                (command.CommandList
                                  children: [
                                    (C {<cat>} 
                                      {(DQ ($ Id.VSub_DollarName '$state_dir')) </strategy_opts>}
                                    )
                                  ]
                                )
                            )
                          )
                        }
                      spids: [446]
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<test>} {<-f>} {(DQ ($ Id.VSub_DollarName '$state_dir')) </allow_rerere_autoupdate>})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:allow_rerere_autoupdate)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (DQ 
                            (command_sub
                              left_token: <Id.Left_DollarParen '$('>
                              command_list: 
                                (command.CommandList
                                  children: [
                                    (C {<cat>} 
                                      {(DQ ($ Id.VSub_DollarName '$state_dir')) 
                                        </allow_rerere_autoupdate>
                                      }
                                    )
                                  ]
                                )
                            )
                          )
                        }
                      spids: [471]
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<test>} {<-f>} {(DQ ($ Id.VSub_DollarName '$state_dir')) </gpg_sign_opt>})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:gpg_sign_opt)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (DQ 
                            (command_sub
                              left_token: <Id.Left_DollarParen '$('>
                              command_list: 
                                (command.CommandList
                                  children: [
                                    (C {<cat>} 
                                      {(DQ ($ Id.VSub_DollarName '$state_dir')) </gpg_sign_opt>}
                                    )
                                  ]
                                )
                            )
                          )
                        }
                      spids: [496]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: write_basic_state
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp]
              children: [
                (command.Simple
                  words: [{<echo>} {(DQ ($ Id.VSub_DollarName '$head_name'))}]
                  redirects: [
                    (redir.Redir
                      op: <Id.Redir_Great '>'>
                      fd: -1
                      arg_word: {(DQ ($ Id.VSub_DollarName '$state_dir')) </head-name>}
                    )
                  ]
                )
                (command.Simple
                  words: [{<echo>} {(DQ ($ Id.VSub_DollarName '$onto'))}]
                  redirects: [
                    (redir.Redir
                      op: <Id.Redir_Great '>'>
                      fd: -1
                      arg_word: {(DQ ($ Id.VSub_DollarName '$state_dir')) </onto>}
                    )
                  ]
                )
                (command.Simple
                  words: [{<echo>} {(DQ ($ Id.VSub_DollarName '$orig_head'))}]
                  redirects: [
                    (redir.Redir
                      op: <Id.Redir_Great '>'>
                      fd: -1
                      arg_word: {(DQ ($ Id.VSub_DollarName '$state_dir')) </orig-head>}
                    )
                  ]
                )
                (command.Simple
                  words: [{<echo>} {(DQ ($ Id.VSub_DollarName '$GIT_QUIET'))}]
                  redirects: [
                    (redir.Redir
                      op: <Id.Redir_Great '>'>
                      fd: -1
                      arg_word: {(DQ ($ Id.VSub_DollarName '$state_dir')) </quiet>}
                    )
                  ]
                )
                (C {<test>} {<t>} {<Id.Lit_Equals '='>} {(DQ ($ Id.VSub_DollarName '$verbose'))})
                (command.Simple
                  words: [{<Id.Lit_Other ':'>}]
                  redirects: [
                    (redir.Redir
                      op: <Id.Redir_Great '>'>
                      fd: -1
                      arg_word: {(DQ ($ Id.VSub_DollarName '$state_dir')) </verbose>}
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$strategy'))})
                (command.Simple
                  words: [{<echo>} {(DQ ($ Id.VSub_DollarName '$strategy'))}]
                  redirects: [
                    (redir.Redir
                      op: <Id.Redir_Great '>'>
                      fd: -1
                      arg_word: {(DQ ($ Id.VSub_DollarName '$state_dir')) </strategy>}
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$strategy_opts'))})
                (command.Simple
                  words: [{<echo>} {(DQ ($ Id.VSub_DollarName '$strategy_opts'))}]
                  redirects: [
                    (redir.Redir
                      op: <Id.Redir_Great '>'>
                      fd: -1
                      arg_word: {(DQ ($ Id.VSub_DollarName '$state_dir')) </strategy_opts>}
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$allow_rerere_autoupdate'))})
                (command.Simple
                  words: [{<echo>} {(DQ ($ Id.VSub_DollarName '$allow_rerere_autoupdate'))}]
                  redirects: [
                    (redir.Redir
                      op: <Id.Redir_Great '>'>
                      fd: -1
                      arg_word: {(DQ ($ Id.VSub_DollarName '$state_dir')) </allow_rerere_autoupdate>}
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$gpg_sign_opt'))})
                (command.Simple
                  words: [{<echo>} {(DQ ($ Id.VSub_DollarName '$gpg_sign_opt'))}]
                  redirects: [
                    (redir.Redir
                      op: <Id.Redir_Great '>'>
                      fd: -1
                      arg_word: {(DQ ($ Id.VSub_DollarName '$state_dir')) </gpg_sign_opt>}
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: output
      body: 
        (command.BraceGroup
          children: [
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName '$verbose'))}
              arms: [
                (case_arm
                  pat_list: [{(SQ )}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:output)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (command.Simple
                                        words: [{(DQ ($ Id.VSub_At '$@'))}]
                                        redirects: [
                                          (redir.Redir
                                            op: <Id.Redir_GreatAnd '2>&'>
                                            fd: 2
                                            arg_word: {<1>}
                                          )
                                        ]
                                      )
                                    ]
                                  )
                              )
                            }
                          spids: [729]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:status)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_QMark '$?')}
                          spids: [741]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<test>} {($ Id.VSub_DollarName '$status')} 
                          {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<0>}
                        )
                        (C {<printf>} {(DQ <'%s'> <Id.Lit_Other '\\'> <n>)} 
                          {(DQ ($ Id.VSub_DollarName '$output'))}
                        )
                      ]
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {($ Id.VSub_DollarName '$status')}
                    )
                  ]
                  spids: [724 726 774 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [(C {(DQ ($ Id.VSub_At '$@'))})]
                  spids: [777 778 786 -1]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: move_to_original_branch
      body: 
        (command.BraceGroup
          children: [
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName '$head_name'))}
              arms: [
                (case_arm
                  pat_list: [{<refs/> <Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:message)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ <'rebase finished: '> ($ Id.VSub_DollarName '$head_name') <' onto '> 
                                ($ Id.VSub_DollarName '$onto')
                              )
                            }
                          spids: [816]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp Id.Op_DPipe]
                      children: [
                        (C {<git>} {<update-ref>} {<-m>} {(DQ ($ Id.VSub_DollarName '$message'))} 
                          {($ Id.VSub_DollarName '$head_name')} 
                          {
                            (command_sub
                              left_token: <Id.Left_DollarParen '$('>
                              command_list: 
                                (command.CommandList
                                  children: [(C {<git>} {<rev-parse>} {<HEAD>})]
                                )
                            )
                          } {($ Id.VSub_DollarName '$orig_head')}
                        )
                        (C {<git>} {<symbolic-ref>} {<-m>} 
                          {
                            (DQ <'rebase finished: returning to '> ($ Id.VSub_DollarName '$head_name'))
                          } {<HEAD>} {($ Id.VSub_DollarName '$head_name')}
                        )
                        (C {<die>} 
                          {
                            (DQ 
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {<eval_gettext>} 
                                        {
                                          (DQ <'Could not move back to '> 
                                            (word_part.EscapedLiteral
                                              token: <Id.Lit_EscapedChar '\\$'>
                                            ) <head_name>
                                          )
                                        }
                                      )
                                    ]
                                  )
                              )
                            )
                          }
                        )
                      ]
                    )
                  ]
                  spids: [811 813 889 -1]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: apply_autostash
      body: 
        (command.BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: [(C {<test>} {<-f>} {(DQ ($ Id.VSub_DollarName '$state_dir') </autostash>)})]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:stash_sha1)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {<cat>} {(DQ ($ Id.VSub_DollarName '$state_dir') </autostash>)})
                                    ]
                                  )
                              )
                            }
                          spids: [920]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Simple
                              words: [{<git>} {<stash>} {<apply>} {($ Id.VSub_DollarName '$stash_sha1')}]
                              redirects: [
                                (redir.Redir
                                  op: <Id.Redir_GreatAnd '2>&'>
                                  fd: 2
                                  arg_word: {<1>}
                                )
                                (redir.Redir
                                  op: <Id.Redir_Great '>'>
                                  fd: -1
                                  arg_word: {</dev/null>}
                                )
                              ]
                            )
                          ]
                          action: [
                            (C {<echo>} 
                              {
                                (DQ 
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    command_list: 
                                      (command.CommandList
                                        children: [(C {<gettext>} {(SQ <'Applied autostash.'>)})]
                                      )
                                  )
                                )
                              }
                            )
                          ]
                          spids: [931 948]
                        )
                      ]
                      else_action: [
                        (command.AndOr
                          ops: [Id.Op_DPipe]
                          children: [
                            (C {<git>} {<stash>} {<store>} {<-m>} {(DQ <autostash>)} {<-q>} 
                              {($ Id.VSub_DollarName '$stash_sha1')}
                            )
                            (C {<die>} 
                              {
                                (DQ 
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {<eval_gettext>} 
                                            {
                                              (DQ <'Cannot store '> 
                                                (word_part.EscapedLiteral
                                                  token: <Id.Lit_EscapedChar '\\$'>
                                                ) <stash_sha1>
                                              )
                                            }
                                          )
                                        ]
                                      )
                                  )
                                )
                              }
                            )
                          ]
                        )
                        (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: [905 917]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: finish_rebase
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DAmp]
              children: [
                (C {<apply_autostash>})
                (command.BraceGroup
                  children: [
                    (command.Sentence
                      child: 
                        (command.AndOr
                          ops: [Id.Op_DPipe]
                          children: [(C {<git>} {<gc>} {<--auto>}) (C {<true>})]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
                (C {<rm>} {<-rf>} {(DQ ($ Id.VSub_DollarName '$state_dir'))})
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: run_specific_rebase
      body: 
        (command.BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$interactive_rebase'))} 
                          {<Id.Lit_Equals '='>} {<implied>} {<Id.Lit_RBracket ']'>}
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:GIT_EDITOR)
                          op: assign_op.Equal
                          rhs: {<Id.Lit_Other ':'>}
                          spids: [1086]
                        )
                      ]
                    )
                    (C {<export>} {<GIT_EDITOR>})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:autosquash)
                          op: assign_op.Equal
                          rhs: (word.Empty)
                          spids: [1095]
                        )
                      ]
                    )
                  ]
                  spids: [1068 1083]
                )
              ]
            )
            (C {<.>} {<git-rebase--> ($ Id.VSub_DollarName '$type')})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:ret)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_QMark '$?')}
                  spids: [1107]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [(C {<test>} {($ Id.VSub_DollarName '$ret')} {<-eq>} {<0>})]
                  action: [(C {<finish_rebase>})]
                  spids: [1111 1122]
                )
                (if_arm
                  cond: [(C {<test>} {($ Id.VSub_DollarName '$ret')} {<-eq>} {<2>})]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp Id.Op_DAmp]
                      children: [
                        (C {<apply_autostash>})
                        (C {<rm>} {<-rf>} {(DQ ($ Id.VSub_DollarName '$state_dir'))})
                        (C {<die>} {(DQ <'Nothing to do'>)})
                      ]
                    )
                  ]
                  spids: [1128 1142]
                )
              ]
            )
            (command.ControlFlow
              token: <Id.ControlFlow_Exit exit>
              arg_word: {($ Id.VSub_DollarName '$ret')}
            )
          ]
        )
    )
    (command.ShFunction
      name: run_pre_rebase_hook
      body: 
        (command.BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$ok_to_skip_pre_rebase'))})
                        (C {<test>} {<-x>} 
                          {
                            (DQ 
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {<git>} {<rev-parse>} {<--git-path>} {<hooks/pre-rebase>})
                                    ]
                                  )
                              )
                            )
                          }
                        )
                      ]
                    )
                  ]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C 
                          {
                            (DQ 
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {<git>} {<rev-parse>} {<--git-path>} {<hooks/pre-rebase>})
                                    ]
                                  )
                              )
                            )
                          } 
                          {
                            (braced_var_sub
                              token: <Id.VSub_Number 1>
                              suffix_op: 
                                (suffix_op.Unary
                                  op_id: Id.VTest_Plus
                                  arg_word: {(DQ ($ Id.VSub_At '$@'))}
                                )
                            )
                          }
                        )
                        (C {<die>} 
                          {
                            (DQ 
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {<gettext>} {(DQ <'The pre-rebase hook refused to rebase.'>)})
                                    ]
                                  )
                              )
                            )
                          }
                        )
                      ]
                    )
                  ]
                  spids: [1186 1216]
                )
              ]
            )
          ]
        )
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<test>} {<-f>} {(DQ ($ Id.VSub_DollarName '$apply_dir')) </applying>})
        (C {<die>} 
          {
            (DQ 
              (command_sub
                left_token: <Id.Left_DollarParen '$('>
                command_list: 
                  (command.CommandList
                    children: [
                      (C {<gettext>} {(DQ <'It looks like git-am is in progress. Cannot rebase.'>)})
                    ]
                  )
              )
            )
          }
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {<test>} {<-d>} {(DQ ($ Id.VSub_DollarName '$apply_dir'))})]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:type)
                  op: assign_op.Equal
                  rhs: {<am>}
                  spids: [1298]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:state_dir)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$apply_dir'))}
                  spids: [1302]
                )
              ]
            )
          ]
          spids: [1285 1295]
        )
        (if_arm
          cond: [(C {<test>} {<-d>} {(DQ ($ Id.VSub_DollarName '$merge_dir'))})]
          action: [
            (command.If
              arms: [
                (if_arm
                  cond: [(C {<test>} {<-f>} {(DQ ($ Id.VSub_DollarName '$merge_dir')) </interactive>})]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:type)
                          op: assign_op.Equal
                          rhs: {<interactive>}
                          spids: [1335]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:interactive_rebase)
                          op: assign_op.Equal
                          rhs: {<explicit>}
                          spids: [1339]
                        )
                      ]
                    )
                  ]
                  spids: [1320 1332]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:type)
                      op: assign_op.Equal
                      rhs: {<merge>}
                      spids: [1346]
                    )
                  ]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:state_dir)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$merge_dir'))}
                  spids: [1353]
                )
              ]
            )
          ]
          spids: [1307 1317]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$type'))})
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:in_progress)
              op: assign_op.Equal
              rhs: {<t>}
              spids: [1370]
            )
          ]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:total_argc)
          op: assign_op.Equal
          rhs: {($ Id.VSub_Pound '$#')}
          spids: [1374]
        )
      ]
    )
    (command.WhileUntil
      keyword: <Id.KW_While while>
      cond: [(C {<test>} {($ Id.VSub_Pound '$#')} {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<0>})]
      body: 
        (command.DoGroup
          children: [
            (command.Case
              to_match: {(DQ ($ Id.VSub_Number '$1'))}
              arms: [
                (case_arm
                  pat_list: [{<--no-verify>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:ok_to_skip_pre_rebase)
                          op: assign_op.Equal
                          rhs: {<yes>}
                          spids: [1404]
                        )
                      ]
                    )
                  ]
                  spids: [1400 1401 1408 -1]
                )
                (case_arm
                  pat_list: [{<--verify>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:ok_to_skip_pre_rebase)
                          op: assign_op.Equal
                          rhs: (word.Empty)
                          spids: [1415]
                        )
                      ]
                    )
                  ]
                  spids: [1411 1412 1418 -1]
                )
                (case_arm
                  pat_list: [{<--continue>} {<--skip>} {<--abort>} {<--edit-todo>}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<test>} {($ Id.VSub_DollarName '$total_argc')} {<-eq>} {<2>})
                        (C {<usage>})
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:action)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (braced_var_sub
                                token: <Id.VSub_Number 1>
                                suffix_op: (suffix_op.Unary op_id:Id.VOp1_DPound arg_word:{<-->})
                              )
                            }
                          spids: [1444]
                        )
                      ]
                    )
                  ]
                  spids: [1421 1428 1452 -1]
                )
                (case_arm
                  pat_list: [{<--onto> <Id.Lit_Equals '='> <Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:onto)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Number 1>
                                  suffix_op: 
                                    (suffix_op.Unary
                                      op_id: Id.VOp1_Pound
                                      arg_word: {<'--onto='>}
                                    )
                                )
                              )
                            }
                          spids: [1461]
                        )
                      ]
                    )
                  ]
                  spids: [1455 1458 1471 -1]
                )
                (case_arm
                  pat_list: [{<--exec> <Id.Lit_Equals '='> <Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:cmd)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ (${ Id.VSub_Name cmd) <'exec '> 
                                (braced_var_sub
                                  token: <Id.VSub_Number 1>
                                  suffix_op: 
                                    (suffix_op.Unary
                                      op_id: Id.VOp1_Pound
                                      arg_word: {<'--exec='>}
                                    )
                                ) (${ Id.VSub_Name LF)
                              )
                            }
                          spids: [1480]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$interactive_rebase'))})
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:interactive_rebase)
                              op: assign_op.Equal
                              rhs: {<implied>}
                              spids: [1507]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [1474 1477 1511 -1]
                )
                (case_arm
                  pat_list: [{<--interactive>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:interactive_rebase)
                          op: assign_op.Equal
                          rhs: {<explicit>}
                          spids: [1518]
                        )
                      ]
                    )
                  ]
                  spids: [1514 1515 1522 -1]
                )
                (case_arm
                  pat_list: [{<--keep-empty>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:keep_empty)
                          op: assign_op.Equal
                          rhs: {<yes>}
                          spids: [1529]
                        )
                      ]
                    )
                  ]
                  spids: [1525 1526 1533 -1]
                )
                (case_arm
                  pat_list: [{<--preserve-merges>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:preserve_merges)
                          op: assign_op.Equal
                          rhs: {<t>}
                          spids: [1540]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$interactive_rebase'))})
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:interactive_rebase)
                              op: assign_op.Equal
                              rhs: {<implied>}
                              spids: [1554]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [1536 1537 1558 -1]
                )
                (case_arm
                  pat_list: [{<--autosquash>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:autosquash)
                          op: assign_op.Equal
                          rhs: {<t>}
                          spids: [1565]
                        )
                      ]
                    )
                  ]
                  spids: [1561 1562 1569 -1]
                )
                (case_arm
                  pat_list: [{<--no-autosquash>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:autosquash)
                          op: assign_op.Equal
                          rhs: (word.Empty)
                          spids: [1576]
                        )
                      ]
                    )
                  ]
                  spids: [1572 1573 1579 -1]
                )
                (case_arm
                  pat_list: [{<--fork-point>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:fork_point)
                          op: assign_op.Equal
                          rhs: {<t>}
                          spids: [1586]
                        )
                      ]
                    )
                  ]
                  spids: [1582 1583 1590 -1]
                )
                (case_arm
                  pat_list: [{<--no-fork-point>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:fork_point)
                          op: assign_op.Equal
                          rhs: (word.Empty)
                          spids: [1597]
                        )
                      ]
                    )
                  ]
                  spids: [1593 1594 1600 -1]
                )
                (case_arm
                  pat_list: [{<--merge>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:do_merge)
                          op: assign_op.Equal
                          rhs: {<t>}
                          spids: [1607]
                        )
                      ]
                    )
                  ]
                  spids: [1603 1604 1611 -1]
                )
                (case_arm
                  pat_list: [{<--strategy-option> <Id.Lit_Equals '='> <Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:strategy_opts)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ ($ Id.VSub_DollarName '$strategy_opts') <' '> 
                                (command_sub
                                  left_token: <Id.Left_DollarParen '$('>
                                  command_list: 
                                    (command.CommandList
                                      children: [
                                        (C {<git>} {<rev-parse>} {<--sq-quote>} 
                                          {
                                            (DQ <--> 
                                              (braced_var_sub
                                                token: <Id.VSub_Number 1>
                                                suffix_op: 
                                                  (suffix_op.Unary
                                                    op_id: Id.VOp1_Pound
                                                    arg_word: {<'--strategy-option='>}
                                                  )
                                              )
                                            )
                                          }
                                        )
                                      ]
                                    )
                                )
                              )
                            }
                          spids: [1620]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:do_merge)
                          op: assign_op.Equal
                          rhs: {<t>}
                          spids: [1643]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$strategy'))})
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:strategy)
                              op: assign_op.Equal
                              rhs: {<recursive>}
                              spids: [1657]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [1614 1617 1661 -1]
                )
                (case_arm
                  pat_list: [{<--strategy> <Id.Lit_Equals '='> <Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:strategy)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Number 1>
                                  suffix_op: 
                                    (suffix_op.Unary
                                      op_id: Id.VOp1_Pound
                                      arg_word: {<'--strategy='>}
                                    )
                                )
                              )
                            }
                          spids: [1670]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:do_merge)
                          op: assign_op.Equal
                          rhs: {<t>}
                          spids: [1680]
                        )
                      ]
                    )
                  ]
                  spids: [1664 1667 1684 -1]
                )
                (case_arm
                  pat_list: [{<--no-stat>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:diffstat)
                          op: assign_op.Equal
                          rhs: (word.Empty)
                          spids: [1691]
                        )
                      ]
                    )
                  ]
                  spids: [1687 1688 1694 -1]
                )
                (case_arm
                  pat_list: [{<--stat>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:diffstat)
                          op: assign_op.Equal
                          rhs: {<t>}
                          spids: [1701]
                        )
                      ]
                    )
                  ]
                  spids: [1697 1698 1705 -1]
                )
                (case_arm
                  pat_list: [{<--autostash>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:autostash)
                          op: assign_op.Equal
                          rhs: {<true>}
                          spids: [1712]
                        )
                      ]
                    )
                  ]
                  spids: [1708 1709 1716 -1]
                )
                (case_arm
                  pat_list: [{<--no-autostash>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:autostash)
                          op: assign_op.Equal
                          rhs: {<false>}
                          spids: [1723]
                        )
                      ]
                    )
                  ]
                  spids: [1719 1720 1727 -1]
                )
                (case_arm
                  pat_list: [{<--verbose>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:verbose)
                          op: assign_op.Equal
                          rhs: {<t>}
                          spids: [1734]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:diffstat)
                          op: assign_op.Equal
                          rhs: {<t>}
                          spids: [1738]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:GIT_QUIET)
                          op: assign_op.Equal
                          rhs: (word.Empty)
                          spids: [1742]
                        )
                      ]
                    )
                  ]
                  spids: [1730 1731 1745 -1]
                )
                (case_arm
                  pat_list: [{<--quiet>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:GIT_QUIET)
                          op: assign_op.Equal
                          rhs: {<t>}
                          spids: [1752]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:git_am_opt)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_DollarName '$git_am_opt') <' -q'>)}
                          spids: [1756]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:verbose)
                          op: assign_op.Equal
                          rhs: (word.Empty)
                          spids: [1763]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:diffstat)
                          op: assign_op.Equal
                          rhs: (word.Empty)
                          spids: [1766]
                        )
                      ]
                    )
                  ]
                  spids: [1748 1749 1769 -1]
                )
                (case_arm
                  pat_list: [{<--whitespace> <Id.Lit_Equals '='> <Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:git_am_opt)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ ($ Id.VSub_DollarName '$git_am_opt') <' --whitespace='> 
                                (braced_var_sub
                                  token: <Id.VSub_Number 1>
                                  suffix_op: 
                                    (suffix_op.Unary
                                      op_id: Id.VOp1_Pound
                                      arg_word: {<'--whitespace='>}
                                    )
                                )
                              )
                            }
                          spids: [1778]
                        )
                      ]
                    )
                    (command.Case
                      to_match: 
                        {
                          (DQ 
                            (braced_var_sub
                              token: <Id.VSub_Number 1>
                              suffix_op: 
                                (suffix_op.Unary
                                  op_id: Id.VOp1_Pound
                                  arg_word: {<'--whitespace='>}
                                )
                            )
                          )
                        }
                      arms: [
                        (case_arm
                          pat_list: [{<fix>} {<strip>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:force_rebase)
                                  op: assign_op.Equal
                                  rhs: {<t>}
                                  spids: [1809]
                                )
                              ]
                            )
                          ]
                          spids: [1803 1806 1813 -1]
                        )
                      ]
                    )
                  ]
                  spids: [1772 1775 1819 -1]
                )
                (case_arm
                  pat_list: [{<--ignore-whitespace>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:git_am_opt)
                          op: assign_op.Equal
                          rhs: 
                            {(DQ ($ Id.VSub_DollarName '$git_am_opt') <' '> ($ Id.VSub_Number '$1'))}
                          spids: [1826]
                        )
                      ]
                    )
                  ]
                  spids: [1822 1823 1834 -1]
                )
                (case_arm
                  pat_list: [{<--committer-date-is-author-date>} {<--ignore-date>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:git_am_opt)
                          op: assign_op.Equal
                          rhs: 
                            {(DQ ($ Id.VSub_DollarName '$git_am_opt') <' '> ($ Id.VSub_Number '$1'))}
                          spids: [1843]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:force_rebase)
                          op: assign_op.Equal
                          rhs: {<t>}
                          spids: [1851]
                        )
                      ]
                    )
                  ]
                  spids: [1837 1840 1855 -1]
                )
                (case_arm
                  pat_list: [{<-C> <Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:git_am_opt)
                          op: assign_op.Equal
                          rhs: 
                            {(DQ ($ Id.VSub_DollarName '$git_am_opt') <' '> ($ Id.VSub_Number '$1'))}
                          spids: [1863]
                        )
                      ]
                    )
                  ]
                  spids: [1858 1860 1871 -1]
                )
                (case_arm
                  pat_list: [{<--root>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:rebase_root)
                          op: assign_op.Equal
                          rhs: {<t>}
                          spids: [1878]
                        )
                      ]
                    )
                  ]
                  spids: [1874 1875 1882 -1]
                )
                (case_arm
                  pat_list: [{<--force-rebase>} {<--no-ff>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:force_rebase)
                          op: assign_op.Equal
                          rhs: {<t>}
                          spids: [1891]
                        )
                      ]
                    )
                  ]
                  spids: [1885 1888 1895 -1]
                )
                (case_arm
                  pat_list: [{<--rerere-autoupdate>} {<--no-rerere-autoupdate>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:allow_rerere_autoupdate)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_Number '$1'))}
                          spids: [1904]
                        )
                      ]
                    )
                  ]
                  spids: [1898 1901 1910 -1]
                )
                (case_arm
                  pat_list: [{<--gpg-sign>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:gpg_sign_opt)
                          op: assign_op.Equal
                          rhs: {<-S>}
                          spids: [1917]
                        )
                      ]
                    )
                  ]
                  spids: [1913 1914 1921 -1]
                )
                (case_arm
                  pat_list: [{<--gpg-sign> <Id.Lit_Equals '='> <Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:gpg_sign_opt)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ <-S> 
                                (braced_var_sub
                                  token: <Id.VSub_Number 1>
                                  suffix_op: 
                                    (suffix_op.Unary
                                      op_id: Id.VOp1_Pound
                                      arg_word: {<'--gpg-sign='>}
                                    )
                                )
                              )
                            }
                          spids: [1930]
                        )
                      ]
                    )
                  ]
                  spids: [1924 1927 1941 -1]
                )
                (case_arm
                  pat_list: [{<-->}]
                  action: [(C {<shift>}) (command.ControlFlow token:<Id.ControlFlow_Break break>)]
                  spids: [1944 1945 1954 -1]
                )
              ]
            )
            (C {<shift>})
          ]
        )
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [(C {<test>} {($ Id.VSub_Pound '$#')} {<-gt>} {<2>}) (C {<usage>})]
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$action'))})]
          action: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$in_progress'))})
                (C {<die>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        command_list: 
                          (command.CommandList
                            children: [(C {<gettext>} {(DQ <'No rebase in progress?'>)})]
                          )
                      )
                    )
                  }
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<test>} {(DQ ($ Id.VSub_DollarName '$type'))} {<Id.Lit_Equals '='>} 
                          {<interactive>}
                        )
                        (C {<test>} {(DQ ($ Id.VSub_DollarName '$GIT_REFLOG_ACTION'))} 
                          {<Id.Lit_Equals '='>} {<rebase>}
                        )
                      ]
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:GIT_REFLOG_ACTION)
                          op: assign_op.Equal
                          rhs: {(DQ <'rebase -i ('> ($ Id.VSub_DollarName '$action') <')'>)}
                          spids: [2045]
                        )
                      ]
                    )
                    (C {<export>} {<GIT_REFLOG_ACTION>})
                  ]
                  spids: [2017 2042]
                )
              ]
            )
          ]
          spids: [1977 1987]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<test>} {(DQ ($ Id.VSub_DollarName '$action'))} {<Id.Lit_Equals '='>} 
                  {(DQ <edit-todo>)}
                )
                (C {<test>} {(DQ ($ Id.VSub_DollarName '$type'))} {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} 
                  {(DQ <interactive>)}
                )
              ]
            )
          ]
          action: [
            (C {<die>} 
              {
                (DQ 
                  (command_sub
                    left_token: <Id.Left_DollarParen '$('>
                    command_list: 
                      (command.CommandList
                        children: [
                          (C {<gettext>} 
                            {
                              (DQ 
                                <
'The --edit-todo action can only be used during interactive rebase.'
                                >
                              )
                            }
                          )
                        ]
                      )
                  )
                )
              }
            )
          ]
          spids: [2063 2092]
        )
      ]
    )
    (command.Case
      to_match: {(DQ ($ Id.VSub_DollarName '$action'))}
      arms: [
        (case_arm
          pat_list: [{<Id.ControlFlow_Continue continue>}]
          action: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.Simple
                  words: [{<git>} {<rev-parse>} {<--verify>} {<HEAD>}]
                  redirects: [(redir.Redir op:<Id.Redir_Great '>'> fd:-1 arg_word:{</dev/null>})]
                )
                (C {<die>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        command_list: 
                          (command.CommandList
                            children: [(C {<gettext>} {(DQ <'Cannot read HEAD'>)})]
                          )
                      )
                    )
                  }
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DPipe]
              children: [
                (C {<git>} {<update-index>} {<--ignore-submodules>} {<--refresh>})
                (C {<git>} {<diff-files>} {<--quiet>} {<--ignore-submodules>})
                (command.BraceGroup
                  children: [
                    (C {<echo>} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {<gettext>} 
                                    {
                                      (DQ <'You must edit all merge conflicts and then\n'> 
                                        <'mark them as resolved using git add'>
                                      )
                                    }
                                  )
                                ]
                              )
                          )
                        )
                      }
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Exit exit>
                      arg_word: {<1>}
                    )
                  ]
                )
              ]
            )
            (C {<read_basic_state>})
            (C {<run_specific_rebase>})
          ]
          spids: [2118 2119 2205 -1]
        )
        (case_arm
          pat_list: [{<skip>}]
          action: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<output>} {<git>} {<reset>} {<--hard>} {<HEAD>})
                (command.ControlFlow
                  token: <Id.ControlFlow_Exit exit>
                  arg_word: {($ Id.VSub_QMark '$?')}
                )
              ]
            )
            (C {<read_basic_state>})
            (C {<run_specific_rebase>})
          ]
          spids: [2207 2208 2234 -1]
        )
        (case_arm
          pat_list: [{<abort>}]
          action: [
            (C {<git>} {<rerere>} {<clear>})
            (C {<read_basic_state>})
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName '$head_name'))}
              arms: [
                (case_arm
                  pat_list: [{<refs/> <Id.Lit_Star '*'>}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<git>} {<symbolic-ref>} {<-m>} {(DQ <'rebase: aborting'>)} {<HEAD>} 
                          {($ Id.VSub_DollarName '$head_name')}
                        )
                        (C {<die>} 
                          {
                            (DQ 
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {<eval_gettext>} 
                                        {
                                          (DQ <'Could not move back to '> 
                                            (word_part.EscapedLiteral
                                              token: <Id.Lit_EscapedChar '\\$'>
                                            ) <head_name>
                                          )
                                        }
                                      )
                                    ]
                                  )
                              )
                            )
                          }
                        )
                      ]
                    )
                  ]
                  spids: [2259 2261 2296 -1]
                )
              ]
            )
            (C {<output>} {<git>} {<reset>} {<--hard>} {($ Id.VSub_DollarName '$orig_head')})
            (C {<finish_rebase>})
            (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
          ]
          spids: [2236 2237 2319 -1]
        )
        (case_arm
          pat_list: [{<edit-todo>}]
          action: [(C {<run_specific_rebase>})]
          spids: [2321 2322 2328 -1]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$in_progress'))})]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:state_dir_base)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <Id.VSub_Name state_dir>
                        suffix_op: 
                          (suffix_op.Unary
                            op_id: Id.VOp1_DPound
                            arg_word: {<'*'> <Id.Lit_Slash />}
                          )
                      )
                    }
                  spids: [2349]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:cmd_live_rebase)
                  op: assign_op.Equal
                  rhs: {(DQ <'git rebase (--continue | --abort | --skip)'>)}
                  spids: [2358]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:cmd_clear_stale_rebase)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ <'rm -fr '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) 
                        ($ Id.VSub_DollarName '$state_dir') (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>)
                      )
                    }
                  spids: [2364]
                )
              ]
            )
            (C {<die>} 
              {
                (DQ <'\n'> 
                  (command_sub
                    left_token: <Id.Left_DollarParen '$('>
                    command_list: 
                      (command.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.'>
                              )
                            }
                          )
                        ]
                      )
                  )
                )
              }
            )
          ]
          spids: [2336 2346]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$rebase_root'))})
                (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$onto'))})
              ]
            )
          ]
          action: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$interactive_rebase'))})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:interactive_rebase)
                      op: assign_op.Equal
                      rhs: {<implied>}
                      spids: [2429]
                    )
                  ]
                )
              ]
            )
          ]
          spids: [2396 2416]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$interactive_rebase'))})]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:type)
                  op: assign_op.Equal
                  rhs: {<interactive>}
                  spids: [2448]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:state_dir)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$merge_dir'))}
                  spids: [2452]
                )
              ]
            )
          ]
          spids: [2435 2445]
        )
        (if_arm
          cond: [(C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$do_merge'))})]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:type)
                  op: assign_op.Equal
                  rhs: {<merge>}
                  spids: [2470]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:state_dir)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$merge_dir'))}
                  spids: [2474]
                )
              ]
            )
          ]
          spids: [2457 2467]
        )
      ]
      else_action: [
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:type)
              op: assign_op.Equal
              rhs: {<am>}
              spids: [2482]
            )
          ]
        )
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:state_dir)
              op: assign_op.Equal
              rhs: {(DQ ($ Id.VSub_DollarName '$apply_dir'))}
              spids: [2486]
            )
          ]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$rebase_root'))})]
          action: [
            (command.Case
              to_match: {(DQ ($ Id.VSub_Pound '$#'))}
              arms: [
                (case_arm
                  pat_list: [{<0>}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Pipeline
                              children: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:upstream_name)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (command.Simple
                                                    words: [
                                                      {<git>}
                                                      {<rev-parse>}
                                                      {<--symbolic-full-name>}
                                                      {<--verify>}
                                                      {<-q>}
                                                      {<Id.Lit_Other '@'> <Id.Lit_LBrace '{'> 
                                                        <upstream> <Id.Lit_RBrace '}'>
                                                      }
                                                    ]
                                                    redirects: [
                                                      (redir.Redir
                                                        op: <Id.Redir_Great '2>'>
                                                        fd: 2
                                                        arg_word: {</dev/null>}
                                                      )
                                                    ]
                                                  )
                                                ]
                                              )
                                          )
                                        }
                                      spids: [2524]
                                    )
                                  ]
                                )
                              ]
                              negated: T
                            )
                          ]
                          action: [
                            (C {<.>} {<git-parse-remote>})
                            (C {<error_on_missing_default_upstream>} {(DQ <rebase>)} {(DQ <rebase>)} 
                              {(DQ <against>)} 
                              {
                                (DQ <'git rebase '> 
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    command_list: 
                                      (command.CommandList
                                        children: [(C {<gettext>} {(SQ <'<branch>'>)})]
                                      )
                                  )
                                )
                              }
                            )
                          ]
                          spids: [2520 2548]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<test>} {(DQ ($ Id.VSub_DollarName '$fork_point'))} {<Id.Lit_Equals '='>} 
                          {<auto>}
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:fork_point)
                              op: assign_op.Equal
                              rhs: {<t>}
                              spids: [2600]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [2516 2517 2604 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:upstream_name)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_Number '$1'))}
                          spids: [2610]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (C {<test>} {(DQ ($ Id.VSub_DollarName '$upstream_name'))} 
                              {<Id.Lit_Equals '='>} {(DQ <->)}
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:upstream_name)
                                  op: assign_op.Equal
                                  rhs: {(DQ <'@{-1}'>)}
                                  spids: [2634]
                                )
                              ]
                            )
                          ]
                          spids: [2616 2631]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                  spids: [2607 2608 2646 -1]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:upstream)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {<peel_committish>} {(DQ (${ Id.VSub_Name upstream_name))})
                                ]
                              )
                          )
                        }
                      spids: [2652]
                    )
                  ]
                )
                (C {<die>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {<eval_gettext>} 
                                {
                                  (DQ <'invalid upstream '> 
                                    (word_part.EscapedLiteral
                                      token: <Id.Lit_EscapedChar '\\$'>
                                    ) <upstream_name>
                                  )
                                }
                              )
                            ]
                          )
                      )
                    )
                  }
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:upstream_arg)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$upstream_name'))}
                  spids: [2681]
                )
              ]
            )
          ]
          spids: [2494 2504]
        )
      ]
      else_action: [
        (command.If
          arms: [
            (if_arm
              cond: [(C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$onto'))})]
              action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:empty_tree)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            command_list: 
                              (command.CommandList
                                children: [(C {<git>} {<hash-object>} {<-t>} {<tree>} {</dev/null>})]
                              )
                          )
                        }
                      spids: [2703]
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:onto)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            command_list: 
                              (command.CommandList
                                children: [
                                  (command.Simple
                                    words: [
                                      {<git>}
                                      {<commit-tree>}
                                      {($ Id.VSub_DollarName '$empty_tree')}
                                    ]
                                    redirects: [
                                      (redir.Redir
                                        op: <Id.Redir_Less '<'>
                                        fd: -1
                                        arg_word: {</dev/null>}
                                      )
                                    ]
                                  )
                                ]
                              )
                          )
                        }
                      spids: [2717]
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:squash_onto)
                      op: assign_op.Equal
                      rhs: {(DQ ($ Id.VSub_DollarName '$onto'))}
                      spids: [2730]
                    )
                  ]
                )
              ]
              spids: [2689 2700]
            )
          ]
        )
        (C {<unset>} {<upstream_name>})
        (C {<unset>} {<upstream>})
        (command.AndOr
          ops: [Id.Op_DAmp]
          children: [(C {<test>} {($ Id.VSub_Pound '$#')} {<-gt>} {<1>}) (C {<usage>})]
        )
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:upstream_arg)
              op: assign_op.Equal
              rhs: {<--root>}
              spids: [2762]
            )
          ]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:onto_name)
          op: assign_op.Equal
          rhs: 
            {
              (braced_var_sub
                token: <Id.VSub_Name onto>
                suffix_op: 
                  (suffix_op.Unary
                    op_id: Id.VTest_Hyphen
                    arg_word: {(DQ ($ Id.VSub_DollarName '$upstream_name'))}
                  )
              )
            }
          spids: [2771]
        )
      ]
    )
    (command.Case
      to_match: {(DQ ($ Id.VSub_DollarName '$onto_name'))}
      arms: [
        (case_arm
          pat_list: [{<Id.Lit_Star '*'> <...> <Id.Lit_Star '*'>}]
          action: [
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:left)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (braced_var_sub
                                    token: <Id.VSub_Name onto_name>
                                    suffix_op: 
                                      (suffix_op.Unary
                                        op_id: Id.VOp1_Percent
                                        arg_word: {<'...*'>}
                                      )
                                  )
                                }
                              spids: [2796]
                            )
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:right)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (braced_var_sub
                                    token: <Id.VSub_Name onto_name>
                                    suffix_op: 
                                      (suffix_op.Unary
                                        op_id: Id.VOp1_Pound
                                        arg_word: {<'*...'>}
                                      )
                                  )
                                }
                              spids: [2803]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:onto)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {<git>} {<merge-base>} {<--all>} 
                                            {
                                              (braced_var_sub
                                                token: <Id.VSub_Name left>
                                                suffix_op: 
                                                  (suffix_op.Unary
                                                    op_id: Id.VTest_ColonHyphen
                                                    arg_word: {<HEAD>}
                                                  )
                                              )
                                            } 
                                            {
                                              (braced_var_sub
                                                token: <Id.VSub_Name right>
                                                suffix_op: 
                                                  (suffix_op.Unary
                                                    op_id: Id.VTest_ColonHyphen
                                                    arg_word: {<HEAD>}
                                                  )
                                              )
                                            }
                                          )
                                        ]
                                      )
                                  )
                                }
                              spids: [2813]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  action: [
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_DollarName '$onto'))}
                      arms: [
                        (case_arm
                          pat_list: [
                            {<Id.Lit_QMark '?'> <Id.Lit_Star '*'> (DQ ($ Id.VSub_DollarName '$LF')) 
                              <Id.Lit_QMark '?'> <Id.Lit_Star '*'>
                            }
                          ]
                          action: [
                            (C {<die>} 
                              {
                                (DQ 
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {<eval_gettext>} 
                                            {
                                              (DQ 
                                                (word_part.EscapedLiteral
                                                  token: <Id.Lit_EscapedChar '\\$'>
                                                ) <'onto_name: there are more than one merge bases'>
                                              )
                                            }
                                          )
                                        ]
                                      )
                                  )
                                )
                              }
                            )
                          ]
                          spids: [2847 2854 2871 -1]
                        )
                        (case_arm
                          pat_list: [{(SQ )}]
                          action: [
                            (C {<die>} 
                              {
                                (DQ 
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {<eval_gettext>} 
                                            {
                                              (DQ 
                                                (word_part.EscapedLiteral
                                                  token: <Id.Lit_EscapedChar '\\$'>
                                                ) <'onto_name: there is no merge base'>
                                              )
                                            }
                                          )
                                        ]
                                      )
                                  )
                                )
                              }
                            )
                          ]
                          spids: [2874 2876 2893 -1]
                        )
                      ]
                    )
                  ]
                  spids: [2794 2835]
                )
              ]
              else_action: [
                (C {<die>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {<eval_gettext>} 
                                {
                                  (DQ (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) 
                                    <'onto_name: there is no merge base'>
                                  )
                                }
                              )
                            ]
                          )
                      )
                    )
                  }
                )
              ]
            )
          ]
          spids: [2788 2791 2919 -1]
        )
        (case_arm
          pat_list: [{<Id.Lit_Star '*'>}]
          action: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:onto)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {<peel_committish>} {(DQ ($ Id.VSub_DollarName '$onto_name'))})
                                ]
                              )
                          )
                        }
                      spids: [2925]
                    )
                  ]
                )
                (C {<die>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {<eval_gettext>} 
                                {
                                  (DQ <'Does not point to a valid commit: '> 
                                    (word_part.EscapedLiteral
                                      token: <Id.Lit_EscapedChar '\\$'>
                                    ) <onto_name>
                                  )
                                }
                              )
                            ]
                          )
                      )
                    )
                  }
                )
              ]
            )
          ]
          spids: [2921 2922 2952 -1]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:switch_to)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [2969]
        )
      ]
    )
    (command.Case
      to_match: {(DQ ($ Id.VSub_Pound '$#'))}
      arms: [
        (case_arm
          pat_list: [{<1>}]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:branch_name)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_Number '$1'))}
                  spids: [2987]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:switch_to)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_Number '$1'))}
                  spids: [2993]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<git>} {<show-ref>} {<--verify>} {<--quiet>} {<-->} 
                          {(DQ <refs/heads/> ($ Id.VSub_Number '$1'))}
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:orig_head)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {<git>} {<rev-parse>} {<-q>} {<--verify>} 
                                            {(DQ <refs/heads/> ($ Id.VSub_Number '$1'))}
                                          )
                                        ]
                                      )
                                  )
                                }
                              spids: [3020]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:head_name)
                          op: assign_op.Equal
                          rhs: {(DQ <refs/heads/> ($ Id.VSub_Number '$1'))}
                          spids: [3040]
                        )
                      ]
                    )
                  ]
                  spids: [3000 3037]
                )
                (if_arm
                  cond: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:orig_head)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {<git>} {<rev-parse>} {<-q>} {<--verify>} 
                                        {(DQ ($ Id.VSub_Number '$1'))}
                                      )
                                    ]
                                  )
                              )
                            }
                          spids: [3049]
                        )
                      ]
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:head_name)
                          op: assign_op.Equal
                          rhs: {(DQ <'detached HEAD'>)}
                          spids: [3068]
                        )
                      ]
                    )
                  ]
                  spids: [3047 3065]
                )
              ]
              else_action: [
                (C {<die>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {<eval_gettext>} 
                                {
                                  (DQ <'fatal: no such branch: '> 
                                    (word_part.EscapedLiteral
                                      token: <Id.Lit_EscapedChar '\\$'>
                                    ) <branch_name>
                                  )
                                }
                              )
                            ]
                          )
                      )
                    )
                  }
                )
              ]
            )
          ]
          spids: [2979 2980 3095 -1]
        )
        (case_arm
          pat_list: [{<0>}]
          action: [
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:branch_name)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                command_list: 
                                  (command.CommandList
                                    children: [(C {<git>} {<symbolic-ref>} {<-q>} {<HEAD>})]
                                  )
                              )
                            }
                          spids: [3107]
                        )
                      ]
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:head_name)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName '$branch_name')}
                          spids: [3122]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:branch_name)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {<expr>} {(DQ <z> ($ Id.VSub_DollarName '$branch_name'))} 
                                        {<Id.Lit_Other ':'>} {(SQ <'zrefs/heads/\\(.*\\)'>)}
                                      )
                                    ]
                                  )
                              )
                            }
                          spids: [3126]
                        )
                      ]
                    )
                  ]
                  spids: [3105 3119]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:head_name)
                      op: assign_op.Equal
                      rhs: {(DQ <'detached HEAD'>)}
                      spids: [3146]
                    )
                  ]
                )
                (command.Sentence
                  child: 
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:branch_name)
                          op: assign_op.Equal
                          rhs: {<HEAD>}
                          spids: [3152]
                        )
                      ]
                    )
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:orig_head)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            command_list: 
                              (command.CommandList
                                children: [(C {<git>} {<rev-parse>} {<--verify>} {<HEAD>})]
                              )
                          )
                        }
                      spids: [3163]
                    )
                  ]
                )
                (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
              ]
            )
          ]
          spids: [3097 3098 3179 -1]
        )
        (case_arm
          pat_list: [{<Id.Lit_Star '*'>}]
          action: [(C {<die>} {(DQ <'BUG: unexpected number of arguments left to parse'>)})]
          spids: [3181 3182 3192 -1]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {<test>} {(DQ ($ Id.VSub_DollarName '$fork_point'))} {<Id.Lit_Equals '='>} {<t>})]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:new_upstream)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {<git>} {<merge-base>} {<--fork-point>} 
                                {(DQ ($ Id.VSub_DollarName '$upstream_name'))} 
                                {
                                  (DQ 
                                    (braced_var_sub
                                      token: <Id.VSub_Name switch_to>
                                      suffix_op: 
                                        (suffix_op.Unary
                                          op_id: Id.VTest_ColonHyphen
                                          arg_word: {<HEAD>}
                                        )
                                    )
                                  )
                                }
                              )
                            ]
                          )
                      )
                    }
                  spids: [3212]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [(C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$new_upstream'))})]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:restrict_revision)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName '$new_upstream')}
                          spids: [3250]
                        )
                      ]
                    )
                  ]
                  spids: [3236 3247]
                )
              ]
            )
          ]
          spids: [3197 3209]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<test>} {(DQ ($ Id.VSub_DollarName '$autostash'))} {<Id.Lit_Equals '='>} {<true>})
                (command.Pipeline
                  children: [
                    (command.Subshell
                      command_list: (command.CommandList children:[(C {<require_clean_work_tree>})])
                      redirects: [(redir.Redir op:<Id.Redir_Great '2>'> fd:2 arg_word:{</dev/null>})]
                    )
                  ]
                  negated: T
                )
              ]
            )
          ]
          action: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:stash_sha1)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            command_list: 
                              (command.CommandList
                                children: [(C {<git>} {<stash>} {<create>} {(DQ <autostash>)})]
                              )
                          )
                        }
                      spids: [3285]
                    )
                  ]
                )
                (C {<die>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        command_list: 
                          (command.CommandList
                            children: [(C {<gettext>} {(SQ <'Cannot autostash'>)})]
                          )
                      )
                    )
                  }
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp]
              children: [
                (C {<mkdir>} {<-p>} {(DQ ($ Id.VSub_DollarName '$state_dir'))})
                (command.Simple
                  words: [{<echo>} {($ Id.VSub_DollarName '$stash_sha1')}]
                  redirects: [
                    (redir.Redir
                      op: <Id.Redir_Great '>'>
                      fd: -1
                      arg_word: {(DQ ($ Id.VSub_DollarName '$state_dir') </autostash>)}
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:stash_abbrev)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {<git>} {<rev-parse>} {<--short>} 
                                    {($ Id.VSub_DollarName '$stash_sha1')}
                                  )
                                ]
                              )
                          )
                        }
                      spids: [3339]
                    )
                  ]
                )
                (C {<echo>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        command_list: 
                          (command.CommandList
                            children: [(C {<eval_gettext>} {(SQ <'Created autostash: $stash_abbrev'>)})]
                          )
                      )
                    )
                  }
                )
                (C {<git>} {<reset>} {<--hard>})
              ]
            )
          ]
          spids: [3259 3282]
        )
      ]
    )
    (C {<require_clean_work_tree>} {(DQ <rebase>)} 
      {
        (DQ 
          (command_sub
            left_token: <Id.Left_DollarParen '$('>
            command_list: 
              (command.CommandList
                children: [(C {<gettext>} {(DQ <'Please commit or stash them.'>)})]
              )
          )
        )
      }
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:mb)
          op: assign_op.Equal
          rhs: 
            {
              (command_sub
                left_token: <Id.Left_DollarParen '$('>
                command_list: 
                  (command.CommandList
                    children: [
                      (C {<git>} {<merge-base>} {(DQ ($ Id.VSub_DollarName '$onto'))} 
                        {(DQ ($ Id.VSub_DollarName '$orig_head'))}
                      )
                    ]
                  )
              )
            }
          spids: [3410]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp]
              children: [
                (C {<test>} {(DQ ($ Id.VSub_DollarName '$type'))} {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} 
                  {<interactive>}
                )
                (C {<test>} {(DQ ($ Id.VSub_DollarName '$upstream'))} {<Id.Lit_Equals '='>} 
                  {(DQ ($ Id.VSub_DollarName '$onto'))}
                )
                (C {<test>} {(DQ ($ Id.VSub_DollarName '$mb'))} {<Id.Lit_Equals '='>} 
                  {(DQ ($ Id.VSub_DollarName '$onto'))}
                )
                (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$restrict_revision'))})
                (command.Pipeline
                  children: [
                    (command.Subshell
                      command_list: 
                        (command.CommandList
                          children: [
                            (command.Pipeline
                              children: [
                                (C {<git>} {<rev-list>} {<--parents>} 
                                  {(DQ ($ Id.VSub_DollarName '$onto')) <..> 
                                    (DQ ($ Id.VSub_DollarName '$orig_head'))
                                  }
                                )
                                (C {<sane_grep>} {(DQ <' .* '>)})
                              ]
                              negated: F
                            )
                          ]
                        )
                      redirects: [(redir.Redir op:<Id.Redir_Great '>'> fd:-1 arg_word:{</dev/null>})]
                    )
                  ]
                  negated: T
                )
              ]
            )
          ]
          action: [
            (command.If
              arms: [
                (if_arm
                  cond: [(C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$force_rebase'))})]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$switch_to'))})
                        (command.Simple
                          words: [
                            {<git>}
                            {<checkout>}
                            {<-q>}
                            {(DQ ($ Id.VSub_DollarName '$switch_to'))}
                            {<-->}
                          ]
                          more_env: [
                            (env_pair
                              name: GIT_REFLOG_ACTION
                              val: 
                                {
                                  (DQ ($ Id.VSub_DollarName '$GIT_REFLOG_ACTION') <': checkout '> 
                                    ($ Id.VSub_DollarName '$switch_to')
                                  )
                                }
                              spids: [3546]
                            )
                          ]
                        )
                      ]
                    )
                    (C {<say>} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {<eval_gettext>} 
                                    {
                                      (DQ <'Current branch '> 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\$'>
                                        ) <'branch_name is up to date.'>
                                      )
                                    }
                                  )
                                ]
                              )
                          )
                        )
                      }
                    )
                    (C {<finish_rebase>})
                    (command.ControlFlow
                      token: <Id.ControlFlow_Exit exit>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [3517 3528]
                )
              ]
              else_action: [
                (C {<say>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {<eval_gettext>} 
                                {
                                  (DQ <'Current branch '> 
                                    (word_part.EscapedLiteral
                                      token: <Id.Lit_EscapedChar '\\$'>
                                    ) <'branch_name is up to date, rebase forced.'>
                                  )
                                }
                              )
                            ]
                          )
                      )
                    )
                  }
                )
              ]
            )
          ]
          spids: [3425 3514]
        )
      ]
    )
    (C {<run_pre_rebase_hook>} {(DQ ($ Id.VSub_DollarName '$upstream_arg'))} {(DQ ($ Id.VSub_At '$@'))})
    (command.If
      arms: [
        (if_arm
          cond: [(C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$diffstat'))})]
          action: [
            (command.If
              arms: [
                (if_arm
                  cond: [(C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$verbose'))})]
                  action: [
                    (C {<echo>} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {<eval_gettext>} 
                                    {
                                      (DQ <'Changes from '> 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\$'>
                                        ) <'mb to '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'onto:'>
                                      )
                                    }
                                  )
                                ]
                              )
                          )
                        )
                      }
                    )
                  ]
                  spids: [3641 3652]
                )
              ]
            )
            (command.Simple
              words: [
                {<git>}
                {<diff>}
                {<--stat>}
                {<--summary>}
                {(DQ ($ Id.VSub_DollarName '$mb'))}
                {(DQ ($ Id.VSub_DollarName '$onto'))}
              ]
              more_env: [(env_pair name:GIT_PAGER val:{(SQ )} spids:[3679])]
            )
          ]
          spids: [3628 3638]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<test>} {(DQ ($ Id.VSub_DollarName '$type'))} {<Id.Lit_Equals '='>} {<interactive>})
        (C {<run_specific_rebase>})
      ]
    )
    (C {<say>} 
      {
        (DQ 
          (command_sub
            left_token: <Id.Left_DollarParen '$('>
            command_list: 
              (command.CommandList
                children: [
                  (C {<gettext>} {(DQ <'First, rewinding head to replay your work on top of it...'>)})
                ]
              )
          )
        )
      }
    )
    (command.AndOr
      ops: [Id.Op_DPipe]
      children: [
        (command.Simple
          words: [{<git>} {<checkout>} {<-q>} {(DQ ($ Id.VSub_DollarName '$onto') <'^0'>)}]
          more_env: [
            (env_pair
              name: GIT_REFLOG_ACTION
              val: 
                {
                  (DQ ($ Id.VSub_DollarName '$GIT_REFLOG_ACTION') <': checkout '> 
                    ($ Id.VSub_DollarName '$onto_name')
                  )
                }
              spids: [3733]
            )
          ]
        )
        (C {<die>} {(DQ <'could not detach HEAD'>)})
      ]
    )
    (C {<git>} {<update-ref>} {<ORIG_HEAD>} {($ Id.VSub_DollarName '$orig_head')})
    (command.If
      arms: [
        (if_arm
          cond: [
            (C {<test>} {(DQ ($ Id.VSub_DollarName '$mb'))} {<Id.Lit_Equals '='>} 
              {(DQ ($ Id.VSub_DollarName '$orig_head'))}
            )
          ]
          action: [
            (C {<say>} 
              {
                (DQ 
                  (command_sub
                    left_token: <Id.Left_DollarParen '$('>
                    command_list: 
                      (command.CommandList
                        children: [
                          (C {<eval_gettext>} 
                            {
                              (DQ <'Fast-forwarded '> 
                                (word_part.EscapedLiteral
                                  token: <Id.Lit_EscapedChar '\\$'>
                                ) <'branch_name to '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <onto_name.>
                              )
                            }
                          )
                        ]
                      )
                  )
                )
              }
            )
            (C {<move_to_original_branch>})
            (C {<finish_rebase>})
            (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<0>})
          ]
          spids: [3776 3790]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$rebase_root'))})]
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:revisions)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$onto') <..> ($ Id.VSub_DollarName '$orig_head'))}
                  spids: [3836]
                )
              ]
            )
          ]
          spids: [3823 3833]
        )
      ]
      else_action: [
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:revisions)
              op: assign_op.Equal
              rhs: 
                {
                  (DQ 
                    (braced_var_sub
                      token: <Id.VSub_Name restrict_revision>
                      suffix_op: 
                        (suffix_op.Unary
                          op_id: Id.VTest_Hyphen
                          arg_word: {($ Id.VSub_DollarName '$upstream')}
                        )
                    ) <..> ($ Id.VSub_DollarName '$orig_head')
                  )
                }
              spids: [3846]
            )
          ]
        )
      ]
    )
    (C {<run_specific_rebase>})
  ]
)