(command.CommandList
  children: [
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:SUBDIRECTORY_OK spids:[13])
          op: Equal
          rhs: {(Yes)}
          spids: [13]
        )
      ]
      spids: [13]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:OPTIONS_KEEPDASHDASH spids:[16])
          op: Equal
          rhs: (word.EmptyWord)
          spids: [16]
        )
      ]
      spids: [16]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:OPTIONS_STUCKLONG spids:[18])
          op: Equal
          rhs: {(t)}
          spids: [18]
        )
      ]
      spids: [18]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:OPTIONS_SPEC spids:[21])
          op: Equal
          rhs: 
            {
              (DQ 
                (
'git rebase [-i] [options] [--exec <cmd>] [--onto <newbase>] [<upstream>] [<branch>]\n'
                ) ('git rebase [-i] [options] [--exec <cmd>] [--onto <newbase>] --root [<branch>]\n') 
                ('git-rebase --continue | --abort | --skip | --edit-todo\n') ('--\n') (' Available options are\n') 
                ('v,verbose!         display a diffstat of what changed upstream\n') ('q,quiet!           be quiet. implies --no-stat\n') 
                ('autostash          automatically stash/stash pop before and after\n') ("fork-point         use 'merge-base --fork-point' to refine upstream\n") 
                ('onto=!             rebase onto given branch instead of upstream\n') ('p,preserve-merges! try to recreate merges instead of ignoring them\n') 
                ('s,strategy=!       use the given merge strategy\n') ('no-ff!             cherry-pick all commits, even if unchanged\n') 
                ('m,merge!           use merging strategies to rebase\n') ('i,interactive!     let the user edit the list of commits to rebase\n') 
                ('x,exec=!           add exec lines after each commit of the editable list\n') ('k,keep-empty\t   preserve empty commits during rebase\n') 
                ('f,force-rebase!    force rebase even if branch is up to date\n') ('X,strategy-option=! pass the argument through to the merge strategy\n') 
                ('stat!              display a diffstat of what changed upstream\n') ('n,no-stat!         do not show diffstat of what changed upstream\n') 
                ('verify             allow pre-rebase hook to run\n') ('rerere-autoupdate  allow rerere to update index with resolved conflicts\n') 
                ('root!              rebase all reachable commits up to the root(s)\n') ('autosquash         move commits that begin with squash!/fixup! under -i\n') 
                ("committer-date-is-author-date! passed to 'git am'\n") ("ignore-date!       passed to 'git am'\n") ("whitespace=!       passed to 'git apply'\n") 
                ("ignore-whitespace! passed to 'git apply'\n") ("C=!                passed to 'git apply'\n") ('S,gpg-sign?        GPG-sign commits\n') 
                (' Actions:\n') ('continue!          continue\n') ('abort!             abort and check out the original branch\n') 
                ('skip!              skip current patch and continue\n') ('edit-todo!         edit the todo list during an interactive rebase\n')
              )
            }
          spids: [21]
        )
      ]
      spids: [21]
    )
    (C {(.)} {(git-sh-setup)})
    (C {(set_reflog_action)} {(rebase)})
    (C {(require_work_tree_exists)})
    (C {(cd_to_toplevel)})
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:LF spids:[75])
          op: Equal
          rhs: {(SQ <'\n'>)}
          spids: [75]
        )
      ]
      spids: [75]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:ok_to_skip_pre_rebase spids:[80])
          op: Equal
          rhs: (word.EmptyWord)
          spids: [80]
        )
      ]
      spids: [80]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:resolvemsg spids:[82])
          op: Equal
          rhs: 
            {
              (DQ ('\n') 
                (word_part.CommandSubPart
                  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".'
                              >
                            )
                          }
                        )
                      ]
                    )
                  left_token: <Left_CommandSub '$('>
                  spids: [85 93]
                ) ('\n')
              )
            }
          spids: [82]
        )
      ]
      spids: [82]
    )
    (C {(unset)} {(onto)})
    (C {(unset)} {(restrict_revision)})
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:cmd spids:[105])
          op: Equal
          rhs: (word.EmptyWord)
          spids: [105]
        )
      ]
      spids: [105]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:strategy spids:[107])
          op: Equal
          rhs: (word.EmptyWord)
          spids: [107]
        )
      ]
      spids: [107]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:strategy_opts spids:[109])
          op: Equal
          rhs: (word.EmptyWord)
          spids: [109]
        )
      ]
      spids: [109]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:do_merge spids:[111])
          op: Equal
          rhs: (word.EmptyWord)
          spids: [111]
        )
      ]
      spids: [111]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:merge_dir spids:[113])
          op: Equal
          rhs: {(DQ ($ VSub_DollarName '$GIT_DIR')) (/rebase-merge)}
          spids: [113]
        )
      ]
      spids: [113]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:apply_dir spids:[119])
          op: Equal
          rhs: {(DQ ($ VSub_DollarName '$GIT_DIR')) (/rebase-apply)}
          spids: [119]
        )
      ]
      spids: [119]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:verbose spids:[125])
          op: Equal
          rhs: (word.EmptyWord)
          spids: [125]
        )
      ]
      spids: [125]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:diffstat spids:[127])
          op: Equal
          rhs: (word.EmptyWord)
          spids: [127]
        )
      ]
      spids: [127]
    )
    (command.AndOr
      ops: [Op_DAmp]
      children: [
        (C {(test)} 
          {
            (DQ 
              (word_part.CommandSubPart
                command_list: 
                  (command.CommandList
                    children: [(C {(git)} {(config)} {(--bool)} {(rebase.stat)})]
                  )
                left_token: <Left_CommandSub '$('>
                spids: [132 140]
              )
            )
          } {(Lit_Other '=')} {(true)}
        )
        (command.Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (lhs_expr.LhsName name:diffstat spids:[149])
              op: Equal
              rhs: {(t)}
              spids: [149]
            )
          ]
          spids: [149]
        )
      ]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:autostash spids:[152])
          op: Equal
          rhs: 
            {
              (DQ 
                (word_part.CommandSubPart
                  command_list: 
                    (command.CommandList
                      children: [
                        (command.AndOr
                          ops: [Op_DPipe]
                          children: [
                            (C {(git)} {(config)} {(--bool)} {(rebase.autostash)})
                            (C {(echo)} {(false)})
                          ]
                        )
                      ]
                    )
                  left_token: <Left_CommandSub '$('>
                  spids: [154 168]
                )
              )
            }
          spids: [152]
        )
      ]
      spids: [152]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:fork_point spids:[171])
          op: Equal
          rhs: {(auto)}
          spids: [171]
        )
      ]
      spids: [171]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:git_am_opt spids:[174])
          op: Equal
          rhs: (word.EmptyWord)
          spids: [174]
        )
      ]
      spids: [174]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:rebase_root spids:[176])
          op: Equal
          rhs: (word.EmptyWord)
          spids: [176]
        )
      ]
      spids: [176]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:force_rebase spids:[178])
          op: Equal
          rhs: (word.EmptyWord)
          spids: [178]
        )
      ]
      spids: [178]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:allow_rerere_autoupdate spids:[180])
          op: Equal
          rhs: (word.EmptyWord)
          spids: [180]
        )
      ]
      spids: [180]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:in_progress spids:[185])
          op: Equal
          rhs: (word.EmptyWord)
          spids: [185]
        )
      ]
      spids: [185]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:type spids:[190])
          op: Equal
          rhs: (word.EmptyWord)
          spids: [190]
        )
      ]
      spids: [190]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:state_dir spids:[195])
          op: Equal
          rhs: (word.EmptyWord)
          spids: [195]
        )
      ]
      spids: [195]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:action spids:[200])
          op: Equal
          rhs: (word.EmptyWord)
          spids: [200]
        )
      ]
      spids: [200]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:preserve_merges spids:[202])
          op: Equal
          rhs: (word.EmptyWord)
          spids: [202]
        )
      ]
      spids: [202]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:autosquash spids:[204])
          op: Equal
          rhs: (word.EmptyWord)
          spids: [204]
        )
      ]
      spids: [204]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:keep_empty spids:[206])
          op: Equal
          rhs: (word.EmptyWord)
          spids: [206]
        )
      ]
      spids: [206]
    )
    (command.AndOr
      ops: [Op_DAmp]
      children: [
        (C {(test)} 
          {
            (DQ 
              (word_part.CommandSubPart
                command_list: 
                  (command.CommandList
                    children: [(C {(git)} {(config)} {(--bool)} {(rebase.autosquash)})]
                  )
                left_token: <Left_CommandSub '$('>
                spids: [211 219]
              )
            )
          } {(Lit_Other '=')} {(DQ (true))}
        )
        (command.Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (lhs_expr.LhsName name:autosquash spids:[230])
              op: Equal
              rhs: {(t)}
              spids: [230]
            )
          ]
          spids: [230]
        )
      ]
    )
    (command.Case
      to_match: 
        {
          (DQ 
            (word_part.CommandSubPart
              command_list: 
                (command.CommandList
                  children: [(C {(git)} {(config)} {(--bool)} {(commit.gpgsign)})]
                )
              left_token: <Left_CommandSub '$('>
              spids: [236 244]
            )
          )
        }
      arms: [
        (case_arm
          pat_list: [{(true)}]
          action: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:gpg_sign_opt spids:[252])
                  op: Equal
                  rhs: {(-S)}
                  spids: [252]
                )
              ]
              spids: [252]
            )
          ]
          spids: [249 250 255 16777215]
        )
        (case_arm
          pat_list: [{(Lit_Other '*')}]
          action: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:gpg_sign_opt spids:[260])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [260]
                )
              ]
              spids: [260]
            )
          ]
          spids: [257 258 262 16777215]
        )
      ]
      spids: [233 247 264]
    )
    (command.FuncDef
      name: read_basic_state
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DAmp Op_DAmp Op_DAmp Op_DAmp Op_DAmp Op_DAmp Op_DAmp]
              children: [
                (C {(test)} {(-f)} {(DQ ($ VSub_DollarName '$state_dir') (/head-name))})
                (C {(test)} {(-f)} {(DQ ($ VSub_DollarName '$state_dir') (/onto))})
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:head_name spids:[299])
                      op: Equal
                      rhs: 
                        {
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(cat)} {(DQ ($ VSub_DollarName '$state_dir')) (/head-name)})
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [300 307]
                          )
                        }
                      spids: [299]
                    )
                  ]
                  spids: [299]
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:onto spids:[312])
                      op: Equal
                      rhs: 
                        {
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [(C {(cat)} {(DQ ($ VSub_DollarName '$state_dir')) (/onto)})]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [313 320]
                          )
                        }
                      spids: [312]
                    )
                  ]
                  spids: [312]
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: [(C {(test)} {(-f)} {(DQ ($ VSub_DollarName '$state_dir')) (/orig-head)})]
                      action: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:orig_head spids:[352])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(cat)} 
                                            {(DQ ($ VSub_DollarName '$state_dir')) (/orig-head)}
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [353 360]
                                  )
                                }
                              spids: [352]
                            )
                          ]
                          spids: [352]
                        )
                      ]
                      spids: [16777215 349]
                    )
                  ]
                  else_action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:orig_head spids:[366])
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(cat)} {(DQ ($ VSub_DollarName '$state_dir')) (/head)})
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [367 374]
                              )
                            }
                          spids: [366]
                        )
                      ]
                      spids: [366]
                    )
                  ]
                  spids: [363 377]
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:GIT_QUIET spids:[382])
                      op: Equal
                      rhs: 
                        {
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [(C {(cat)} {(DQ ($ VSub_DollarName '$state_dir')) (/quiet)})]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [383 390]
                          )
                        }
                      spids: [382]
                    )
                  ]
                  spids: [382]
                )
                (C {(test)} {(-f)} {(DQ ($ VSub_DollarName '$state_dir')) (/verbose)})
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:verbose spids:[406])
                      op: Equal
                      rhs: {(t)}
                      spids: [406]
                    )
                  ]
                  spids: [406]
                )
              ]
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-f)} {(DQ ($ VSub_DollarName '$state_dir')) (/strategy)})
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:strategy spids:[421])
                      op: Equal
                      rhs: 
                        {
                          (DQ 
                            (word_part.CommandSubPart
                              command_list: 
                                (command.CommandList
                                  children: [
                                    (C {(cat)} {(DQ ($ VSub_DollarName '$state_dir')) (/strategy)})
                                  ]
                                )
                              left_token: <Left_CommandSub '$('>
                              spids: [423 430]
                            )
                          )
                        }
                      spids: [421]
                    )
                  ]
                  spids: [421]
                )
              ]
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-f)} {(DQ ($ VSub_DollarName '$state_dir')) (/strategy_opts)})
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:strategy_opts spids:[446])
                      op: Equal
                      rhs: 
                        {
                          (DQ 
                            (word_part.CommandSubPart
                              command_list: 
                                (command.CommandList
                                  children: [
                                    (C {(cat)} {(DQ ($ VSub_DollarName '$state_dir')) (/strategy_opts)})
                                  ]
                                )
                              left_token: <Left_CommandSub '$('>
                              spids: [448 455]
                            )
                          )
                        }
                      spids: [446]
                    )
                  ]
                  spids: [446]
                )
              ]
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-f)} {(DQ ($ VSub_DollarName '$state_dir')) (/allow_rerere_autoupdate)})
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:allow_rerere_autoupdate spids:[471])
                      op: Equal
                      rhs: 
                        {
                          (DQ 
                            (word_part.CommandSubPart
                              command_list: 
                                (command.CommandList
                                  children: [
                                    (C {(cat)} 
                                      {(DQ ($ VSub_DollarName '$state_dir')) 
                                        (/allow_rerere_autoupdate)
                                      }
                                    )
                                  ]
                                )
                              left_token: <Left_CommandSub '$('>
                              spids: [473 480]
                            )
                          )
                        }
                      spids: [471]
                    )
                  ]
                  spids: [471]
                )
              ]
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-f)} {(DQ ($ VSub_DollarName '$state_dir')) (/gpg_sign_opt)})
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:gpg_sign_opt spids:[496])
                      op: Equal
                      rhs: 
                        {
                          (DQ 
                            (word_part.CommandSubPart
                              command_list: 
                                (command.CommandList
                                  children: [
                                    (C {(cat)} {(DQ ($ VSub_DollarName '$state_dir')) (/gpg_sign_opt)})
                                  ]
                                )
                              left_token: <Left_CommandSub '$('>
                              spids: [498 505]
                            )
                          )
                        }
                      spids: [496]
                    )
                  ]
                  spids: [496]
                )
              ]
            )
          ]
          spids: [272]
        )
      spids: [267 271]
    )
    (command.FuncDef
      name: write_basic_state
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DAmp Op_DAmp Op_DAmp Op_DAmp Op_DAmp]
              children: [
                (command.SimpleCommand
                  words: [{(echo)} {(DQ ($ VSub_DollarName '$head_name'))}]
                  redirects: [
                    (redir.Redir
                      op: <Redir_Great '>'>
                      fd: 16777215
                      arg_word: {(DQ ($ VSub_DollarName '$state_dir')) (/head-name)}
                    )
                  ]
                )
                (command.SimpleCommand
                  words: [{(echo)} {(DQ ($ VSub_DollarName '$onto'))}]
                  redirects: [
                    (redir.Redir
                      op: <Redir_Great '>'>
                      fd: 16777215
                      arg_word: {(DQ ($ VSub_DollarName '$state_dir')) (/onto)}
                    )
                  ]
                )
                (command.SimpleCommand
                  words: [{(echo)} {(DQ ($ VSub_DollarName '$orig_head'))}]
                  redirects: [
                    (redir.Redir
                      op: <Redir_Great '>'>
                      fd: 16777215
                      arg_word: {(DQ ($ VSub_DollarName '$state_dir')) (/orig-head)}
                    )
                  ]
                )
                (command.SimpleCommand
                  words: [{(echo)} {(DQ ($ VSub_DollarName '$GIT_QUIET'))}]
                  redirects: [
                    (redir.Redir
                      op: <Redir_Great '>'>
                      fd: 16777215
                      arg_word: {(DQ ($ VSub_DollarName '$state_dir')) (/quiet)}
                    )
                  ]
                )
                (C {(test)} {(t)} {(Lit_Other '=')} {(DQ ($ VSub_DollarName '$verbose'))})
                (command.SimpleCommand
                  words: [{(Lit_Other ':')}]
                  redirects: [
                    (redir.Redir
                      op: <Redir_Great '>'>
                      fd: 16777215
                      arg_word: {(DQ ($ VSub_DollarName '$state_dir')) (/verbose)}
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$strategy'))})
                (command.SimpleCommand
                  words: [{(echo)} {(DQ ($ VSub_DollarName '$strategy'))}]
                  redirects: [
                    (redir.Redir
                      op: <Redir_Great '>'>
                      fd: 16777215
                      arg_word: {(DQ ($ VSub_DollarName '$state_dir')) (/strategy)}
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$strategy_opts'))})
                (command.SimpleCommand
                  words: [{(echo)} {(DQ ($ VSub_DollarName '$strategy_opts'))}]
                  redirects: [
                    (redir.Redir
                      op: <Redir_Great '>'>
                      fd: 16777215
                      arg_word: {(DQ ($ VSub_DollarName '$state_dir')) (/strategy_opts)}
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$allow_rerere_autoupdate'))})
                (command.SimpleCommand
                  words: [{(echo)} {(DQ ($ VSub_DollarName '$allow_rerere_autoupdate'))}]
                  redirects: [
                    (redir.Redir
                      op: <Redir_Great '>'>
                      fd: 16777215
                      arg_word: {(DQ ($ VSub_DollarName '$state_dir')) (/allow_rerere_autoupdate)}
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$gpg_sign_opt'))})
                (command.SimpleCommand
                  words: [{(echo)} {(DQ ($ VSub_DollarName '$gpg_sign_opt'))}]
                  redirects: [
                    (redir.Redir
                      op: <Redir_Great '>'>
                      fd: 16777215
                      arg_word: {(DQ ($ VSub_DollarName '$state_dir')) (/gpg_sign_opt)}
                    )
                  ]
                )
              ]
            )
          ]
          spids: [516]
        )
      spids: [511 515]
    )
    (command.FuncDef
      name: output
      body: 
        (command.BraceGroup
          children: [
            (command.Case
              to_match: {(DQ ($ VSub_DollarName '$verbose'))}
              arms: [
                (case_arm
                  pat_list: [{(SQ )}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:output spids:[729])
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (command.SimpleCommand
                                        words: [{(DQ ($ VSub_At '$@'))}]
                                        redirects: [
                                          (redir.Redir
                                            op: <Redir_GreatAnd '2>&'>
                                            fd: 2
                                            arg_word: {(1)}
                                          )
                                        ]
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [730 738]
                              )
                            }
                          spids: [729]
                        )
                      ]
                      spids: [729]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:status spids:[741])
                          op: Equal
                          rhs: {($ VSub_QMark '$?')}
                          spids: [741]
                        )
                      ]
                      spids: [741]
                    )
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {($ VSub_DollarName '$status')} {(KW_Bang '!') (Lit_Other '=')} {(0)})
                        (C {(printf)} {(DQ ('%s') (Lit_Other '\\') (n))} 
                          {(DQ ($ VSub_DollarName '$output'))}
                        )
                      ]
                    )
                    (command.ControlFlow
                      token: <ControlFlow_Return return>
                      arg_word: {($ VSub_DollarName '$status')}
                    )
                  ]
                  spids: [724 726 774 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [(C {(DQ ($ VSub_At '$@'))})]
                  spids: [777 778 786 16777215]
                )
              ]
              spids: [715 721 789]
            )
          ]
          spids: [712]
        )
      spids: [707 711]
    )
    (command.FuncDef
      name: move_to_original_branch
      body: 
        (command.BraceGroup
          children: [
            (command.Case
              to_match: {(DQ ($ VSub_DollarName '$head_name'))}
              arms: [
                (case_arm
                  pat_list: [{(refs/) (Lit_Other '*')}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:message spids:[816])
                          op: Equal
                          rhs: 
                            {
                              (DQ ('rebase finished: ') ($ VSub_DollarName '$head_name') (' onto ') 
                                ($ VSub_DollarName '$onto')
                              )
                            }
                          spids: [816]
                        )
                      ]
                      spids: [816]
                    )
                    (command.AndOr
                      ops: [Op_DAmp Op_DPipe]
                      children: [
                        (C {(git)} {(update-ref)} {(-m)} {(DQ ($ VSub_DollarName '$message'))} 
                          {($ VSub_DollarName '$head_name')} 
                          {
                            (word_part.CommandSubPart
                              command_list: 
                                (command.CommandList
                                  children: [(C {(git)} {(rev-parse)} {(HEAD)})]
                                )
                              left_token: <Left_CommandSub '$('>
                              spids: [839 845]
                            )
                          } {($ VSub_DollarName '$orig_head')}
                        )
                        (C {(git)} {(symbolic-ref)} {(-m)} 
                          {(DQ ('rebase finished: returning to ') ($ VSub_DollarName '$head_name'))} {(HEAD)} {($ VSub_DollarName '$head_name')}
                        )
                        (C {(die)} 
                          {
                            (DQ 
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(eval_gettext)} 
                                        {
                                          (DQ ('Could not move back to ') 
                                            (word_part.EscapedLiteralPart
                                              token: <Lit_EscapedChar '\\$'>
                                            ) (head_name)
                                          )
                                        }
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [877 885]
                              )
                            )
                          }
                        )
                      ]
                    )
                  ]
                  spids: [811 813 889 16777215]
                )
              ]
              spids: [802 808 892]
            )
          ]
          spids: [799]
        )
      spids: [794 798]
    )
    (command.FuncDef
      name: apply_autostash
      body: 
        (command.BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-f)} {(DQ ($ VSub_DollarName '$state_dir') (/autostash))})]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:stash_sha1 spids:[920])
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(cat)} {(DQ ($ VSub_DollarName '$state_dir') (/autostash))})
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [921 928]
                              )
                            }
                          spids: [920]
                        )
                      ]
                      spids: [920]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.SimpleCommand
                              words: [{(git)} {(stash)} {(apply)} {($ VSub_DollarName '$stash_sha1')}]
                              redirects: [
                                (redir.Redir
                                  op: <Redir_GreatAnd '2>&'>
                                  fd: 2
                                  arg_word: {(1)}
                                )
                                (redir.Redir
                                  op: <Redir_Great '>'>
                                  fd: 16777215
                                  arg_word: {(/dev/null)}
                                )
                              ]
                            )
                          ]
                          action: [
                            (C {(echo)} 
                              {
                                (DQ 
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [(C {(gettext)} {(SQ <'Applied autostash.'>)})]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [954 960]
                                  )
                                )
                              }
                            )
                          ]
                          spids: [16777215 948]
                        )
                      ]
                      else_action: [
                        (command.AndOr
                          ops: [Op_DPipe]
                          children: [
                            (C {(git)} {(stash)} {(store)} {(-m)} {(DQ (autostash))} {(-q)} 
                              {($ VSub_DollarName '$stash_sha1')}
                            )
                            (C {(die)} 
                              {
                                (DQ 
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(eval_gettext)} 
                                            {
                                              (DQ ('Cannot store ') 
                                                (word_part.EscapedLiteralPart
                                                  token: <Lit_EscapedChar '\\$'>
                                                ) (stash_sha1)
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [989 997]
                                  )
                                )
                              }
                            )
                          ]
                        )
                        (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: [964 1010]
                    )
                  ]
                  spids: [16777215 917]
                )
              ]
              spids: [16777215 1013]
            )
          ]
          spids: [902]
        )
      spids: [897 901]
    )
    (command.FuncDef
      name: finish_rebase
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DAmp Op_DAmp]
              children: [
                (C {(apply_autostash)})
                (command.BraceGroup
                  children: [
                    (command.Sentence
                      child: 
                        (command.AndOr
                          ops: [Op_DPipe]
                          children: [(C {(git)} {(gc)} {(--auto)}) (C {(true)})]
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  spids: [1031]
                )
                (C {(rm)} {(-rf)} {(DQ ($ VSub_DollarName '$state_dir'))})
              ]
            )
          ]
          spids: [1023]
        )
      spids: [1018 1022]
    )
    (command.FuncDef
      name: run_specific_rebase
      body: 
        (command.BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (C {(Lit_Other '[')} {(DQ ($ VSub_DollarName '$interactive_rebase'))} 
                          {(Lit_Other '=')} {(implied)} {(Lit_Other ']')}
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:GIT_EDITOR spids:[1086])
                          op: Equal
                          rhs: {(Lit_Other ':')}
                          spids: [1086]
                        )
                      ]
                      spids: [1086]
                    )
                    (C {(export)} {(GIT_EDITOR)})
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:autosquash spids:[1095])
                          op: Equal
                          rhs: (word.EmptyWord)
                          spids: [1095]
                        )
                      ]
                      spids: [1095]
                    )
                  ]
                  spids: [16777215 1083]
                )
              ]
              spids: [16777215 1098]
            )
            (C {(.)} {(git-rebase--) ($ VSub_DollarName '$type')})
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:ret spids:[1107])
                  op: Equal
                  rhs: {($ VSub_QMark '$?')}
                  spids: [1107]
                )
              ]
              spids: [1107]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {($ VSub_DollarName '$ret')} {(-eq)} {(0)})]
                  action: [(C {(finish_rebase)})]
                  spids: [16777215 1122]
                )
                (if_arm
                  cond: [(C {(test)} {($ VSub_DollarName '$ret')} {(-eq)} {(2)})]
                  action: [
                    (command.AndOr
                      ops: [Op_DAmp Op_DAmp]
                      children: [
                        (C {(apply_autostash)})
                        (C {(rm)} {(-rf)} {(DQ ($ VSub_DollarName '$state_dir'))})
                        (C {(die)} {(DQ ('Nothing to do'))})
                      ]
                    )
                  ]
                  spids: [1128 1142]
                )
              ]
              spids: [16777215 1168]
            )
            (command.ControlFlow
              token: <ControlFlow_Exit exit>
              arg_word: {($ VSub_DollarName '$ret')}
            )
          ]
          spids: [1065]
        )
      spids: [1060 1064]
    )
    (command.FuncDef
      name: run_pre_rebase_hook
      body: 
        (command.BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$ok_to_skip_pre_rebase'))})
                        (C {(test)} {(-x)} 
                          {
                            (DQ 
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(git)} {(rev-parse)} {(--git-path)} {(hooks/pre-rebase)})
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [1204 1212]
                              )
                            )
                          }
                        )
                      ]
                    )
                  ]
                  action: [
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C 
                          {
                            (DQ 
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(git)} {(rev-parse)} {(--git-path)} {(hooks/pre-rebase)})
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [1220 1228]
                              )
                            )
                          } 
                          {
                            (word_part.BracedVarSub
                              token: <VSub_Number 1>
                              suffix_op: 
                                (suffix_op.StringUnary
                                  op_id: VTest_Plus
                                  arg_word: {(DQ ($ VSub_At '$@'))}
                                )
                              spids: [1231 1237]
                            )
                          }
                        )
                        (C {(die)} 
                          {
                            (DQ 
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(gettext)} {(DQ ('The pre-rebase hook refused to rebase.'))})
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [1245 1251]
                              )
                            )
                          }
                        )
                      ]
                    )
                  ]
                  spids: [16777215 1216]
                )
              ]
              spids: [16777215 1255]
            )
          ]
          spids: [1183]
        )
      spids: [1178 1182]
    )
    (command.AndOr
      ops: [Op_DAmp]
      children: [
        (C {(test)} {(-f)} {(DQ ($ VSub_DollarName '$apply_dir')) (/applying)})
        (C {(die)} 
          {
            (DQ 
              (word_part.CommandSubPart
                command_list: 
                  (command.CommandList
                    children: [
                      (C {(gettext)} {(DQ ('It looks like git-am is in progress. Cannot rebase.'))})
                    ]
                  )
                left_token: <Left_CommandSub '$('>
                spids: [1275 1281]
              )
            )
          }
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-d)} {(DQ ($ VSub_DollarName '$apply_dir'))})]
          action: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:type spids:[1298])
                  op: Equal
                  rhs: {(am)}
                  spids: [1298]
                )
              ]
              spids: [1298]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:state_dir spids:[1302])
                  op: Equal
                  rhs: {(DQ ($ VSub_DollarName '$apply_dir'))}
                  spids: [1302]
                )
              ]
              spids: [1302]
            )
          ]
          spids: [16777215 1295]
        )
        (if_arm
          cond: [(C {(test)} {(-d)} {(DQ ($ VSub_DollarName '$merge_dir'))})]
          action: [
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-f)} {(DQ ($ VSub_DollarName '$merge_dir')) (/interactive)})]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:type spids:[1335])
                          op: Equal
                          rhs: {(interactive)}
                          spids: [1335]
                        )
                      ]
                      spids: [1335]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:interactive_rebase spids:[1339])
                          op: Equal
                          rhs: {(explicit)}
                          spids: [1339]
                        )
                      ]
                      spids: [1339]
                    )
                  ]
                  spids: [16777215 1332]
                )
              ]
              else_action: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:type spids:[1346])
                      op: Equal
                      rhs: {(merge)}
                      spids: [1346]
                    )
                  ]
                  spids: [1346]
                )
              ]
              spids: [1343 1350]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:state_dir spids:[1353])
                  op: Equal
                  rhs: {(DQ ($ VSub_DollarName '$merge_dir'))}
                  spids: [1353]
                )
              ]
              spids: [1353]
            )
          ]
          spids: [1307 1317]
        )
      ]
      spids: [16777215 1358]
    )
    (command.AndOr
      ops: [Op_DAmp]
      children: [
        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$type'))})
        (command.Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (lhs_expr.LhsName name:in_progress spids:[1370])
              op: Equal
              rhs: {(t)}
              spids: [1370]
            )
          ]
          spids: [1370]
        )
      ]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:total_argc spids:[1374])
          op: Equal
          rhs: {($ VSub_Pound '$#')}
          spids: [1374]
        )
      ]
      spids: [1374]
    )
    (command.WhileUntil
      keyword: <KW_While while>
      cond: [(C {(test)} {($ VSub_Pound '$#')} {(KW_Bang '!') (Lit_Other '=')} {(0)})]
      body: 
        (command.DoGroup
          children: [
            (command.Case
              to_match: {(DQ ($ VSub_Number '$1'))}
              arms: [
                (case_arm
                  pat_list: [{(--no-verify)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:ok_to_skip_pre_rebase spids:[1404])
                          op: Equal
                          rhs: {(yes)}
                          spids: [1404]
                        )
                      ]
                      spids: [1404]
                    )
                  ]
                  spids: [1400 1401 1408 16777215]
                )
                (case_arm
                  pat_list: [{(--verify)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:ok_to_skip_pre_rebase spids:[1415])
                          op: Equal
                          rhs: (word.EmptyWord)
                          spids: [1415]
                        )
                      ]
                      spids: [1415]
                    )
                  ]
                  spids: [1411 1412 1418 16777215]
                )
                (case_arm
                  pat_list: [{(--continue)} {(--skip)} {(--abort)} {(--edit-todo)}]
                  action: [
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(test)} {($ VSub_DollarName '$total_argc')} {(-eq)} {(2)})
                        (C {(usage)})
                      ]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:action spids:[1444])
                          op: Equal
                          rhs: 
                            {
                              (word_part.BracedVarSub
                                token: <VSub_Number 1>
                                suffix_op: (suffix_op.StringUnary op_id:VOp1_DPound arg_word:{(--)})
                                spids: [1445 1449]
                              )
                            }
                          spids: [1444]
                        )
                      ]
                      spids: [1444]
                    )
                  ]
                  spids: [1421 1428 1452 16777215]
                )
                (case_arm
                  pat_list: [{(--onto) (Lit_Other '=') (Lit_Other '*')}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:onto spids:[1461])
                          op: Equal
                          rhs: 
                            {
                              (DQ 
                                (word_part.BracedVarSub
                                  token: <VSub_Number 1>
                                  suffix_op: 
                                    (suffix_op.StringUnary
                                      op_id: VOp1_Pound
                                      arg_word: {('--onto=')}
                                    )
                                  spids: [1463 1467]
                                )
                              )
                            }
                          spids: [1461]
                        )
                      ]
                      spids: [1461]
                    )
                  ]
                  spids: [1455 1458 1471 16777215]
                )
                (case_arm
                  pat_list: [{(--exec) (Lit_Other '=') (Lit_Other '*')}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:cmd spids:[1480])
                          op: Equal
                          rhs: 
                            {
                              (DQ (${ VSub_Name cmd) ('exec ') 
                                (word_part.BracedVarSub
                                  token: <VSub_Number 1>
                                  suffix_op: 
                                    (suffix_op.StringUnary
                                      op_id: VOp1_Pound
                                      arg_word: {('--exec=')}
                                    )
                                  spids: [1486 1490]
                                ) (${ VSub_Name LF)
                              )
                            }
                          spids: [1480]
                        )
                      ]
                      spids: [1480]
                    )
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$interactive_rebase'))})
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:interactive_rebase spids:[1507])
                              op: Equal
                              rhs: {(implied)}
                              spids: [1507]
                            )
                          ]
                          spids: [1507]
                        )
                      ]
                    )
                  ]
                  spids: [1474 1477 1511 16777215]
                )
                (case_arm
                  pat_list: [{(--interactive)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:interactive_rebase spids:[1518])
                          op: Equal
                          rhs: {(explicit)}
                          spids: [1518]
                        )
                      ]
                      spids: [1518]
                    )
                  ]
                  spids: [1514 1515 1522 16777215]
                )
                (case_arm
                  pat_list: [{(--keep-empty)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:keep_empty spids:[1529])
                          op: Equal
                          rhs: {(yes)}
                          spids: [1529]
                        )
                      ]
                      spids: [1529]
                    )
                  ]
                  spids: [1525 1526 1533 16777215]
                )
                (case_arm
                  pat_list: [{(--preserve-merges)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:preserve_merges spids:[1540])
                          op: Equal
                          rhs: {(t)}
                          spids: [1540]
                        )
                      ]
                      spids: [1540]
                    )
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$interactive_rebase'))})
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:interactive_rebase spids:[1554])
                              op: Equal
                              rhs: {(implied)}
                              spids: [1554]
                            )
                          ]
                          spids: [1554]
                        )
                      ]
                    )
                  ]
                  spids: [1536 1537 1558 16777215]
                )
                (case_arm
                  pat_list: [{(--autosquash)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:autosquash spids:[1565])
                          op: Equal
                          rhs: {(t)}
                          spids: [1565]
                        )
                      ]
                      spids: [1565]
                    )
                  ]
                  spids: [1561 1562 1569 16777215]
                )
                (case_arm
                  pat_list: [{(--no-autosquash)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:autosquash spids:[1576])
                          op: Equal
                          rhs: (word.EmptyWord)
                          spids: [1576]
                        )
                      ]
                      spids: [1576]
                    )
                  ]
                  spids: [1572 1573 1579 16777215]
                )
                (case_arm
                  pat_list: [{(--fork-point)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:fork_point spids:[1586])
                          op: Equal
                          rhs: {(t)}
                          spids: [1586]
                        )
                      ]
                      spids: [1586]
                    )
                  ]
                  spids: [1582 1583 1590 16777215]
                )
                (case_arm
                  pat_list: [{(--no-fork-point)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:fork_point spids:[1597])
                          op: Equal
                          rhs: (word.EmptyWord)
                          spids: [1597]
                        )
                      ]
                      spids: [1597]
                    )
                  ]
                  spids: [1593 1594 1600 16777215]
                )
                (case_arm
                  pat_list: [{(--merge)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:do_merge spids:[1607])
                          op: Equal
                          rhs: {(t)}
                          spids: [1607]
                        )
                      ]
                      spids: [1607]
                    )
                  ]
                  spids: [1603 1604 1611 16777215]
                )
                (case_arm
                  pat_list: [{(--strategy-option) (Lit_Other '=') (Lit_Other '*')}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:strategy_opts spids:[1620])
                          op: Equal
                          rhs: 
                            {
                              (DQ ($ VSub_DollarName '$strategy_opts') (' ') 
                                (word_part.CommandSubPart
                                  command_list: 
                                    (command.CommandList
                                      children: [
                                        (C {(git)} {(rev-parse)} {(--sq-quote)} 
                                          {
                                            (DQ (--) 
                                              (word_part.BracedVarSub
                                                token: <VSub_Number 1>
                                                suffix_op: 
                                                  (suffix_op.StringUnary
                                                    op_id: VOp1_Pound
                                                    arg_word: {('--strategy-option=')}
                                                  )
                                                spids: [1633 1637]
                                              )
                                            )
                                          }
                                        )
                                      ]
                                    )
                                  left_token: <Left_CommandSub '$('>
                                  spids: [1624 1639]
                                )
                              )
                            }
                          spids: [1620]
                        )
                      ]
                      spids: [1620]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:do_merge spids:[1643])
                          op: Equal
                          rhs: {(t)}
                          spids: [1643]
                        )
                      ]
                      spids: [1643]
                    )
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$strategy'))})
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:strategy spids:[1657])
                              op: Equal
                              rhs: {(recursive)}
                              spids: [1657]
                            )
                          ]
                          spids: [1657]
                        )
                      ]
                    )
                  ]
                  spids: [1614 1617 1661 16777215]
                )
                (case_arm
                  pat_list: [{(--strategy) (Lit_Other '=') (Lit_Other '*')}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:strategy spids:[1670])
                          op: Equal
                          rhs: 
                            {
                              (DQ 
                                (word_part.BracedVarSub
                                  token: <VSub_Number 1>
                                  suffix_op: 
                                    (suffix_op.StringUnary
                                      op_id: VOp1_Pound
                                      arg_word: {('--strategy=')}
                                    )
                                  spids: [1672 1676]
                                )
                              )
                            }
                          spids: [1670]
                        )
                      ]
                      spids: [1670]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:do_merge spids:[1680])
                          op: Equal
                          rhs: {(t)}
                          spids: [1680]
                        )
                      ]
                      spids: [1680]
                    )
                  ]
                  spids: [1664 1667 1684 16777215]
                )
                (case_arm
                  pat_list: [{(--no-stat)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:diffstat spids:[1691])
                          op: Equal
                          rhs: (word.EmptyWord)
                          spids: [1691]
                        )
                      ]
                      spids: [1691]
                    )
                  ]
                  spids: [1687 1688 1694 16777215]
                )
                (case_arm
                  pat_list: [{(--stat)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:diffstat spids:[1701])
                          op: Equal
                          rhs: {(t)}
                          spids: [1701]
                        )
                      ]
                      spids: [1701]
                    )
                  ]
                  spids: [1697 1698 1705 16777215]
                )
                (case_arm
                  pat_list: [{(--autostash)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:autostash spids:[1712])
                          op: Equal
                          rhs: {(true)}
                          spids: [1712]
                        )
                      ]
                      spids: [1712]
                    )
                  ]
                  spids: [1708 1709 1716 16777215]
                )
                (case_arm
                  pat_list: [{(--no-autostash)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:autostash spids:[1723])
                          op: Equal
                          rhs: {(false)}
                          spids: [1723]
                        )
                      ]
                      spids: [1723]
                    )
                  ]
                  spids: [1719 1720 1727 16777215]
                )
                (case_arm
                  pat_list: [{(--verbose)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:verbose spids:[1734])
                          op: Equal
                          rhs: {(t)}
                          spids: [1734]
                        )
                      ]
                      spids: [1734]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:diffstat spids:[1738])
                          op: Equal
                          rhs: {(t)}
                          spids: [1738]
                        )
                      ]
                      spids: [1738]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:GIT_QUIET spids:[1742])
                          op: Equal
                          rhs: (word.EmptyWord)
                          spids: [1742]
                        )
                      ]
                      spids: [1742]
                    )
                  ]
                  spids: [1730 1731 1745 16777215]
                )
                (case_arm
                  pat_list: [{(--quiet)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:GIT_QUIET spids:[1752])
                          op: Equal
                          rhs: {(t)}
                          spids: [1752]
                        )
                      ]
                      spids: [1752]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:git_am_opt spids:[1756])
                          op: Equal
                          rhs: {(DQ ($ VSub_DollarName '$git_am_opt') (' -q'))}
                          spids: [1756]
                        )
                      ]
                      spids: [1756]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:verbose spids:[1763])
                          op: Equal
                          rhs: (word.EmptyWord)
                          spids: [1763]
                        )
                      ]
                      spids: [1763]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:diffstat spids:[1766])
                          op: Equal
                          rhs: (word.EmptyWord)
                          spids: [1766]
                        )
                      ]
                      spids: [1766]
                    )
                  ]
                  spids: [1748 1749 1769 16777215]
                )
                (case_arm
                  pat_list: [{(--whitespace) (Lit_Other '=') (Lit_Other '*')}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:git_am_opt spids:[1778])
                          op: Equal
                          rhs: 
                            {
                              (DQ ($ VSub_DollarName '$git_am_opt') (' --whitespace=') 
                                (word_part.BracedVarSub
                                  token: <VSub_Number 1>
                                  suffix_op: 
                                    (suffix_op.StringUnary
                                      op_id: VOp1_Pound
                                      arg_word: {('--whitespace=')}
                                    )
                                  spids: [1782 1786]
                                )
                              )
                            }
                          spids: [1778]
                        )
                      ]
                      spids: [1778]
                    )
                    (command.Case
                      to_match: 
                        {
                          (DQ 
                            (word_part.BracedVarSub
                              token: <VSub_Number 1>
                              suffix_op: 
                                (suffix_op.StringUnary
                                  op_id: VOp1_Pound
                                  arg_word: {('--whitespace=')}
                                )
                              spids: [1793 1797]
                            )
                          )
                        }
                      arms: [
                        (case_arm
                          pat_list: [{(fix)} {(strip)}]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:force_rebase spids:[1809])
                                  op: Equal
                                  rhs: {(t)}
                                  spids: [1809]
                                )
                              ]
                              spids: [1809]
                            )
                          ]
                          spids: [1803 1806 1813 16777215]
                        )
                      ]
                      spids: [1790 1800 1816]
                    )
                  ]
                  spids: [1772 1775 1819 16777215]
                )
                (case_arm
                  pat_list: [{(--ignore-whitespace)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:git_am_opt spids:[1826])
                          op: Equal
                          rhs: {(DQ ($ VSub_DollarName '$git_am_opt') (' ') ($ VSub_Number '$1'))}
                          spids: [1826]
                        )
                      ]
                      spids: [1826]
                    )
                  ]
                  spids: [1822 1823 1834 16777215]
                )
                (case_arm
                  pat_list: [{(--committer-date-is-author-date)} {(--ignore-date)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:git_am_opt spids:[1843])
                          op: Equal
                          rhs: {(DQ ($ VSub_DollarName '$git_am_opt') (' ') ($ VSub_Number '$1'))}
                          spids: [1843]
                        )
                      ]
                      spids: [1843]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:force_rebase spids:[1851])
                          op: Equal
                          rhs: {(t)}
                          spids: [1851]
                        )
                      ]
                      spids: [1851]
                    )
                  ]
                  spids: [1837 1840 1855 16777215]
                )
                (case_arm
                  pat_list: [{(-C) (Lit_Other '*')}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:git_am_opt spids:[1863])
                          op: Equal
                          rhs: {(DQ ($ VSub_DollarName '$git_am_opt') (' ') ($ VSub_Number '$1'))}
                          spids: [1863]
                        )
                      ]
                      spids: [1863]
                    )
                  ]
                  spids: [1858 1860 1871 16777215]
                )
                (case_arm
                  pat_list: [{(--root)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:rebase_root spids:[1878])
                          op: Equal
                          rhs: {(t)}
                          spids: [1878]
                        )
                      ]
                      spids: [1878]
                    )
                  ]
                  spids: [1874 1875 1882 16777215]
                )
                (case_arm
                  pat_list: [{(--force-rebase)} {(--no-ff)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:force_rebase spids:[1891])
                          op: Equal
                          rhs: {(t)}
                          spids: [1891]
                        )
                      ]
                      spids: [1891]
                    )
                  ]
                  spids: [1885 1888 1895 16777215]
                )
                (case_arm
                  pat_list: [{(--rerere-autoupdate)} {(--no-rerere-autoupdate)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:allow_rerere_autoupdate spids:[1904])
                          op: Equal
                          rhs: {(DQ ($ VSub_Number '$1'))}
                          spids: [1904]
                        )
                      ]
                      spids: [1904]
                    )
                  ]
                  spids: [1898 1901 1910 16777215]
                )
                (case_arm
                  pat_list: [{(--gpg-sign)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:gpg_sign_opt spids:[1917])
                          op: Equal
                          rhs: {(-S)}
                          spids: [1917]
                        )
                      ]
                      spids: [1917]
                    )
                  ]
                  spids: [1913 1914 1921 16777215]
                )
                (case_arm
                  pat_list: [{(--gpg-sign) (Lit_Other '=') (Lit_Other '*')}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:gpg_sign_opt spids:[1930])
                          op: Equal
                          rhs: 
                            {
                              (DQ (-S) 
                                (word_part.BracedVarSub
                                  token: <VSub_Number 1>
                                  suffix_op: 
                                    (suffix_op.StringUnary
                                      op_id: VOp1_Pound
                                      arg_word: {('--gpg-sign=')}
                                    )
                                  spids: [1933 1937]
                                )
                              )
                            }
                          spids: [1930]
                        )
                      ]
                      spids: [1930]
                    )
                  ]
                  spids: [1924 1927 1941 16777215]
                )
                (case_arm
                  pat_list: [{(--)}]
                  action: [(C {(shift)}) (command.ControlFlow token:<ControlFlow_Break break>)]
                  spids: [1944 1945 1954 16777215]
                )
              ]
              spids: [1391 1397 1957]
            )
            (C {(shift)})
          ]
          spids: [1388 1962]
        )
    )
    (command.AndOr
      ops: [Op_DAmp]
      children: [(C {(test)} {($ VSub_Pound '$#')} {(-gt)} {(2)}) (C {(usage)})]
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$action'))})]
          action: [
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$in_progress'))})
                (C {(die)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [(C {(gettext)} {(DQ ('No rebase in progress?'))})]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [2003 2009]
                      )
                    )
                  }
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(DQ ($ VSub_DollarName '$type'))} {(Lit_Other '=')} {(interactive)})
                        (C {(test)} {(DQ ($ VSub_DollarName '$GIT_REFLOG_ACTION'))} {(Lit_Other '=')} 
                          {(rebase)}
                        )
                      ]
                    )
                  ]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:GIT_REFLOG_ACTION spids:[2045])
                          op: Equal
                          rhs: {(DQ ('rebase -i (') ($ VSub_DollarName '$action') (')'))}
                          spids: [2045]
                        )
                      ]
                      spids: [2045]
                    )
                    (C {(export)} {(GIT_REFLOG_ACTION)})
                  ]
                  spids: [16777215 2042]
                )
              ]
              spids: [16777215 2058]
            )
          ]
          spids: [16777215 1987]
        )
      ]
      spids: [16777215 2060]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(DQ ($ VSub_DollarName '$action'))} {(Lit_Other '=')} {(DQ (edit-todo))})
                (C {(test)} {(DQ ($ VSub_DollarName '$type'))} {(KW_Bang '!') (Lit_Other '=')} 
                  {(DQ (interactive))}
                )
              ]
            )
          ]
          action: [
            (C {(die)} 
              {
                (DQ 
                  (word_part.CommandSubPart
                    command_list: 
                      (command.CommandList
                        children: [
                          (C {(gettext)} 
                            {
                              (DQ 
                                (
'The --edit-todo action can only be used during interactive rebase.'
                                )
                              )
                            }
                          )
                        ]
                      )
                    left_token: <Left_CommandSub '$('>
                    spids: [2098 2104]
                  )
                )
              }
            )
          ]
          spids: [16777215 2092]
        )
      ]
      spids: [16777215 2107]
    )
    (command.Case
      to_match: {(DQ ($ VSub_DollarName '$action'))}
      arms: [
        (case_arm
          pat_list: [{(ControlFlow_Continue continue)}]
          action: [
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (command.SimpleCommand
                  words: [{(git)} {(rev-parse)} {(--verify)} {(HEAD)}]
                  redirects: [(redir.Redir op:<Redir_Great '>'> fd:16777215 arg_word:{(/dev/null)})]
                )
                (C {(die)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [(C {(gettext)} {(DQ ('Cannot read HEAD'))})]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [2143 2149]
                      )
                    )
                  }
                )
              ]
            )
            (command.AndOr
              ops: [Op_DAmp Op_DPipe]
              children: [
                (C {(git)} {(update-index)} {(--ignore-submodules)} {(--refresh)})
                (C {(git)} {(diff-files)} {(--quiet)} {(--ignore-submodules)})
                (command.BraceGroup
                  children: [
                    (C {(echo)} 
                      {
                        (DQ 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(gettext)} 
                                    {
                                      (DQ ('You must edit all merge conflicts and then\n') 
                                        ('mark them as resolved using git add')
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [2180 2187]
                          )
                        )
                      }
                    )
                    (command.ControlFlow
                      token: <ControlFlow_Exit exit>
                      arg_word: {(1)}
                    )
                  ]
                  spids: [2174]
                )
              ]
            )
            (C {(read_basic_state)})
            (C {(run_specific_rebase)})
          ]
          spids: [2118 2119 2205 16777215]
        )
        (case_arm
          pat_list: [{(skip)}]
          action: [
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(output)} {(git)} {(reset)} {(--hard)} {(HEAD)})
                (command.ControlFlow
                  token: <ControlFlow_Exit exit>
                  arg_word: {($ VSub_QMark '$?')}
                )
              ]
            )
            (C {(read_basic_state)})
            (C {(run_specific_rebase)})
          ]
          spids: [2207 2208 2234 16777215]
        )
        (case_arm
          pat_list: [{(abort)}]
          action: [
            (C {(git)} {(rerere)} {(clear)})
            (C {(read_basic_state)})
            (command.Case
              to_match: {(DQ ($ VSub_DollarName '$head_name'))}
              arms: [
                (case_arm
                  pat_list: [{(refs/) (Lit_Other '*')}]
                  action: [
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(git)} {(symbolic-ref)} {(-m)} {(DQ ('rebase: aborting'))} {(HEAD)} 
                          {($ VSub_DollarName '$head_name')}
                        )
                        (C {(die)} 
                          {
                            (DQ 
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(eval_gettext)} 
                                        {
                                          (DQ ('Could not move back to ') 
                                            (word_part.EscapedLiteralPart
                                              token: <Lit_EscapedChar '\\$'>
                                            ) (head_name)
                                          )
                                        }
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [2284 2292]
                              )
                            )
                          }
                        )
                      ]
                    )
                  ]
                  spids: [2259 2261 2296 16777215]
                )
              ]
              spids: [2250 2256 2299]
            )
            (C {(output)} {(git)} {(reset)} {(--hard)} {($ VSub_DollarName '$orig_head')})
            (C {(finish_rebase)})
            (command.ControlFlow token:<ControlFlow_Exit exit>)
          ]
          spids: [2236 2237 2319 16777215]
        )
        (case_arm
          pat_list: [{(edit-todo)}]
          action: [(C {(run_specific_rebase)})]
          spids: [2321 2322 2328 16777215]
        )
      ]
      spids: [2110 2116 2330]
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$in_progress'))})]
          action: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:state_dir_base spids:[2349])
                  op: Equal
                  rhs: 
                    {
                      (word_part.BracedVarSub
                        token: <VSub_Name state_dir>
                        suffix_op: 
                          (suffix_op.StringUnary
                            op_id: VOp1_DPound
                            arg_word: {('*') (Lit_Slash /)}
                          )
                        spids: [2350 2355]
                      )
                    }
                  spids: [2349]
                )
              ]
              spids: [2349]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:cmd_live_rebase spids:[2358])
                  op: Equal
                  rhs: {(DQ ('git rebase (--continue | --abort | --skip)'))}
                  spids: [2358]
                )
              ]
              spids: [2358]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:cmd_clear_stale_rebase spids:[2364])
                  op: Equal
                  rhs: 
                    {
                      (DQ ('rm -fr ') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\"'>) 
                        ($ VSub_DollarName '$state_dir') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\"'>)
                      )
                    }
                  spids: [2364]
                )
              ]
              spids: [2364]
            )
            (C {(die)} 
              {
                (DQ ('\n') 
                  (word_part.CommandSubPart
                    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.'>
                              )
                            }
                          )
                        ]
                      )
                    left_token: <Left_CommandSub '$('>
                    spids: [2377 2390]
                  )
                )
              }
            )
          ]
          spids: [16777215 2346]
        )
      ]
      spids: [16777215 2393]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$rebase_root'))})
                (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$onto'))})
              ]
            )
          ]
          action: [
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$interactive_rebase'))})
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:interactive_rebase spids:[2429])
                      op: Equal
                      rhs: {(implied)}
                      spids: [2429]
                    )
                  ]
                  spids: [2429]
                )
              ]
            )
          ]
          spids: [16777215 2416]
        )
      ]
      spids: [16777215 2432]
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$interactive_rebase'))})]
          action: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:type spids:[2448])
                  op: Equal
                  rhs: {(interactive)}
                  spids: [2448]
                )
              ]
              spids: [2448]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:state_dir spids:[2452])
                  op: Equal
                  rhs: {(DQ ($ VSub_DollarName '$merge_dir'))}
                  spids: [2452]
                )
              ]
              spids: [2452]
            )
          ]
          spids: [16777215 2445]
        )
        (if_arm
          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$do_merge'))})]
          action: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:type spids:[2470])
                  op: Equal
                  rhs: {(merge)}
                  spids: [2470]
                )
              ]
              spids: [2470]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:state_dir spids:[2474])
                  op: Equal
                  rhs: {(DQ ($ VSub_DollarName '$merge_dir'))}
                  spids: [2474]
                )
              ]
              spids: [2474]
            )
          ]
          spids: [2457 2467]
        )
      ]
      else_action: [
        (command.Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (lhs_expr.LhsName name:type spids:[2482])
              op: Equal
              rhs: {(am)}
              spids: [2482]
            )
          ]
          spids: [2482]
        )
        (command.Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (lhs_expr.LhsName name:state_dir spids:[2486])
              op: Equal
              rhs: {(DQ ($ VSub_DollarName '$apply_dir'))}
              spids: [2486]
            )
          ]
          spids: [2486]
        )
      ]
      spids: [2479 2491]
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$rebase_root'))})]
          action: [
            (command.Case
              to_match: {(DQ ($ VSub_Pound '$#'))}
              arms: [
                (case_arm
                  pat_list: [{(0)}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Pipeline
                              children: [
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:upstream_name spids:[2524])
                                      op: Equal
                                      rhs: 
                                        {
                                          (word_part.CommandSubPart
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (command.SimpleCommand
                                                    words: [
                                                      {(git)}
                                                      {(rev-parse)}
                                                      {(--symbolic-full-name)}
                                                      {(--verify)}
                                                      {(-q)}
                                                      {(Lit_Other '@') (Lit_LBrace '{') (upstream) 
                                                        (Lit_RBrace '}')
                                                      }
                                                    ]
                                                    redirects: [
                                                      (redir.Redir
                                                        op: <Redir_Great '2>'>
                                                        fd: 2
                                                        arg_word: {(/dev/null)}
                                                      )
                                                    ]
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub '$('>
                                            spids: [2525 2545]
                                          )
                                        }
                                      spids: [2524]
                                    )
                                  ]
                                  spids: [2524]
                                )
                              ]
                              negated: T
                            )
                          ]
                          action: [
                            (C {(.)} {(git-parse-remote)})
                            (C {(error_on_missing_default_upstream)} {(DQ (rebase))} {(DQ (rebase))} 
                              {(DQ (against))} 
                              {
                                (DQ ('git rebase ') 
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [(C {(gettext)} {(SQ <'<branch>'>)})]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [2574 2580]
                                  )
                                )
                              }
                            )
                          ]
                          spids: [16777215 2548]
                        )
                      ]
                      spids: [16777215 2584]
                    )
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(DQ ($ VSub_DollarName '$fork_point'))} {(Lit_Other '=')} {(auto)})
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:fork_point spids:[2600])
                              op: Equal
                              rhs: {(t)}
                              spids: [2600]
                            )
                          ]
                          spids: [2600]
                        )
                      ]
                    )
                  ]
                  spids: [2516 2517 2604 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:upstream_name spids:[2610])
                          op: Equal
                          rhs: {(DQ ($ VSub_Number '$1'))}
                          spids: [2610]
                        )
                      ]
                      spids: [2610]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (C {(test)} {(DQ ($ VSub_DollarName '$upstream_name'))} {(Lit_Other '=')} 
                              {(DQ (-))}
                            )
                          ]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:upstream_name spids:[2634])
                                  op: Equal
                                  rhs: {(DQ ('@{-1}'))}
                                  spids: [2634]
                                )
                              ]
                              spids: [2634]
                            )
                          ]
                          spids: [16777215 2631]
                        )
                      ]
                      spids: [16777215 2640]
                    )
                    (C {(shift)})
                  ]
                  spids: [2607 2608 2646 16777215]
                )
              ]
              spids: [2507 2513 2649]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:upstream spids:[2652])
                      op: Equal
                      rhs: 
                        {
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [(C {(peel_committish)} {(DQ (${ VSub_Name upstream_name))})]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [2653 2661]
                          )
                        }
                      spids: [2652]
                    )
                  ]
                  spids: [2652]
                )
                (C {(die)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {(eval_gettext)} 
                                {
                                  (DQ ('invalid upstream ') 
                                    (word_part.EscapedLiteralPart
                                      token: <Lit_EscapedChar '\\$'>
                                    ) (upstream_name)
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [2669 2677]
                      )
                    )
                  }
                )
              ]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:upstream_arg spids:[2681])
                  op: Equal
                  rhs: {(DQ ($ VSub_DollarName '$upstream_name'))}
                  spids: [2681]
                )
              ]
              spids: [2681]
            )
          ]
          spids: [16777215 2504]
        )
      ]
      else_action: [
        (command.If
          arms: [
            (if_arm
              cond: [(C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$onto'))})]
              action: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:empty_tree spids:[2703])
                      op: Equal
                      rhs: 
                        {
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [(C {(git)} {(hash-object)} {(-t)} {(tree)} {(/dev/null)})]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [2704 2714]
                          )
                        }
                      spids: [2703]
                    )
                  ]
                  spids: [2703]
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:onto spids:[2717])
                      op: Equal
                      rhs: 
                        {
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (command.SimpleCommand
                                    words: [{(git)} {(commit-tree)} {($ VSub_DollarName '$empty_tree')}]
                                    redirects: [
                                      (redir.Redir
                                        op: <Redir_Less '<'>
                                        fd: 16777215
                                        arg_word: {(/dev/null)}
                                      )
                                    ]
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [2718 2727]
                          )
                        }
                      spids: [2717]
                    )
                  ]
                  spids: [2717]
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:squash_onto spids:[2730])
                      op: Equal
                      rhs: {(DQ ($ VSub_DollarName '$onto'))}
                      spids: [2730]
                    )
                  ]
                  spids: [2730]
                )
              ]
              spids: [16777215 2700]
            )
          ]
          spids: [16777215 2736]
        )
        (C {(unset)} {(upstream_name)})
        (C {(unset)} {(upstream)})
        (command.AndOr
          ops: [Op_DAmp]
          children: [(C {(test)} {($ VSub_Pound '$#')} {(-gt)} {(1)}) (C {(usage)})]
        )
        (command.Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (lhs_expr.LhsName name:upstream_arg spids:[2762])
              op: Equal
              rhs: {(--root)}
              spids: [2762]
            )
          ]
          spids: [2762]
        )
      ]
      spids: [2686 2765]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:onto_name spids:[2771])
          op: Equal
          rhs: 
            {
              (word_part.BracedVarSub
                token: <VSub_Name onto>
                suffix_op: 
                  (suffix_op.StringUnary
                    op_id: VTest_Hyphen
                    arg_word: {(DQ ($ VSub_DollarName '$upstream_name'))}
                  )
                spids: [2772 2778]
              )
            }
          spids: [2771]
        )
      ]
      spids: [2771]
    )
    (command.Case
      to_match: {(DQ ($ VSub_DollarName '$onto_name'))}
      arms: [
        (case_arm
          pat_list: [{(Lit_Other '*') (...) (Lit_Other '*')}]
          action: [
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:left spids:[2796])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.BracedVarSub
                                    token: <VSub_Name onto_name>
                                    suffix_op: 
                                      (suffix_op.StringUnary
                                        op_id: VOp1_Percent
                                        arg_word: {('...*')}
                                      )
                                    spids: [2797 2801]
                                  )
                                }
                              spids: [2796]
                            )
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:right spids:[2803])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.BracedVarSub
                                    token: <VSub_Name onto_name>
                                    suffix_op: 
                                      (suffix_op.StringUnary
                                        op_id: VOp1_Pound
                                        arg_word: {('*...')}
                                      )
                                    spids: [2804 2808]
                                  )
                                }
                              spids: [2803]
                            )
                          ]
                          spids: [2796]
                        )
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:onto spids:[2813])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(git)} {(merge-base)} {(--all)} 
                                            {
                                              (word_part.BracedVarSub
                                                token: <VSub_Name left>
                                                suffix_op: 
                                                  (suffix_op.StringUnary
                                                    op_id: VTest_ColonHyphen
                                                    arg_word: {(HEAD)}
                                                  )
                                                spids: [2821 2825]
                                              )
                                            } 
                                            {
                                              (word_part.BracedVarSub
                                                token: <VSub_Name right>
                                                suffix_op: 
                                                  (suffix_op.StringUnary
                                                    op_id: VTest_ColonHyphen
                                                    arg_word: {(HEAD)}
                                                  )
                                                spids: [2827 2831]
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [2814 2832]
                                  )
                                }
                              spids: [2813]
                            )
                          ]
                          spids: [2813]
                        )
                      ]
                    )
                  ]
                  action: [
                    (command.Case
                      to_match: {(DQ ($ VSub_DollarName '$onto'))}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(Lit_Other '?') (Lit_Other '*') (DQ ($ VSub_DollarName '$LF')) 
                              (Lit_Other '?') (Lit_Other '*')
                            }
                          ]
                          action: [
                            (C {(die)} 
                              {
                                (DQ 
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(eval_gettext)} 
                                            {
                                              (DQ 
                                                (word_part.EscapedLiteralPart
                                                  token: <Lit_EscapedChar '\\$'>
                                                ) ('onto_name: there are more than one merge bases')
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [2860 2867]
                                  )
                                )
                              }
                            )
                          ]
                          spids: [2847 2854 2871 16777215]
                        )
                        (case_arm
                          pat_list: [{(SQ )}]
                          action: [
                            (C {(die)} 
                              {
                                (DQ 
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(eval_gettext)} 
                                            {
                                              (DQ 
                                                (word_part.EscapedLiteralPart
                                                  token: <Lit_EscapedChar '\\$'>
                                                ) ('onto_name: there is no merge base')
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [2882 2889]
                                  )
                                )
                              }
                            )
                          ]
                          spids: [2874 2876 2893 16777215]
                        )
                      ]
                      spids: [2838 2844 2896]
                    )
                  ]
                  spids: [16777215 2835]
                )
              ]
              else_action: [
                (C {(die)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {(eval_gettext)} 
                                {
                                  (DQ (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) 
                                    ('onto_name: there is no merge base')
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [2905 2912]
                      )
                    )
                  }
                )
              ]
              spids: [2899 2916]
            )
          ]
          spids: [2788 2791 2919 16777215]
        )
        (case_arm
          pat_list: [{(Lit_Other '*')}]
          action: [
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:onto spids:[2925])
                      op: Equal
                      rhs: 
                        {
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(peel_committish)} {(DQ ($ VSub_DollarName '$onto_name'))})
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [2926 2932]
                          )
                        }
                      spids: [2925]
                    )
                  ]
                  spids: [2925]
                )
                (C {(die)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {(eval_gettext)} 
                                {
                                  (DQ ('Does not point to a valid commit: ') 
                                    (word_part.EscapedLiteralPart
                                      token: <Lit_EscapedChar '\\$'>
                                    ) (onto_name)
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [2940 2948]
                      )
                    )
                  }
                )
              ]
            )
          ]
          spids: [2921 2922 2952 16777215]
        )
      ]
      spids: [2780 2786 2954]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:switch_to spids:[2969])
          op: Equal
          rhs: (word.EmptyWord)
          spids: [2969]
        )
      ]
      spids: [2969]
    )
    (command.Case
      to_match: {(DQ ($ VSub_Pound '$#'))}
      arms: [
        (case_arm
          pat_list: [{(1)}]
          action: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:branch_name spids:[2987])
                  op: Equal
                  rhs: {(DQ ($ VSub_Number '$1'))}
                  spids: [2987]
                )
              ]
              spids: [2987]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:switch_to spids:[2993])
                  op: Equal
                  rhs: {(DQ ($ VSub_Number '$1'))}
                  spids: [2993]
                )
              ]
              spids: [2993]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(git)} {(show-ref)} {(--verify)} {(--quiet)} {(--)} 
                          {(DQ (refs/heads/) ($ VSub_Number '$1'))}
                        )
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:orig_head spids:[3020])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(git)} {(rev-parse)} {(-q)} {(--verify)} 
                                            {(DQ (refs/heads/) ($ VSub_Number '$1'))}
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [3021 3034]
                                  )
                                }
                              spids: [3020]
                            )
                          ]
                          spids: [3020]
                        )
                      ]
                    )
                  ]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:head_name spids:[3040])
                          op: Equal
                          rhs: {(DQ (refs/heads/) ($ VSub_Number '$1'))}
                          spids: [3040]
                        )
                      ]
                      spids: [3040]
                    )
                  ]
                  spids: [16777215 3037]
                )
                (if_arm
                  cond: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:orig_head spids:[3049])
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(git)} {(rev-parse)} {(-q)} {(--verify)} 
                                        {(DQ ($ VSub_Number '$1'))}
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [3050 3062]
                              )
                            }
                          spids: [3049]
                        )
                      ]
                      spids: [3049]
                    )
                  ]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:head_name spids:[3068])
                          op: Equal
                          rhs: {(DQ ('detached HEAD'))}
                          spids: [3068]
                        )
                      ]
                      spids: [3068]
                    )
                  ]
                  spids: [3047 3065]
                )
              ]
              else_action: [
                (C {(die)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {(eval_gettext)} 
                                {
                                  (DQ ('fatal: no such branch: ') 
                                    (word_part.EscapedLiteralPart
                                      token: <Lit_EscapedChar '\\$'>
                                    ) (branch_name)
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [3080 3088]
                      )
                    )
                  }
                )
              ]
              spids: [3074 3092]
            )
          ]
          spids: [2979 2980 3095 16777215]
        )
        (case_arm
          pat_list: [{(0)}]
          action: [
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:branch_name spids:[3107])
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [(C {(git)} {(symbolic-ref)} {(-q)} {(HEAD)})]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [3108 3116]
                              )
                            }
                          spids: [3107]
                        )
                      ]
                      spids: [3107]
                    )
                  ]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:head_name spids:[3122])
                          op: Equal
                          rhs: {($ VSub_DollarName '$branch_name')}
                          spids: [3122]
                        )
                      ]
                      spids: [3122]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:branch_name spids:[3126])
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(expr)} {(DQ (z) ($ VSub_DollarName '$branch_name'))} 
                                        {(Lit_Other ':')} {(SQ <'zrefs/heads/\\(.*\\)'>)}
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [3127 3140]
                              )
                            }
                          spids: [3126]
                        )
                      ]
                      spids: [3126]
                    )
                  ]
                  spids: [16777215 3119]
                )
              ]
              else_action: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:head_name spids:[3146])
                      op: Equal
                      rhs: {(DQ ('detached HEAD'))}
                      spids: [3146]
                    )
                  ]
                  spids: [3146]
                )
                (command.Sentence
                  child: 
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:branch_name spids:[3152])
                          op: Equal
                          rhs: {(HEAD)}
                          spids: [3152]
                        )
                      ]
                      spids: [3152]
                    )
                  terminator: <Op_Semi ';'>
                )
              ]
              spids: [3143 3160]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:orig_head spids:[3163])
                      op: Equal
                      rhs: 
                        {
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [(C {(git)} {(rev-parse)} {(--verify)} {(HEAD)})]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [3164 3172]
                          )
                        }
                      spids: [3163]
                    )
                  ]
                  spids: [3163]
                )
                (command.ControlFlow token:<ControlFlow_Exit exit>)
              ]
            )
          ]
          spids: [3097 3098 3179 16777215]
        )
        (case_arm
          pat_list: [{(Lit_Other '*')}]
          action: [(C {(die)} {(DQ ('BUG: unexpected number of arguments left to parse'))})]
          spids: [3181 3182 3192 16777215]
        )
      ]
      spids: [2971 2977 3194]
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {(test)} {(DQ ($ VSub_DollarName '$fork_point'))} {(Lit_Other '=')} {(t)})]
          action: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:new_upstream spids:[3212])
                  op: Equal
                  rhs: 
                    {
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {(git)} {(merge-base)} {(--fork-point)} 
                                {(DQ ($ VSub_DollarName '$upstream_name'))} 
                                {
                                  (DQ 
                                    (word_part.BracedVarSub
                                      token: <VSub_Name switch_to>
                                      suffix_op: 
                                        (suffix_op.StringUnary
                                          op_id: VTest_ColonHyphen
                                          arg_word: {(HEAD)}
                                        )
                                      spids: [3227 3231]
                                    )
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [3213 3233]
                      )
                    }
                  spids: [3212]
                )
              ]
              spids: [3212]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$new_upstream'))})]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:restrict_revision spids:[3250])
                          op: Equal
                          rhs: {($ VSub_DollarName '$new_upstream')}
                          spids: [3250]
                        )
                      ]
                      spids: [3250]
                    )
                  ]
                  spids: [16777215 3247]
                )
              ]
              spids: [16777215 3254]
            )
          ]
          spids: [16777215 3209]
        )
      ]
      spids: [16777215 3256]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(DQ ($ VSub_DollarName '$autostash'))} {(Lit_Other '=')} {(true)})
                (command.Pipeline
                  children: [
                    (command.Subshell
                      child: (C {(require_clean_work_tree)})
                      redirects: [(redir.Redir op:<Redir_Great '2>'> fd:2 arg_word:{(/dev/null)})]
                      spids: [3275 3277]
                    )
                  ]
                  negated: T
                )
              ]
            )
          ]
          action: [
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:stash_sha1 spids:[3285])
                      op: Equal
                      rhs: 
                        {
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [(C {(git)} {(stash)} {(create)} {(DQ (autostash))})]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [3286 3296]
                          )
                        }
                      spids: [3285]
                    )
                  ]
                  spids: [3285]
                )
                (C {(die)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [(C {(gettext)} {(SQ <'Cannot autostash'>)})]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [3304 3310]
                      )
                    )
                  }
                )
              ]
            )
            (command.AndOr
              ops: [Op_DAmp Op_DAmp Op_DAmp Op_DAmp]
              children: [
                (C {(mkdir)} {(-p)} {(DQ ($ VSub_DollarName '$state_dir'))})
                (command.SimpleCommand
                  words: [{(echo)} {($ VSub_DollarName '$stash_sha1')}]
                  redirects: [
                    (redir.Redir
                      op: <Redir_Great '>'>
                      fd: 16777215
                      arg_word: {(DQ ($ VSub_DollarName '$state_dir') (/autostash))}
                    )
                  ]
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:stash_abbrev spids:[3339])
                      op: Equal
                      rhs: 
                        {
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(git)} {(rev-parse)} {(--short)} 
                                    {($ VSub_DollarName '$stash_sha1')}
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [3340 3348]
                          )
                        }
                      spids: [3339]
                    )
                  ]
                  spids: [3339]
                )
                (C {(echo)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [(C {(eval_gettext)} {(SQ <'Created autostash: $stash_abbrev'>)})]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [3356 3362]
                      )
                    )
                  }
                )
                (C {(git)} {(reset)} {(--hard)})
              ]
            )
          ]
          spids: [16777215 3282]
        )
      ]
      spids: [16777215 3374]
    )
    (C {(require_clean_work_tree)} {(DQ (rebase))} 
      {
        (DQ 
          (word_part.CommandSubPart
            command_list: 
              (command.CommandList
                children: [(C {(gettext)} {(DQ ('Please commit or stash them.'))})]
              )
            left_token: <Left_CommandSub '$('>
            spids: [3384 3390]
          )
        )
      }
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:mb spids:[3410])
          op: Equal
          rhs: 
            {
              (word_part.CommandSubPart
                command_list: 
                  (command.CommandList
                    children: [
                      (C {(git)} {(merge-base)} {(DQ ($ VSub_DollarName '$onto'))} 
                        {(DQ ($ VSub_DollarName '$orig_head'))}
                      )
                    ]
                  )
                left_token: <Left_CommandSub '$('>
                spids: [3411 3423]
              )
            }
          spids: [3410]
        )
      ]
      spids: [3410]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.AndOr
              ops: [Op_DAmp Op_DAmp Op_DAmp Op_DAmp]
              children: [
                (C {(test)} {(DQ ($ VSub_DollarName '$type'))} {(KW_Bang '!') (Lit_Other '=')} 
                  {(interactive)}
                )
                (C {(test)} {(DQ ($ VSub_DollarName '$upstream'))} {(Lit_Other '=')} 
                  {(DQ ($ VSub_DollarName '$onto'))}
                )
                (C {(test)} {(DQ ($ VSub_DollarName '$mb'))} {(Lit_Other '=')} 
                  {(DQ ($ VSub_DollarName '$onto'))}
                )
                (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$restrict_revision'))})
                (command.Pipeline
                  children: [
                    (command.Subshell
                      child: 
                        (command.Pipeline
                          children: [
                            (C {(git)} {(rev-list)} {(--parents)} 
                              {(DQ ($ VSub_DollarName '$onto')) (..) 
                                (DQ ($ VSub_DollarName '$orig_head'))
                              }
                            )
                            (C {(sane_grep)} {(DQ (' .* '))})
                          ]
                          negated: F
                        )
                      redirects: [(redir.Redir op:<Redir_Great '>'> fd:16777215 arg_word:{(/dev/null)})]
                      spids: [3486 3508]
                    )
                  ]
                  negated: T
                )
              ]
            )
          ]
          action: [
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$force_rebase'))})]
                  action: [
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$switch_to'))})
                        (command.SimpleCommand
                          words: [
                            {(git)}
                            {(checkout)}
                            {(-q)}
                            {(DQ ($ VSub_DollarName '$switch_to'))}
                            {(--)}
                          ]
                          more_env: [
                            (env_pair
                              name: GIT_REFLOG_ACTION
                              val: 
                                {
                                  (DQ ($ VSub_DollarName '$GIT_REFLOG_ACTION') (': checkout ') 
                                    ($ VSub_DollarName '$switch_to')
                                  )
                                }
                              spids: [3546]
                            )
                          ]
                        )
                      ]
                    )
                    (C {(say)} 
                      {
                        (DQ 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ ('Current branch ') 
                                        (word_part.EscapedLiteralPart
                                          token: <Lit_EscapedChar '\\$'>
                                        ) ('branch_name is up to date.')
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [3571 3579]
                          )
                        )
                      }
                    )
                    (C {(finish_rebase)})
                    (command.ControlFlow
                      token: <ControlFlow_Exit exit>
                      arg_word: {(0)}
                    )
                  ]
                  spids: [16777215 3528]
                )
              ]
              else_action: [
                (C {(say)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {(eval_gettext)} 
                                {
                                  (DQ ('Current branch ') 
                                    (word_part.EscapedLiteralPart
                                      token: <Lit_EscapedChar '\\$'>
                                    ) ('branch_name is up to date, rebase forced.')
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [3597 3605]
                      )
                    )
                  }
                )
              ]
              spids: [3591 3609]
            )
          ]
          spids: [16777215 3514]
        )
      ]
      spids: [16777215 3611]
    )
    (C {(run_pre_rebase_hook)} {(DQ ($ VSub_DollarName '$upstream_arg'))} {(DQ ($ VSub_At '$@'))})
    (command.If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$diffstat'))})]
          action: [
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$verbose'))})]
                  action: [
                    (C {(echo)} 
                      {
                        (DQ 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ ('Changes from ') 
                                        (word_part.EscapedLiteralPart
                                          token: <Lit_EscapedChar '\\$'>
                                        ) ('mb to ') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) ('onto:')
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [3658 3668]
                          )
                        )
                      }
                    )
                  ]
                  spids: [16777215 3652]
                )
              ]
              spids: [16777215 3672]
            )
            (command.SimpleCommand
              words: [
                {(git)}
                {(diff)}
                {(--stat)}
                {(--summary)}
                {(DQ ($ VSub_DollarName '$mb'))}
                {(DQ ($ VSub_DollarName '$onto'))}
              ]
              more_env: [(env_pair name:GIT_PAGER val:{(SQ )} spids:[3679])]
            )
          ]
          spids: [16777215 3638]
        )
      ]
      spids: [16777215 3699]
    )
    (command.AndOr
      ops: [Op_DAmp]
      children: [
        (C {(test)} {(DQ ($ VSub_DollarName '$type'))} {(Lit_Other '=')} {(interactive)})
        (C {(run_specific_rebase)})
      ]
    )
    (C {(say)} 
      {
        (DQ 
          (word_part.CommandSubPart
            command_list: 
              (command.CommandList
                children: [
                  (C {(gettext)} {(DQ ('First, rewinding head to replay your work on top of it...'))})
                ]
              )
            left_token: <Left_CommandSub '$('>
            spids: [3723 3729]
          )
        )
      }
    )
    (command.AndOr
      ops: [Op_DPipe]
      children: [
        (command.SimpleCommand
          words: [{(git)} {(checkout)} {(-q)} {(DQ ($ VSub_DollarName '$onto') ('^0'))}]
          more_env: [
            (env_pair
              name: GIT_REFLOG_ACTION
              val: 
                {
                  (DQ ($ VSub_DollarName '$GIT_REFLOG_ACTION') (': checkout ') 
                    ($ VSub_DollarName '$onto_name')
                  )
                }
              spids: [3733]
            )
          ]
        )
        (C {(die)} {(DQ ('could not detach HEAD'))})
      ]
    )
    (C {(git)} {(update-ref)} {(ORIG_HEAD)} {($ VSub_DollarName '$orig_head')})
    (command.If
      arms: [
        (if_arm
          cond: [
            (C {(test)} {(DQ ($ VSub_DollarName '$mb'))} {(Lit_Other '=')} 
              {(DQ ($ VSub_DollarName '$orig_head'))}
            )
          ]
          action: [
            (C {(say)} 
              {
                (DQ 
                  (word_part.CommandSubPart
                    command_list: 
                      (command.CommandList
                        children: [
                          (C {(eval_gettext)} 
                            {
                              (DQ ('Fast-forwarded ') 
                                (word_part.EscapedLiteralPart
                                  token: <Lit_EscapedChar '\\$'>
                                ) ('branch_name to ') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) (onto_name.)
                              )
                            }
                          )
                        ]
                      )
                    left_token: <Left_CommandSub '$('>
                    spids: [3796 3806]
                  )
                )
              }
            )
            (C {(move_to_original_branch)})
            (C {(finish_rebase)})
            (command.ControlFlow token:<ControlFlow_Exit exit> arg_word:{(0)})
          ]
          spids: [16777215 3790]
        )
      ]
      spids: [16777215 3820]
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$rebase_root'))})]
          action: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:revisions spids:[3836])
                  op: Equal
                  rhs: {(DQ ($ VSub_DollarName '$onto') (..) ($ VSub_DollarName '$orig_head'))}
                  spids: [3836]
                )
              ]
              spids: [3836]
            )
          ]
          spids: [16777215 3833]
        )
      ]
      else_action: [
        (command.Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (lhs_expr.LhsName name:revisions spids:[3846])
              op: Equal
              rhs: 
                {
                  (DQ 
                    (word_part.BracedVarSub
                      token: <VSub_Name restrict_revision>
                      suffix_op: 
                        (suffix_op.StringUnary
                          op_id: VTest_Hyphen
                          arg_word: {($ VSub_DollarName '$upstream')}
                        )
                      spids: [3848 3852]
                    ) (..) ($ VSub_DollarName '$orig_head')
                  )
                }
              spids: [3846]
            )
          ]
          spids: [3846]
        )
      ]
      spids: [3843 3857]
    )
    (C {(run_specific_rebase)})
  ]
)