(command.CommandList
  children: [
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:todo spids:[47])
          op: Equal
          rhs: {(DQ ($ VSub_Name '$state_dir')) (/git-rebase-todo)}
          spids: [47]
        )
      ]
      spids: [47]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:done spids:[63])
          op: Equal
          rhs: {(DQ ($ VSub_Name '$state_dir')) (/done)}
          spids: [63]
        )
      ]
      spids: [63]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:msg spids:[76])
          op: Equal
          rhs: {(DQ ($ VSub_Name '$state_dir')) (/message)}
          spids: [76]
        )
      ]
      spids: [76]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:squash_msg spids:[122])
          op: Equal
          rhs: {(DQ ($ VSub_Name '$state_dir')) (/message-squash)}
          spids: [122]
        )
      ]
      spids: [122]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:fixup_msg spids:[144])
          op: Equal
          rhs: {(DQ ($ VSub_Name '$state_dir')) (/message-fixup)}
          spids: [144]
        )
      ]
      spids: [144]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:rewritten spids:[169])
          op: Equal
          rhs: {(DQ ($ VSub_Name '$state_dir')) (/rewritten)}
          spids: [169]
        )
      ]
      spids: [169]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:dropped spids:[176])
          op: Equal
          rhs: {(DQ ($ VSub_Name '$state_dir')) (/dropped)}
          spids: [176]
        )
      ]
      spids: [176]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:end spids:[183])
          op: Equal
          rhs: {(DQ ($ VSub_Name '$state_dir')) (/end)}
          spids: [183]
        )
      ]
      spids: [183]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:msgnum spids:[189])
          op: Equal
          rhs: {(DQ ($ VSub_Name '$state_dir')) (/msgnum)}
          spids: [189]
        )
      ]
      spids: [189]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:author_script spids:[205])
          op: Equal
          rhs: {(DQ ($ VSub_Name '$state_dir')) (/author-script)}
          spids: [205]
        )
      ]
      spids: [205]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:amend spids:[230])
          op: Equal
          rhs: {(DQ ($ VSub_Name '$state_dir')) (/amend)}
          spids: [230]
        )
      ]
      spids: [230]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:rewritten_list spids:[249])
          op: Equal
          rhs: {(DQ ($ VSub_Name '$state_dir')) (/rewritten-list)}
          spids: [249]
        )
      ]
      spids: [249]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:rewritten_pending spids:[255])
          op: Equal
          rhs: {(DQ ($ VSub_Name '$state_dir')) (/rewritten-pending)}
          spids: [255]
        )
      ]
      spids: [255]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:cr spids:[268])
          op: Equal
          rhs: 
            {
              (word_part.CommandSubPart
                command_list: 
                  (command.CommandList
                    children: [(C {(printf)} {(DQ (Lit_Other '\\') (015))})]
                  )
                left_token: <Left_CommandSub '$('>
                spids: [269 276]
              )
            }
          spids: [268]
        )
      ]
      spids: [268]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:strategy_args spids:[279])
          op: Equal
          rhs: 
            {
              (word_part.BracedVarSub
                token: <VSub_Name strategy>
                suffix_op: 
                  (suffix_op.StringUnary
                    op_id: VTest_ColonPlus
                    arg_word: {('--strategy=') ($ VSub_Name '$strategy')}
                  )
                spids: [280 285]
              )
            }
          spids: [279]
        )
      ]
      spids: [279]
    )
    (command.AndOr
      ops: [Op_DAmp]
      children: [
        (C {(test)} {(-n)} {(DQ ($ VSub_Name '$strategy_opts'))})
        (C {(eval)} 
          {(SQ <'\n'> <'\tfor strategy_opt in '>) (DQ ($ VSub_Name '$strategy_opts')) 
            (SQ <'\n'> <'\tdo\n'> 
              <
'\t\tstrategy_args="$strategy_args -X$(git rev-parse --sq-quote "${strategy_opt#--}")"\n'
              > <'\tdone\n'>
            )
          }
        )
      ]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:GIT_CHERRY_PICK_HELP spids:[314])
          op: Equal
          rhs: {(DQ ($ VSub_Name '$resolvemsg'))}
          spids: [314]
        )
      ]
      spids: [314]
    )
    (C {(export)} {(GIT_CHERRY_PICK_HELP)})
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:comment_char spids:[324])
          op: Equal
          rhs: 
            {
              (word_part.CommandSubPart
                command_list: 
                  (command.CommandList
                    children: [
                      (command.Pipeline
                        children: [
                          (command.SimpleCommand
                            words: [{(git)} {(config)} {(--get)} {(core.commentchar)}]
                            redirects: [(redir.Redir op:<Redir_Great '2>'> fd:2 arg_word:{(/dev/null)})]
                          )
                          (C {(cut)} {(-c1)})
                        ]
                        negated: F
                      )
                    ]
                  )
                left_token: <Left_CommandSub '$('>
                spids: [325 342]
              )
            }
          spids: [324]
        )
      ]
      spids: [324]
    )
    (C {(Lit_Other ':')} 
      {
        (word_part.BracedVarSub
          token: <VSub_Name comment_char>
          suffix_op: (suffix_op.StringUnary op_id:VTest_ColonEquals arg_word:{(Lit_Pound '#')})
          spids: [346 350]
        )
      }
    )
    (command.FuncDef
      name: warn
      body: 
        (command.BraceGroup
          children: [
            (command.SimpleCommand
              words: [{(printf)} {(SQ <'%s\\n'>)} {(DQ ($ VSub_Star '$*'))}]
              redirects: [(redir.Redir op:<Redir_GreatAnd '>&'> fd:16777215 arg_word:{(2)})]
            )
          ]
          spids: [358]
        )
      spids: [353 357]
    )
    (command.FuncDef
      name: commit_message
      body: 
        (command.BraceGroup
          children: [
            (command.Pipeline
              children: [
                (C {(git)} {(cat-file)} {(commit)} {(DQ ($ VSub_Number '$1'))})
                (C {(sed)} {(DQ ('1,/^') (Lit_Other '$') (/d))})
              ]
              negated: F
            )
          ]
          spids: [385]
        )
      spids: [380 384]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:orig_reflog_action spids:[411])
          op: Equal
          rhs: {(DQ ($ VSub_Name '$GIT_REFLOG_ACTION'))}
          spids: [411]
        )
      ]
      spids: [411]
    )
    (command.FuncDef
      name: comment_for_reflog
      body: 
        (command.BraceGroup
          children: [
            (command.Case
              to_match: {(DQ ($ VSub_Name '$orig_reflog_action'))}
              arms: [
                (case_arm
                  pat_list: [{(SQ )} {(rebase) (Lit_Other '*')}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:GIT_REFLOG_ACTION spids:[442])
                          op: Equal
                          rhs: {(DQ ('rebase -i (') ($ VSub_Number '$1') (')'))}
                          spids: [442]
                        )
                      ]
                      spids: [442]
                    )
                    (C {(export)} {(GIT_REFLOG_ACTION)})
                  ]
                  spids: [434 439 455 16777215]
                )
              ]
              spids: [425 431 458]
            )
          ]
          spids: [422]
        )
      spids: [417 421]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:last_count spids:[463])
          op: Equal
          rhs: (word.EmptyWord)
          spids: [463]
        )
      ]
      spids: [463]
    )
    (command.FuncDef
      name: mark_action_done
      body: 
        (command.BraceGroup
          children: [
            (command.SimpleCommand
              words: [{(sed)} {(-e)} {(1q)}]
              redirects: [
                (redir.Redir
                  op: <Redir_Less '<'>
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_Name '$todo'))}
                )
                (redir.Redir
                  op: <Redir_DGreat '>>'>
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_Name '$done'))}
                )
              ]
            )
            (command.SimpleCommand
              words: [{(sed)} {(-e)} {(1d)}]
              redirects: [
                (redir.Redir
                  op: <Redir_Less '<'>
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_Name '$todo'))}
                )
                (redir.Redir
                  op: <Redir_DGreat '>>'>
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_Name '$todo')) (.new)}
                )
              ]
            )
            (C {(mv)} {(-f)} {(DQ ($ VSub_Name '$todo')) (.new)} {(DQ ($ VSub_Name '$todo'))})
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:new_count spids:[526])
                  op: Equal
                  rhs: 
                    {
                      (word_part.ArithSubPart
                        anode: 
                          (arith_expr.ArithWord
                            w: 
                              {
                                (word_part.CommandSubPart
                                  command_list: 
                                    (command.CommandList
                                      children: [
                                        (command.Pipeline
                                          children: [
                                            (command.SimpleCommand
                                              words: [{(git)} {(stripspace)} {(--strip-comments)}]
                                              redirects: [
                                                (redir.Redir
                                                  op: <Redir_Less '<'>
                                                  fd: 16777215
                                                  arg_word: {(DQ ($ VSub_Name '$done'))}
                                                )
                                              ]
                                            )
                                            (C {(wc)} {(-l)})
                                          ]
                                          negated: F
                                        )
                                      ]
                                    )
                                  left_token: <Left_CommandSub '$('>
                                  spids: [529 546]
                                )
                              }
                          )
                        spids: [527 549]
                      )
                    }
                  spids: [526]
                )
              ]
              spids: [526]
            )
            (command.SimpleCommand
              words: [{(echo)} {($ VSub_Name '$new_count')}]
              redirects: [
                (redir.Redir
                  op: <Redir_Great '>'>
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_Name '$msgnum'))}
                )
              ]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:total spids:[562])
                  op: Equal
                  rhs: 
                    {
                      (word_part.ArithSubPart
                        anode: 
                          (arith_expr.ArithBinary
                            op_id: Arith_Plus
                            left: (arith_expr.ArithWord w:{($ VSub_Name '$new_count')})
                            right: 
                              (arith_expr.ArithWord
                                w: 
                                  {
                                    (word_part.CommandSubPart
                                      command_list: 
                                        (command.CommandList
                                          children: [
                                            (command.Pipeline
                                              children: [
                                                (command.SimpleCommand
                                                  words: [{(git)} {(stripspace)} {(--strip-comments)}]
                                                  redirects: [
                                                    (redir.Redir
                                                      op: <Redir_Less '<'>
                                                      fd: 16777215
                                                      arg_word: {(DQ ($ VSub_Name '$todo'))}
                                                    )
                                                  ]
                                                )
                                                (C {(wc)} {(-l)})
                                              ]
                                              negated: F
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub '$('>
                                      spids: [568 585]
                                    )
                                  }
                              )
                          )
                        spids: [563 587]
                      )
                    }
                  spids: [562]
                )
              ]
              spids: [562]
            )
            (command.SimpleCommand
              words: [{(echo)} {($ VSub_Name '$total')}]
              redirects: [
                (redir.Redir
                  op: <Redir_Great '>'>
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_Name '$end'))}
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (C {(test)} {(DQ ($ VSub_Name '$last_count'))} {(KW_Bang '!') (Lit_Other '=')} 
                      {(DQ ($ VSub_Name '$new_count'))}
                    )
                  ]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:last_count spids:[619])
                          op: Equal
                          rhs: {($ VSub_Name '$new_count')}
                          spids: [619]
                        )
                      ]
                      spids: [619]
                    )
                    (command.Sentence
                      child: 
                        (C {(eval_gettext)} 
                          {
                            (DQ ('Rebasing (') 
                              (word_part.EscapedLiteralPart
                                token: <Lit_EscapedChar '\\$'>
                              ) (new_count/) (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) ('total)')
                            )
                          }
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (C {(printf)} {(DQ (Lit_Other '\\') (r))})
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [(C {(test)} {(-z)} {(DQ ($ VSub_Name '$verbose'))}) (C {(echo)})]
                    )
                  ]
                  spids: [16777215 616]
                )
              ]
              spids: [16777215 655]
            )
          ]
          spids: [470]
        )
      spids: [465 469]
    )
    (command.FuncDef
      name: reschedule_last_action
      body: 
        (command.BraceGroup
          children: [
            (command.Pipeline
              children: [
                (C {(tail)} {(-n)} {(1)} {(DQ ($ VSub_Name '$done'))})
                (command.SimpleCommand
                  words: [{(cat)} {(-)} {(DQ ($ VSub_Name '$todo'))}]
                  redirects: [
                    (redir.Redir
                      op: <Redir_Great '>'>
                      fd: 16777215
                      arg_word: {(DQ ($ VSub_Name '$todo')) (.new)}
                    )
                  ]
                )
              ]
              negated: F
            )
            (command.SimpleCommand
              words: [{(sed)} {(-e)} {(word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) (d)}]
              redirects: [
                (redir.Redir
                  op: <Redir_Less '<'>
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_Name '$done'))}
                )
                (redir.Redir
                  op: <Redir_Great '>'>
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_Name '$done')) (.new)}
                )
              ]
            )
            (C {(mv)} {(-f)} {(DQ ($ VSub_Name '$todo')) (.new)} {(DQ ($ VSub_Name '$todo'))})
            (C {(mv)} {(-f)} {(DQ ($ VSub_Name '$done')) (.new)} {(DQ ($ VSub_Name '$done'))})
          ]
          spids: [674]
        )
      spids: [669 673]
    )
    (command.FuncDef
      name: append_todo_help
      body: 
        (command.BraceGroup
          children: [
            (command.Pipeline
              children: [
                (C {(gettext)} 
                  {
                    (DQ ('\n') ('Commands:\n') (' p, pick = use commit\n') 
                      (' r, reword = use commit, but edit the commit message\n') (' e, edit = use commit, but stop for amending\n') 
                      (' s, squash = use commit, but meld into previous commit\n') (' f, fixup = like ') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\"'>) (squash) 
                      (word_part.EscapedLiteralPart
                        token: <Lit_EscapedChar '\\"'>
                      ) (", but discard this commit's log message\n") 
                      (' x, exec = run command (the rest of the line) using shell\n') (' d, drop = remove commit\n') ('\n') 
                      ('These lines can be re-ordered; they are executed from top to bottom.\n')
                    )
                  }
                )
                (command.SimpleCommand
                  words: [{(git)} {(stripspace)} {(--comment-lines)}]
                  redirects: [
                    (redir.Redir
                      op: <Redir_DGreat '>>'>
                      fd: 16777215
                      arg_word: {(DQ ($ VSub_Name '$todo'))}
                    )
                  ]
                )
              ]
              negated: F
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (C {(test)} 
                      {
                        (word_part.CommandSubPart
                          command_list: 
                            (command.CommandList
                              children: [(C {(get_missing_commit_check_level)})]
                            )
                          left_token: <Left_CommandSub '$('>
                          spids: [800 802]
                        )
                      } {(Lit_Other '=')} {(error)}
                    )
                  ]
                  action: [
                    (command.Pipeline
                      children: [
                        (C {(gettext)} 
                          {
                            (DQ ('\n') 
                              (
"Do not remove any line. Use 'drop' explicitly to remove a commit.\n"
                              )
                            )
                          }
                        )
                        (command.SimpleCommand
                          words: [{(git)} {(stripspace)} {(--comment-lines)}]
                          redirects: [
                            (redir.Redir
                              op: <Redir_DGreat '>>'>
                              fd: 16777215
                              arg_word: {(DQ ($ VSub_Name '$todo'))}
                            )
                          ]
                        )
                      ]
                      negated: F
                    )
                  ]
                  spids: [16777215 809]
                )
              ]
              else_action: [
                (command.Pipeline
                  children: [
                    (C {(gettext)} 
                      {(DQ ('\n') ('If you remove a line here THAT COMMIT WILL BE LOST.\n'))}
                    )
                    (command.SimpleCommand
                      words: [{(git)} {(stripspace)} {(--comment-lines)}]
                      redirects: [
                        (redir.Redir
                          op: <Redir_DGreat '>>'>
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_Name '$todo'))}
                        )
                      ]
                    )
                  ]
                  negated: F
                )
              ]
              spids: [833 857]
            )
          ]
          spids: [758]
        )
      spids: [753 757]
    )
    (command.FuncDef
      name: make_patch
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:sha1_and_parents spids:[870])
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (word_part.CommandSubPart
                          command_list: 
                            (command.CommandList
                              children: [
                                (C {(git)} {(rev-list)} {(--parents)} {(-1)} {(DQ ($ VSub_Number '$1'))})
                              ]
                            )
                          left_token: <Left_CommandSub '$('>
                          spids: [872 884]
                        )
                      )
                    }
                  spids: [870]
                )
              ]
              spids: [870]
            )
            (command.Case
              to_match: {(DQ ($ VSub_Name '$sha1_and_parents'))}
              arms: [
                (case_arm
                  pat_list: [
                    {(Lit_Other '?') (Lit_Other '*') (SQ <' '>) (Lit_Other '?') (Lit_Other '*') 
                      (SQ <' '>) (Lit_Other '?') (Lit_Other '*')
                    }
                  ]
                  action: [(C {(git)} {(diff)} {(--cc)} {($ VSub_Name '$sha1_and_parents')})]
                  spids: [897 909 921 16777215]
                )
                (case_arm
                  pat_list: [
                    {(Lit_Other '?') (Lit_Other '*') (SQ <' '>) (Lit_Other '?') (Lit_Other '*')}
                  ]
                  action: [(C {(git)} {(diff-tree)} {(-p)} {(DQ ($ VSub_Number '$1') ('^!'))})]
                  spids: [924 931 946 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [(C {(echo)} {(DQ ('Root commit'))})]
                  spids: [949 950 960 16777215]
                )
              ]
              redirects: [
                (redir.Redir
                  op: <Redir_Great '>'>
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_Name '$state_dir')) (/patch)}
                )
              ]
              spids: [888 894 963]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(test)} {(-f)} {(DQ ($ VSub_Name '$msg'))})
                (command.SimpleCommand
                  words: [{(commit_message)} {(DQ ($ VSub_Number '$1'))}]
                  redirects: [
                    (redir.Redir
                      op: <Redir_Great '>'>
                      fd: 16777215
                      arg_word: {(DQ ($ VSub_Name '$msg'))}
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(test)} {(-f)} {(DQ ($ VSub_Name '$author_script'))})
                (command.SimpleCommand
                  words: [{(get_author_ident_from_commit)} {(DQ ($ VSub_Number '$1'))}]
                  redirects: [
                    (redir.Redir
                      op: <Redir_Great '>'>
                      fd: 16777215
                      arg_word: {(DQ ($ VSub_Name '$author_script'))}
                    )
                  ]
                )
              ]
            )
          ]
          spids: [867]
        )
      spids: [862 866]
    )
    (command.FuncDef
      name: die_with_patch
      body: 
        (command.BraceGroup
          children: [
            (command.SimpleCommand
              words: [{(echo)} {(DQ ($ VSub_Number '$1'))}]
              redirects: [
                (redir.Redir
                  op: <Redir_Great '>'>
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_Name '$state_dir')) (/stopped-sha)}
                )
              ]
            )
            (C {(make_patch)} {(DQ ($ VSub_Number '$1'))})
            (C {(die)} {(DQ ($ VSub_Number '$2'))})
          ]
          spids: [1028]
        )
      spids: [1023 1027]
    )
    (command.FuncDef
      name: exit_with_patch
      body: 
        (command.BraceGroup
          children: [
            (command.SimpleCommand
              words: [{(echo)} {(DQ ($ VSub_Number '$1'))}]
              redirects: [
                (redir.Redir
                  op: <Redir_Great '>'>
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_Name '$state_dir')) (/stopped-sha)}
                )
              ]
            )
            (C {(make_patch)} {($ VSub_Number '$1')})
            (command.SimpleCommand
              words: [{(git)} {(rev-parse)} {(--verify)} {(HEAD)}]
              redirects: [
                (redir.Redir
                  op: <Redir_Great '>'>
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_Name '$amend'))}
                )
              ]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:gpg_sign_opt_quoted spids:[1103])
                  op: Equal
                  rhs: 
                    {
                      (word_part.BracedVarSub
                        token: <VSub_Name gpg_sign_opt>
                        suffix_op: 
                          (suffix_op.StringUnary
                            op_id: VTest_ColonPlus
                            arg_word: 
                              {
                                (word_part.CommandSubPart
                                  command_list: 
                                    (command.CommandList
                                      children: [
                                        (C {(git)} {(rev-parse)} {(--sq-quote)} 
                                          {(DQ ($ VSub_Name '$gpg_sign_opt'))}
                                        )
                                      ]
                                    )
                                  left_token: <Left_CommandSub '$('>
                                  spids: [1107 1117]
                                )
                              }
                          )
                        spids: [1104 1118]
                      )
                    }
                  spids: [1103]
                )
              ]
              spids: [1103]
            )
            (C {(warn)} 
              {
                (DQ 
                  (word_part.CommandSubPart
                    command_list: 
                      (command.CommandList
                        children: [
                          (C {(eval_gettext)} 
                            {
                              (DQ ('You can amend the commit now, with\n') ('\n') 
                                ('\tgit commit --amend ') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) ('gpg_sign_opt_quoted\n') ('\n') 
                                ('Once you are satisfied with your changes, run\n') ('\n') ('\tgit rebase --continue')
                              )
                            }
                          )
                        ]
                      )
                    left_token: <Left_CommandSub '$('>
                    spids: [1124 1139]
                  )
                )
              }
            )
            (C {(warn)})
            (command.ControlFlow
              token: <ControlFlow_Exit exit>
              arg_word: {($ VSub_Number '$2')}
            )
          ]
          spids: [1066]
        )
      spids: [1061 1065]
    )
    (command.FuncDef
      name: die_abort
      body: 
        (command.BraceGroup
          children: [
            (C {(apply_autostash)})
            (C {(rm)} {(-rf)} {(DQ ($ VSub_Name '$state_dir'))})
            (C {(die)} {(DQ ($ VSub_Number '$1'))})
          ]
          spids: [1158]
        )
      spids: [1153 1157]
    )
    (command.FuncDef
      name: has_action
      body: 
        (command.BraceGroup
          children: [
            (C {(test)} {(-n)} 
              {
                (DQ 
                  (word_part.CommandSubPart
                    command_list: 
                      (command.CommandList
                        children: [
                          (command.SimpleCommand
                            words: [{(git)} {(stripspace)} {(--strip-comments)}]
                            redirects: [
                              (redir.Redir
                                op: <Redir_Less '<'>
                                fd: 16777215
                                arg_word: {(DQ ($ VSub_Number '$1'))}
                              )
                            ]
                          )
                        ]
                      )
                    left_token: <Left_CommandSub '$('>
                    spids: [1195 1206]
                  )
                )
              }
            )
          ]
          spids: [1187]
        )
      spids: [1182 1186]
    )
    (command.FuncDef
      name: is_empty_commit
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:tree spids:[1219])
                      op: Equal
                      rhs: 
                        {
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (command.SimpleCommand
                                    words: [
                                      {(git)}
                                      {(rev-parse)}
                                      {(-q)}
                                      {(--verify)}
                                      {(DQ ($ VSub_Number '$1')) (Lit_Other '^') (Lit_LBrace '{') 
                                        (tree) (Lit_RBrace '}')
                                      }
                                    ]
                                    redirects: [
                                      (redir.Redir
                                        op: <Redir_Great '2>'>
                                        fd: 2
                                        arg_word: {(/dev/null)}
                                      )
                                    ]
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [1220 1239]
                          )
                        }
                      spids: [1219]
                    )
                  ]
                  spids: [1219]
                )
                (command.BraceGroup
                  children: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:sha1 spids:[1246])
                          op: Equal
                          rhs: {($ VSub_Number '$1')}
                          spids: [1246]
                        )
                      ]
                      spids: [1246]
                    )
                    (C {(die)} 
                      {
                        (DQ 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) 
                                        ('sha1: not a commit that can be picked')
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [1253 1260]
                          )
                        )
                      }
                    )
                  ]
                  spids: [1243]
                )
              ]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:ptree spids:[1267])
                      op: Equal
                      rhs: 
                        {
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (command.SimpleCommand
                                    words: [
                                      {(git)}
                                      {(rev-parse)}
                                      {(-q)}
                                      {(--verify)}
                                      {(DQ ($ VSub_Number '$1')) (Lit_Other '^') (Lit_Other '^') 
                                        (Lit_LBrace '{') (tree) (Lit_RBrace '}')
                                      }
                                    ]
                                    redirects: [
                                      (redir.Redir
                                        op: <Redir_Great '2>'>
                                        fd: 2
                                        arg_word: {(/dev/null)}
                                      )
                                    ]
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [1268 1288]
                          )
                        }
                      spids: [1267]
                    )
                  ]
                  spids: [1267]
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:ptree spids:[1293])
                      op: Equal
                      rhs: {(4b825dc642cb6eb9a060e54bf8d69288fbee4904)}
                      spids: [1293]
                    )
                  ]
                  spids: [1293]
                )
              ]
            )
            (C {(test)} {(DQ ($ VSub_Name '$tree'))} {(Lit_Other '=')} {(DQ ($ VSub_Name '$ptree'))})
          ]
          spids: [1216]
        )
      spids: [1212 1215]
    )
    (command.FuncDef
      name: is_merge_commit
      body: 
        (command.BraceGroup
          children: [
            (command.SimpleCommand
              words: [
                {(git)}
                {(rev-parse)}
                {(--verify)}
                {(--quiet)}
                {(DQ ($ VSub_Number '$1')) (Lit_Other '^') (2)}
              ]
              redirects: [
                (redir.Redir op:<Redir_Great '>'> fd:16777215 arg_word:{(/dev/null)})
                (redir.Redir op:<Redir_GreatAnd '2>&'> fd:2 arg_word:{(1)})
              ]
            )
          ]
          spids: [1316]
        )
      spids: [1312 1315]
    )
    (command.FuncDef
      name: do_with_author
      body: 
        (command.BraceGroup
          children: [
            (command.Subshell
              child: 
                (command.CommandList
                  children: [
                    (C {(export)} {(GIT_AUTHOR_NAME)} {(GIT_AUTHOR_EMAIL)} {(GIT_AUTHOR_DATE)})
                    (C {(DQ ($ VSub_At '$@'))})
                  ]
                )
              spids: [1356 1373]
            )
          ]
          spids: [1353]
        )
      spids: [1348 1352]
    )
    (command.FuncDef
      name: git_sequence_editor
      body: 
        (command.BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name '$GIT_SEQUENCE_EDITOR'))})]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:GIT_SEQUENCE_EDITOR spids:[1400])
                          op: Equal
                          rhs: 
                            {
                              (DQ 
                                (word_part.CommandSubPart
                                  command_list: 
                                    (command.CommandList
                                      children: [(C {(git)} {(config)} {(sequence.editor)})]
                                    )
                                  left_token: <Left_CommandSub '$('>
                                  spids: [1402 1408]
                                )
                              )
                            }
                          spids: [1400]
                        )
                      ]
                      spids: [1400]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (C {(Lit_Other '[')} {(-z)} {(DQ ($ VSub_Name '$GIT_SEQUENCE_EDITOR'))} 
                              {(Lit_Other ']')}
                            )
                          ]
                          action: [
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:GIT_SEQUENCE_EDITOR spids:[1428])
                                      op: Equal
                                      rhs: 
                                        {
                                          (DQ 
                                            (word_part.CommandSubPart
                                              command_list: 
                                                (command.CommandList
                                                  children: [(C {(git)} {(var)} {(GIT_EDITOR)})]
                                                )
                                              left_token: <Left_CommandSub '$('>
                                              spids: [1430 1436]
                                            )
                                          )
                                        }
                                      spids: [1428]
                                    )
                                  ]
                                  spids: [1428]
                                )
                                (command.ControlFlow
                                  token: <ControlFlow_Return return>
                                  arg_word: {($ VSub_QMark '$?')}
                                )
                              ]
                            )
                          ]
                          spids: [16777215 1425]
                        )
                      ]
                      spids: [16777215 1446]
                    )
                  ]
                  spids: [16777215 1397]
                )
              ]
              spids: [16777215 1449]
            )
            (C {(eval)} {(DQ ($ VSub_Name '$GIT_SEQUENCE_EDITOR'))} {(SQ <'"$@"'>)})
          ]
          spids: [1383]
        )
      spids: [1378 1382]
    )
    (command.FuncDef
      name: pick_one
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:ff spids:[1474])
                  op: Equal
                  rhs: {(--ff)}
                  spids: [1474]
                )
              ]
              spids: [1474]
            )
            (command.Case
              to_match: {(DQ ($ VSub_Number '$1'))}
              arms: [
                (case_arm
                  pat_list: [{(-n)}]
                  action: [
                    (command.Sentence
                      child: 
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:sha1 spids:[1490])
                              op: Equal
                              rhs: {($ VSub_Number '$2')}
                              spids: [1490]
                            )
                          ]
                          spids: [1490]
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:ff spids:[1494])
                          op: Equal
                          rhs: (word.EmptyWord)
                          spids: [1494]
                        )
                      ]
                      spids: [1494]
                    )
                  ]
                  spids: [1487 1488 1496 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:sha1 spids:[1501])
                          op: Equal
                          rhs: {($ VSub_Number '$1')}
                          spids: [1501]
                        )
                      ]
                      spids: [1501]
                    )
                  ]
                  spids: [1498 1499 1504 16777215]
                )
              ]
              spids: [1479 1485 1506]
            )
            (command.Case
              to_match: {(DQ ($ VSub_Name '$force_rebase'))}
              arms: [
                (case_arm pat_list:[{(SQ )}] spids:[1517 1519 1521 16777215])
                (case_arm
                  pat_list: [{(Lit_Other '?') (Lit_Other '*')}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:ff spids:[1527])
                          op: Equal
                          rhs: (word.EmptyWord)
                          spids: [1527]
                        )
                      ]
                      spids: [1527]
                    )
                  ]
                  spids: [1523 1525 1529 16777215]
                )
              ]
              spids: [1509 1515 1531]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(output)} {(git)} {(rev-parse)} {(--verify)} {($ VSub_Name '$sha1')})
                (C {(die)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {(eval_gettext)} 
                                {
                                  (DQ ('Invalid commit name: ') 
                                    (word_part.EscapedLiteralPart
                                      token: <Lit_EscapedChar '\\$'>
                                    ) (sha1)
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [1549 1557]
                      )
                    )
                  }
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(is_empty_commit)} {(DQ ($ VSub_Name '$sha1'))})]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:empty_args spids:[1574])
                          op: Equal
                          rhs: {(DQ (--allow-empty))}
                          spids: [1574]
                        )
                      ]
                      spids: [1574]
                    )
                  ]
                  spids: [16777215 1571]
                )
              ]
              spids: [16777215 1580]
            )
            (command.AndOr
              ops: [Op_DAmp Op_DAmp]
              children: [
                (C {(test)} {(-d)} {(DQ ($ VSub_Name '$rewritten'))})
                (C {(pick_one_preserving_merges)} {(DQ ($ VSub_At '$@'))})
                (command.ControlFlow token:<ControlFlow_Return return>)
              ]
            )
            (C {(output)} {(eval)} {(git)} {(cherry-pick)} 
              {
                (word_part.BracedVarSub
                  token: <VSub_Name gpg_sign_opt>
                  suffix_op: 
                    (suffix_op.StringUnary
                      op_id: VTest_ColonPlus
                      arg_word: 
                        {
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(git)} {(rev-parse)} {(--sq-quote)} 
                                    {(DQ ($ VSub_Name '$gpg_sign_opt'))}
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [1619 1629]
                          )
                        }
                    )
                  spids: [1616 1630]
                )
              } {(DQ ($ VSub_Name '$strategy_args'))} {($ VSub_Name '$empty_args')} {($ VSub_Name '$ff')} 
              {(DQ ($ VSub_At '$@'))}
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:ret spids:[1656])
                  op: Equal
                  rhs: {($ VSub_QMark '$?')}
                  spids: [1656]
                )
              ]
              spids: [1656]
            )
            (command.Case
              to_match: {(DQ ($ VSub_Name '$ret'))}
              arms: [
                (case_arm
                  pat_list: [{(Lit_Other '[') (01) (Lit_Other ']')}]
                  spids: [1668 1671 1673 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [(C {(reschedule_last_action)})]
                  spids: [1675 1676 1680 16777215]
                )
              ]
              spids: [1660 1666 1682]
            )
            (command.ControlFlow
              token: <ControlFlow_Return return>
              arg_word: {($ VSub_Name '$ret')}
            )
          ]
          spids: [1471]
        )
      spids: [1466 1470]
    )
    (command.FuncDef
      name: pick_one_preserving_merges
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:fast_forward spids:[1700])
                  op: Equal
                  rhs: {(t)}
                  spids: [1700]
                )
              ]
              spids: [1700]
            )
            (command.Case
              to_match: {(DQ ($ VSub_Number '$1'))}
              arms: [
                (case_arm
                  pat_list: [{(-n)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:fast_forward spids:[1717])
                          op: Equal
                          rhs: {(f)}
                          spids: [1717]
                        )
                      ]
                      spids: [1717]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:sha1 spids:[1721])
                          op: Equal
                          rhs: {($ VSub_Number '$2')}
                          spids: [1721]
                        )
                      ]
                      spids: [1721]
                    )
                  ]
                  spids: [1713 1714 1725 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:sha1 spids:[1732])
                          op: Equal
                          rhs: {($ VSub_Number '$1')}
                          spids: [1732]
                        )
                      ]
                      spids: [1732]
                    )
                  ]
                  spids: [1728 1729 1736 16777215]
                )
              ]
              spids: [1704 1710 1739]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:sha1 spids:[1742])
                  op: Equal
                  rhs: 
                    {
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [(C {(git)} {(rev-parse)} {($ VSub_Name '$sha1')})]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [1743 1749]
                      )
                    }
                  spids: [1742]
                )
              ]
              spids: [1742]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-f)} {(DQ ($ VSub_Name '$state_dir')) (/current-commit)})]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (C {(test)} {(DQ ($ VSub_Name '$fast_forward'))} {(Lit_Other '=')} {(t)})
                          ]
                          action: [
                            (command.WhileUntil
                              keyword: <KW_While while>
                              cond: [(C {(read)} {(current_commit)})]
                              body: 
                                (command.DoGroup
                                  children: [
                                    (command.SimpleCommand
                                      words: [{(git)} {(rev-parse)} {(HEAD)}]
                                      redirects: [
                                        (redir.Redir
                                          op: <Redir_Great '>'>
                                          fd: 16777215
                                          arg_word: 
                                            {(DQ ($ VSub_Name '$rewritten')) (/) 
                                              ($ VSub_Name '$current_commit')
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [1791 1809]
                                )
                              redirects: [
                                (redir.Redir
                                  op: <Redir_Less '<'>
                                  fd: 16777215
                                  arg_word: {(DQ ($ VSub_Name '$state_dir')) (/current-commit)}
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {(rm)} {(DQ ($ VSub_Name '$state_dir')) (/current-commit)})
                                (C {(die)} 
                                  {
                                    (DQ 
                                      (word_part.CommandSubPart
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (C {(gettext)} 
                                                {
                                                  (DQ 
                                                    (
"Cannot write current commit's replacement sha1"
                                                    )
                                                  )
                                                }
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub '$('>
                                        spids: [1831 1837]
                                      )
                                    )
                                  }
                                )
                              ]
                            )
                          ]
                          spids: [16777215 1781]
                        )
                      ]
                      spids: [16777215 1841]
                    )
                  ]
                  spids: [16777215 1765]
                )
              ]
              spids: [16777215 1844]
            )
            (command.SimpleCommand
              words: [{(echo)} {($ VSub_Name '$sha1')}]
              redirects: [
                (redir.Redir
                  op: <Redir_DGreat '>>'>
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_Name '$state_dir')) (/current-commit)}
                )
              ]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:new_parents spids:[1865])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [1865]
                )
              ]
              spids: [1865]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:pend spids:[1868])
                  op: Equal
                  rhs: 
                    {
                      (DQ (' ') 
                        (word_part.CommandSubPart
                          command_list: 
                            (command.CommandList
                              children: [
                                (command.Pipeline
                                  children: [
                                    (C {(git)} {(rev-list)} {(--parents)} {(-1)} {($ VSub_Name '$sha1')})
                                    (C {(cut)} {(-d) (SQ <' '>)} {(-s)} {(-f2-)})
                                  ]
                                  negated: F
                                )
                              ]
                            )
                          left_token: <Left_CommandSub '$('>
                          spids: [1871 1894]
                        )
                      )
                    }
                  spids: [1868]
                )
              ]
              spids: [1868]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(DQ ($ VSub_Name '$pend'))} {(Lit_Other '=')} {(DQ (' '))})]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:pend spids:[1916])
                          op: Equal
                          rhs: {(DQ (' root'))}
                          spids: [1916]
                        )
                      ]
                      spids: [1916]
                    )
                  ]
                  spids: [16777215 1913]
                )
              ]
              spids: [16777215 1922]
            )
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [
                (C {(Lit_Other '[')} {(DQ ($ VSub_Name '$pend'))} {(KW_Bang '!') (Lit_Other '=')} {(DQ )} 
                  {(Lit_Other ']')}
                )
              ]
              body: 
                (command.DoGroup
                  children: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:p spids:[1945])
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(expr)} {(DQ ($ VSub_Name '$pend'))} {(Lit_Other ':')} 
                                        {(SQ <' \\([^ ]*\\)'>)}
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [1946 1958]
                              )
                            }
                          spids: [1945]
                        )
                      ]
                      spids: [1945]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:pend spids:[1961])
                          op: Equal
                          rhs: 
                            {
                              (DQ 
                                (word_part.BracedVarSub
                                  token: <VSub_Name pend>
                                  suffix_op: 
                                    (suffix_op.StringUnary
                                      op_id: VOp1_Pound
                                      arg_word: {(' ') ($ VSub_Name '$p')}
                                    )
                                  spids: [1963 1968]
                                )
                              )
                            }
                          spids: [1961]
                        )
                      ]
                      spids: [1961]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (C {(test)} {(-f)} {(DQ ($ VSub_Name '$rewritten')) (/) ($ VSub_Name '$p')})
                          ]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:new_p spids:[1989])
                                  op: Equal
                                  rhs: 
                                    {
                                      (word_part.CommandSubPart
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (C {(cat)} 
                                                {(DQ ($ VSub_Name '$rewritten')) (/) 
                                                  ($ VSub_Name '$p')
                                                }
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub '$('>
                                        spids: [1990 1998]
                                      )
                                    }
                                  spids: [1989]
                                )
                              ]
                              spids: [1989]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name '$new_p'))})]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:new_p spids:[2028])
                                          op: Equal
                                          rhs: 
                                            {
                                              (word_part.CommandSubPart
                                                command_list: 
                                                  (command.CommandList
                                                    children: [(C {(git)} {(rev-parse)} {(HEAD)})]
                                                  )
                                                left_token: <Left_CommandSub '$('>
                                                spids: [2029 2035]
                                              )
                                            }
                                          spids: [2028]
                                        )
                                      ]
                                      spids: [2028]
                                    )
                                  ]
                                  spids: [16777215 2025]
                                )
                              ]
                              spids: [16777215 2038]
                            )
                            (command.AndOr
                              ops: [Op_DAmp]
                              children: [
                                (C {(test)} {($ VSub_Name '$p')} {(KW_Bang '!') (Lit_Other '=')} 
                                  {($ VSub_Name '$new_p')}
                                )
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:fast_forward spids:[2053])
                                      op: Equal
                                      rhs: {(f)}
                                      spids: [2053]
                                    )
                                  ]
                                  spids: [2053]
                                )
                              ]
                            )
                            (command.Case
                              to_match: {(DQ ($ VSub_Name '$new_parents'))}
                              arms: [
                                (case_arm
                                  pat_list: [{(Lit_Other '*') ($ VSub_Name '$new_p') (Lit_Other '*')}]
                                  spids: [2066 2069 2072 16777215]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Other '*')}]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:new_parents spids:[2082])
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name '$new_parents') (' ') 
                                                ($ VSub_Name '$new_p')
                                              )
                                            }
                                          spids: [2082]
                                        )
                                      ]
                                      spids: [2082]
                                    )
                                  ]
                                  spids: [2078 2079 2090 16777215]
                                )
                              ]
                              spids: [2057 2063 2093]
                            )
                          ]
                          spids: [16777215 1986]
                        )
                      ]
                      else_action: [
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (C {(test)} {(-f)} 
                                  {(DQ ($ VSub_Name '$dropped')) (/) ($ VSub_Name '$p')}
                                )
                              ]
                              action: [
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:fast_forward spids:[2115])
                                      op: Equal
                                      rhs: {(f)}
                                      spids: [2115]
                                    )
                                  ]
                                  spids: [2115]
                                )
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:replacement spids:[2119])
                                      op: Equal
                                      rhs: 
                                        {
                                          (DQ 
                                            (word_part.CommandSubPart
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (C {(cat)} 
                                                      {(DQ ($ VSub_Name '$dropped')) (/) 
                                                        ($ VSub_Name '$p')
                                                      }
                                                    )
                                                  ]
                                                )
                                              left_token: <Left_CommandSub '$('>
                                              spids: [2121 2129]
                                            )
                                          )
                                        }
                                      spids: [2119]
                                    )
                                  ]
                                  spids: [2119]
                                )
                                (command.AndOr
                                  ops: [Op_DAmp]
                                  children: [
                                    (C {(test)} {(-z)} {(DQ ($ VSub_Name '$replacement'))})
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:replacement spids:[2143])
                                          op: Equal
                                          rhs: {(root)}
                                          spids: [2143]
                                        )
                                      ]
                                      spids: [2143]
                                    )
                                  ]
                                )
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:pend spids:[2147])
                                      op: Equal
                                      rhs: 
                                        {
                                          (DQ (' ') ($ VSub_Name '$replacement') ($ VSub_Name '$pend'))
                                        }
                                      spids: [2147]
                                    )
                                  ]
                                  spids: [2147]
                                )
                              ]
                              spids: [16777215 2112]
                            )
                          ]
                          else_action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:new_parents spids:[2158])
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name '$new_parents') (' ') ($ VSub_Name '$p'))}
                                  spids: [2158]
                                )
                              ]
                              spids: [2158]
                            )
                          ]
                          spids: [2155 2166]
                        )
                      ]
                      spids: [2096 2169]
                    )
                  ]
                  spids: [1942 2172]
                )
            )
            (command.Case
              to_match: {($ VSub_Name '$fast_forward')}
              arms: [
                (case_arm
                  pat_list: [{(t)}]
                  action: [
                    (C {(output)} {(warn)} 
                      {
                        (DQ 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ ('Fast-forward to ') 
                                        (word_part.EscapedLiteralPart
                                          token: <Lit_EscapedChar '\\$'>
                                        ) (sha1)
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [2191 2199]
                          )
                        )
                      }
                    )
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(output)} {(git)} {(reset)} {(--hard)} {($ VSub_Name '$sha1')})
                        (C {(die)} 
                          {
                            (DQ 
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(eval_gettext)} 
                                        {
                                          (DQ ('Cannot fast-forward to ') 
                                            (word_part.EscapedLiteralPart
                                              token: <Lit_EscapedChar '\\$'>
                                            ) (sha1)
                                          )
                                        }
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [2219 2227]
                              )
                            )
                          }
                        )
                      ]
                    )
                  ]
                  spids: [2182 2183 2231 16777215]
                )
                (case_arm
                  pat_list: [{(f)}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:first_parent spids:[2238])
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(expr)} {(DQ ($ VSub_Name '$new_parents'))} {(Lit_Other ':')} 
                                        {(SQ <' \\([^ ]*\\)'>)}
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [2239 2251]
                              )
                            }
                          spids: [2238]
                        )
                      ]
                      spids: [2238]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (C {(Lit_Other '[')} {(DQ ($ VSub_Number '$1'))} 
                              {(KW_Bang '!') (Lit_Other '=')} {(DQ (-n))} {(Lit_Other ']')}
                            )
                          ]
                          action: [
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (command.SimpleCommand
                                  words: [{(output)} {(git)} {(checkout)} {($ VSub_Name '$first_parent')}]
                                  redirects: [
                                    (redir.Redir
                                      op: <Redir_Great '2>'>
                                      fd: 2
                                      arg_word: {(/dev/null)}
                                    )
                                  ]
                                )
                                (C {(die)} 
                                  {
                                    (DQ 
                                      (word_part.CommandSubPart
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (C {(eval_gettext)} 
                                                {
                                                  (DQ ('Cannot move HEAD to ') 
                                                    (word_part.EscapedLiteralPart
                                                      token: <Lit_EscapedChar '\\$'>
                                                    ) (first_parent)
                                                  )
                                                }
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub '$('>
                                        spids: [2298 2306]
                                      )
                                    )
                                  }
                                )
                              ]
                            )
                          ]
                          spids: [16777215 2273]
                        )
                      ]
                      spids: [16777215 2310]
                    )
                    (command.Case
                      to_match: {(DQ ($ VSub_Name '$new_parents'))}
                      arms: [
                        (case_arm
                          pat_list: [{(SQ <' '>) (Lit_Other '*') (SQ <' '>) (Lit_Other '*')}]
                          action: [
                            (command.AndOr
                              ops: [Op_DAmp]
                              children: [
                                (C {(test)} {(DQ (a) ($ VSub_Number '$1'))} {(Lit_Other '=')} {(a-n)})
                                (C {(die)} 
                                  {
                                    (DQ 
                                      (word_part.CommandSubPart
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (C {(eval_gettext)} 
                                                {
                                                  (DQ ('Refusing to squash a merge: ') 
                                                    (word_part.EscapedLiteralPart
                                                      token: <Lit_EscapedChar '\\$'>
                                                    ) (sha1)
                                                  )
                                                }
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub '$('>
                                        spids: [2350 2358]
                                      )
                                    )
                                  }
                                )
                              ]
                            )
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:author_script_content spids:[2367])
                                  op: Equal
                                  rhs: 
                                    {
                                      (word_part.CommandSubPart
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (C {(get_author_ident_from_commit)} 
                                                {($ VSub_Name '$sha1')}
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub '$('>
                                        spids: [2368 2372]
                                      )
                                    }
                                  spids: [2367]
                                )
                              ]
                              spids: [2367]
                            )
                            (C {(eval)} {(DQ ($ VSub_Name '$author_script_content'))})
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:msg_content spids:[2382])
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (word_part.CommandSubPart
                                          command_list: 
                                            (command.CommandList
                                              children: [(C {(commit_message)} {($ VSub_Name '$sha1')})]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                          spids: [2384 2388]
                                        )
                                      )
                                    }
                                  spids: [2382]
                                )
                              ]
                              spids: [2382]
                            )
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:new_parents spids:[2396])
                                  op: Equal
                                  rhs: 
                                    {
                                      (word_part.BracedVarSub
                                        token: <VSub_Name new_parents>
                                        suffix_op: 
                                          (suffix_op.StringUnary
                                            op_id: VOp1_Pound
                                            arg_word: {(' ') ($ VSub_Name '$first_parent')}
                                          )
                                        spids: [2397 2402]
                                      )
                                    }
                                  spids: [2396]
                                )
                              ]
                              spids: [2396]
                            )
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:merge_args spids:[2405])
                                  op: Equal
                                  rhs: {(DQ ('--no-log --no-ff'))}
                                  spids: [2405]
                                )
                              ]
                              spids: [2405]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Pipeline
                                      children: [
                                        (C {(do_with_author)} {(output)} {(eval)} 
                                          {
                                            (SQ <'git merge ${gpg_sign_opt:+"$gpg_sign_opt"} \\\n'> 
                                              <
'\t\t\t\t$merge_args $strategy_args -m "$msg_content" $new_parents'
                                              >
                                            )
                                          }
                                        )
                                      ]
                                      negated: T
                                    )
                                  ]
                                  action: [
                                    (command.SimpleCommand
                                      words: [
                                        {(printf)}
                                        {(DQ ('%s') (Lit_Other '\\') (n))}
                                        {(DQ ($ VSub_Name '$msg_content'))}
                                      ]
                                      redirects: [
                                        (redir.Redir
                                          op: <Redir_Great '>'>
                                          fd: 16777215
                                          arg_word: {(DQ ($ VSub_Name '$GIT_DIR')) (/MERGE_MSG)}
                                        )
                                      ]
                                    )
                                    (C {(die_with_patch)} {($ VSub_Name '$sha1')} 
                                      {
                                        (DQ 
                                          (word_part.CommandSubPart
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (C {(eval_gettext)} 
                                                    {
                                                      (DQ ('Error redoing merge ') 
                                                        (word_part.EscapedLiteralPart
                                                          token: <Lit_EscapedChar '\\$'>
                                                        ) (sha1)
                                                      )
                                                    }
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub '$('>
                                            spids: [2457 2465]
                                          )
                                        )
                                      }
                                    )
                                  ]
                                  spids: [16777215 2429]
                                )
                              ]
                              spids: [16777215 2469]
                            )
                            (command.SimpleCommand
                              words: [
                                {(echo)}
                                {
                                  (DQ ($ VSub_Name '$sha1') (' ') 
                                    (word_part.CommandSubPart
                                      command_list: 
                                        (command.CommandList
                                          children: [
                                            (C {(git)} {(rev-parse)} {(HEAD) (Lit_Other '^') (0)})
                                          ]
                                        )
                                      left_token: <Left_CommandSub '$('>
                                      spids: [2477 2485]
                                    )
                                  )
                                }
                              ]
                              redirects: [
                                (redir.Redir
                                  op: <Redir_DGreat '>>'>
                                  fd: 16777215
                                  arg_word: {(DQ ($ VSub_Name '$rewritten_list'))}
                                )
                              ]
                            )
                          ]
                          spids: [2323 2331 2495 16777215]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other '*')}]
                          action: [
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {(output)} {(eval)} {(git)} {(cherry-pick)} 
                                  {
                                    (word_part.BracedVarSub
                                      token: <VSub_Name gpg_sign_opt>
                                      suffix_op: 
                                        (suffix_op.StringUnary
                                          op_id: VTest_ColonPlus
                                          arg_word: 
                                            {
                                              (word_part.CommandSubPart
                                                command_list: 
                                                  (command.CommandList
                                                    children: [
                                                      (C {(git)} {(rev-parse)} {(--sq-quote)} 
                                                        {(DQ ($ VSub_Name '$gpg_sign_opt'))}
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_CommandSub '$('>
                                                spids: [2515 2525]
                                              )
                                            }
                                        )
                                      spids: [2512 2526]
                                    )
                                  } {(DQ ($ VSub_Name '$strategy_args'))} {(DQ ($ VSub_At '$@'))}
                                )
                                (C {(die_with_patch)} {($ VSub_Name '$sha1')} 
                                  {
                                    (DQ 
                                      (word_part.CommandSubPart
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (C {(eval_gettext)} 
                                                {
                                                  (DQ ('Could not pick ') 
                                                    (word_part.EscapedLiteralPart
                                                      token: <Lit_EscapedChar '\\$'>
                                                    ) (sha1)
                                                  )
                                                }
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub '$('>
                                        spids: [2546 2554]
                                      )
                                    )
                                  }
                                )
                              ]
                            )
                          ]
                          spids: [2498 2499 2558 16777215]
                        )
                      ]
                      spids: [2314 2320 2561]
                    )
                  ]
                  spids: [2234 2235 2564 16777215]
                )
              ]
              spids: [2175 2179 2567]
            )
          ]
          spids: [1697]
        )
      spids: [1692 1696]
    )
    (command.FuncDef
      name: this_nth_commit_message
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:n spids:[2580])
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                  spids: [2580]
                )
              ]
              spids: [2580]
            )
            (C {(eval_gettext)} 
              {
                (DQ ('This is the commit message #') 
                  (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) ('{n}:')
                )
              }
            )
          ]
          spids: [2577]
        )
      spids: [2572 2576]
    )
    (command.FuncDef
      name: skip_nth_commit_message
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:n spids:[2603])
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                  spids: [2603]
                )
              ]
              spids: [2603]
            )
            (C {(eval_gettext)} 
              {
                (DQ ('The commit message #') 
                  (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) ('{n} will be skipped:')
                )
              }
            )
          ]
          spids: [2600]
        )
      spids: [2595 2599]
    )
    (command.FuncDef
      name: update_squash_messages
      body: 
        (command.BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: (C {(test)} {(-f)} {(DQ ($ VSub_Name '$squash_msg'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(mv)} {(DQ ($ VSub_Name '$squash_msg'))} 
                          {(DQ ($ VSub_Name '$squash_msg')) (.bak)}
                        )
                        (command.ControlFlow token:<ControlFlow_Exit exit>)
                      ]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:count spids:[2656])
                          op: Equal
                          rhs: 
                            {
                              (word_part.ArithSubPart
                                anode: 
                                  (arith_expr.ArithBinary
                                    op_id: Arith_Plus
                                    left: 
                                      (arith_expr.ArithWord
                                        w: 
                                          {
                                            (word_part.CommandSubPart
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (command.SimpleCommand
                                                      words: [
                                                        {(sed)}
                                                        {(-n)}
                                                        {(-e)}
                                                        {
                                                          (DQ ('1s/^') ($ VSub_Name '$comment_char') 
                                                            ('.*') (Lit_Other '\\') ('([0-9][0-9]*') (Lit_Other '\\') (').*/') (Lit_Other '\\') (1/p)
                                                          )
                                                        }
                                                        {(-e)}
                                                        {(DQ (q))}
                                                      ]
                                                      redirects: [
                                                        (redir.Redir
                                                          op: <Redir_Less '<'>
                                                          fd: 16777215
                                                          arg_word: 
                                                            {(DQ ($ VSub_Name '$squash_msg')) (.bak)}
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              left_token: <Left_CommandSub '$('>
                                              spids: [2658 2693]
                                            )
                                          }
                                      )
                                    right: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                                  )
                                spids: [2657 2697]
                              )
                            }
                          spids: [2656]
                        )
                      ]
                      spids: [2656]
                    )
                    (command.BraceGroup
                      children: [
                        (C {(printf)} {(SQ <'%s\\n'>)} 
                          {
                            (DQ ($ VSub_Name '$comment_char') (' ') 
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(eval_ngettext)} 
                                        {
                                          (DQ ('This is a combination of ') 
                                            (word_part.EscapedLiteralPart
                                              token: <Lit_EscapedChar '\\$'>
                                            ) ('count commit.')
                                          )
                                        } 
                                        {
                                          (DQ ('This is a combination of ') 
                                            (word_part.EscapedLiteralPart
                                              token: <Lit_EscapedChar '\\$'>
                                            ) ('count commits.')
                                          )
                                        } {($ VSub_Name '$count')}
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [2712 2734]
                              )
                            )
                          }
                        )
                        (command.SimpleCommand
                          words: [
                            {(sed)}
                            {(-e)}
                            {(1d)}
                            {(-e)}
                            {(SQ <'2,/^./{\n'> <'\t\t\t\t/^$/d\n'> <'\t\t\t}'>)}
                          ]
                          redirects: [
                            (redir.Redir
                              op: <Redir_Less '<'>
                              fd: 16777215
                              arg_word: {(DQ ($ VSub_Name '$squash_msg')) (.bak)}
                            )
                          ]
                        )
                      ]
                      redirects: [
                        (redir.Redir
                          op: <Redir_Great '>'>
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_Name '$squash_msg'))}
                        )
                      ]
                      spids: [2700]
                    )
                  ]
                  spids: [16777215 2637]
                )
              ]
              else_action: [
                (command.AndOr
                  ops: [Op_DPipe]
                  children: [
                    (command.SimpleCommand
                      words: [{(commit_message)} {(HEAD)}]
                      redirects: [
                        (redir.Redir
                          op: <Redir_Great '>'>
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_Name '$fixup_msg'))}
                        )
                      ]
                    )
                    (C {(die)} 
                      {
                        (DQ 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(gettext)} 
                                    {
                                      (DQ ('Cannot write ') 
                                        (word_part.EscapedLiteralPart
                                          token: <Lit_EscapedChar '\\$'>
                                        ) (fixup_msg)
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [2785 2793]
                          )
                        )
                      }
                    )
                  ]
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:count spids:[2797])
                      op: Equal
                      rhs: {(2)}
                      spids: [2797]
                    )
                  ]
                  spids: [2797]
                )
                (command.BraceGroup
                  children: [
                    (C {(printf)} {(SQ <'%s\\n'>)} 
                      {
                        (DQ ($ VSub_Name '$comment_char') (' ') 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(gettext)} {(DQ ('This is a combination of 2 commits.'))})
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [2813 2819]
                          )
                        )
                      }
                    )
                    (C {(printf)} {(SQ <'%s\\n'>)} 
                      {
                        (DQ ($ VSub_Name '$comment_char') (' ') 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [(C {(gettext)} {(DQ ('This is the 1st commit message:'))})]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [2832 2838]
                          )
                        )
                      }
                    )
                    (C {(echo)})
                    (C {(cat)} {(DQ ($ VSub_Name '$fixup_msg'))})
                  ]
                  redirects: [
                    (redir.Redir
                      op: <Redir_Great '>'>
                      fd: 16777215
                      arg_word: {(DQ ($ VSub_Name '$squash_msg'))}
                    )
                  ]
                  spids: [2801]
                )
              ]
              spids: [2767 2860]
            )
            (command.Case
              to_match: {($ VSub_Number '$1')}
              arms: [
                (case_arm
                  pat_list: [{(squash)}]
                  action: [
                    (C {(rm)} {(-f)} {(DQ ($ VSub_Name '$fixup_msg'))})
                    (C {(echo)})
                    (C {(printf)} {(SQ <'%s\\n'>)} 
                      {
                        (DQ ($ VSub_Name '$comment_char') (' ') 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [(C {(this_nth_commit_message)} {($ VSub_Name '$count')})]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [2895 2899]
                          )
                        )
                      }
                    )
                    (C {(echo)})
                    (C {(commit_message)} {($ VSub_Number '$2')})
                  ]
                  spids: [2870 2871 2911 16777215]
                )
                (case_arm
                  pat_list: [{(fixup)}]
                  action: [
                    (C {(echo)})
                    (C {(printf)} {(SQ <'%s\\n'>)} 
                      {
                        (DQ ($ VSub_Name '$comment_char') (' ') 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [(C {(skip_nth_commit_message)} {($ VSub_Name '$count')})]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [2930 2934]
                          )
                        )
                      }
                    )
                    (C {(echo)})
                    (command.Pipeline
                      children: [
                        (C {(commit_message)} {($ VSub_Number '$2')})
                        (C {(git)} {(stripspace)} {(--comment-lines)})
                        (C {(sed)} {(-e)} {(SQ <'s/ /\t/'>)})
                      ]
                      negated: F
                    )
                  ]
                  spids: [2914 2915 2968 16777215]
                )
              ]
              redirects: [
                (redir.Redir
                  op: <Redir_DGreat '>>'>
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_Name '$squash_msg'))}
                )
              ]
              spids: [2863 2867 2971]
            )
          ]
          spids: [2623]
        )
      spids: [2618 2622]
    )
    (command.FuncDef
      name: peek_next_command
      body: 
        (command.BraceGroup
          children: [
            (command.Pipeline
              children: [
                (command.SimpleCommand
                  words: [{(git)} {(stripspace)} {(--strip-comments)}]
                  redirects: [
                    (redir.Redir
                      op: <Redir_Less '<'>
                      fd: 16777215
                      arg_word: {(DQ ($ VSub_Name '$todo'))}
                    )
                  ]
                )
                (C {(sed)} {(-n)} {(-e)} {(SQ <'s/ .*//p'>)} {(-e)} {(q)})
              ]
              negated: F
            )
          ]
          spids: [2986]
        )
      spids: [2981 2985]
    )
    (command.FuncDef
      name: die_failed_squash
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:sha1 spids:[3044])
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                  spids: [3044]
                )
              ]
              spids: [3044]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:rest spids:[3048])
                  op: Equal
                  rhs: {($ VSub_Number '$2')}
                  spids: [3048]
                )
              ]
              spids: [3048]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(mv)} {(DQ ($ VSub_Name '$squash_msg'))} {(DQ ($ VSub_Name '$msg'))})
                (command.ControlFlow token:<ControlFlow_Exit exit>)
              ]
            )
            (C {(rm)} {(-f)} {(DQ ($ VSub_Name '$fixup_msg'))})
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(cp)} {(DQ ($ VSub_Name '$msg'))} {(DQ ($ VSub_Name '$GIT_DIR')) (/MERGE_MSG)})
                (command.ControlFlow token:<ControlFlow_Exit exit>)
              ]
            )
            (C {(warn)})
            (C {(warn)} 
              {
                (DQ 
                  (word_part.CommandSubPart
                    command_list: 
                      (command.CommandList
                        children: [
                          (C {(eval_gettext)} 
                            {
                              (DQ ('Could not apply ') 
                                (word_part.EscapedLiteralPart
                                  token: <Lit_EscapedChar '\\$'>
                                ) ('sha1... ') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) (rest)
                              )
                            }
                          )
                        ]
                      )
                    left_token: <Left_CommandSub '$('>
                    spids: [3098 3108]
                  )
                )
              }
            )
            (C {(die_with_patch)} {($ VSub_Name '$sha1')} {(DQ )})
          ]
          spids: [3041]
        )
      spids: [3037 3040]
    )
    (command.FuncDef
      name: flush_rewritten_pending
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(test)} {(-s)} {(DQ ($ VSub_Name '$rewritten_pending'))})
                (command.ControlFlow token:<ControlFlow_Return return>)
              ]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:newsha1 spids:[3142])
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (word_part.CommandSubPart
                          command_list: 
                            (command.CommandList
                              children: [(C {(git)} {(rev-parse)} {(HEAD) (Lit_Other '^') (0)})]
                            )
                          left_token: <Left_CommandSub '$('>
                          spids: [3144 3152]
                        )
                      )
                    }
                  spids: [3142]
                )
              ]
              spids: [3142]
            )
            (command.SimpleCommand
              words: [{(sed)} {(DQ (s/) (Lit_Other '$') ('/ ') ($ VSub_Name '$newsha1') (/))}]
              redirects: [
                (redir.Redir
                  op: <Redir_Less '<'>
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_Name '$rewritten_pending'))}
                )
                (redir.Redir
                  op: <Redir_DGreat '>>'>
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_Name '$rewritten_list'))}
                )
              ]
            )
            (C {(rm)} {(-f)} {(DQ ($ VSub_Name '$rewritten_pending'))})
          ]
          spids: [3126]
        )
      spids: [3122 3125]
    )
    (command.FuncDef
      name: record_in_rewritten
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:oldsha1 spids:[3197])
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (word_part.CommandSubPart
                          command_list: 
                            (command.CommandList
                              children: [(C {(git)} {(rev-parse)} {($ VSub_Number '$1')})]
                            )
                          left_token: <Left_CommandSub '$('>
                          spids: [3199 3205]
                        )
                      )
                    }
                  spids: [3197]
                )
              ]
              spids: [3197]
            )
            (command.SimpleCommand
              words: [{(echo)} {(DQ ($ VSub_Name '$oldsha1'))}]
              redirects: [
                (redir.Redir
                  op: <Redir_DGreat '>>'>
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_Name '$rewritten_pending'))}
                )
              ]
            )
            (command.Case
              to_match: 
                {
                  (DQ 
                    (word_part.CommandSubPart
                      command_list: (command.CommandList children:[(C {(peek_next_command)})])
                      left_token: <Left_CommandSub '$('>
                      spids: [3226 3228]
                    )
                  )
                }
              arms: [
                (case_arm
                  pat_list: [{(squash)} {(s)} {(fixup)} {(f)}]
                  spids: [3234 3241 3244 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [(C {(flush_rewritten_pending)})]
                  spids: [3247 3248 3254 16777215]
                )
              ]
              spids: [3223 3231 3257]
            )
          ]
          spids: [3194]
        )
      spids: [3190 3193]
    )
    (command.FuncDef
      name: do_pick
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:sha1 spids:[3270])
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                  spids: [3270]
                )
              ]
              spids: [3270]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:rest spids:[3274])
                  op: Equal
                  rhs: {($ VSub_Number '$2')}
                  spids: [3274]
                )
              ]
              spids: [3274]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (C {(test)} 
                      {
                        (DQ 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [(C {(git)} {(rev-parse)} {(HEAD)})]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [3283 3289]
                          )
                        )
                      } {(Lit_Other '=')} {(DQ ($ VSub_Name '$squash_onto'))}
                    )
                  ]
                  action: [
                    (command.AndOr
                      ops: [Op_DAmp Op_DAmp Op_DPipe]
                      children: [
                        (C {(git)} {(commit)} {(--allow-empty)} {(--allow-empty-message)} {(--amend)} 
                          {(--no-post-rewrite)} {(-n)} {(-q)} {(-C)} {($ VSub_Name '$sha1')}
                        )
                        (C {(pick_one)} {(-n)} {($ VSub_Name '$sha1')})
                        (C {(git)} {(commit)} {(--allow-empty)} {(--allow-empty-message)} {(--amend)} 
                          {(--no-post-rewrite)} {(-n)} {(-q)} {(-C)} {($ VSub_Name '$sha1')} 
                          {
                            (word_part.BracedVarSub
                              token: <VSub_Name gpg_sign_opt>
                              suffix_op: 
                                (suffix_op.StringUnary
                                  op_id: VTest_ColonPlus
                                  arg_word: {(DQ ($ VSub_Name '$gpg_sign_opt'))}
                                )
                              spids: [3392 3398]
                            )
                          }
                        )
                        (C {(die_with_patch)} {($ VSub_Name '$sha1')} 
                          {
                            (DQ 
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(eval_gettext)} 
                                        {
                                          (DQ ('Could not apply ') 
                                            (word_part.EscapedLiteralPart
                                              token: <Lit_EscapedChar '\\$'>
                                            ) ('sha1... ') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) (rest)
                                          )
                                        }
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [3408 3418]
                              )
                            )
                          }
                        )
                      ]
                    )
                  ]
                  spids: [16777215 3299]
                )
              ]
              else_action: [
                (command.AndOr
                  ops: [Op_DPipe]
                  children: [
                    (C {(pick_one)} {($ VSub_Name '$sha1')})
                    (C {(die_with_patch)} {($ VSub_Name '$sha1')} 
                      {
                        (DQ 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ ('Could not apply ') 
                                        (word_part.EscapedLiteralPart
                                          token: <Lit_EscapedChar '\\$'>
                                        ) ('sha1... ') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) (rest)
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [3437 3447]
                          )
                        )
                      }
                    )
                  ]
                )
              ]
              spids: [3422 3451]
            )
          ]
          spids: [3267]
        )
      spids: [3262 3266]
    )
    (command.FuncDef
      name: do_next
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(rm)} {(-f)} {(DQ ($ VSub_Name '$msg'))} {(DQ ($ VSub_Name '$author_script'))} 
                  {(DQ ($ VSub_Name '$amend'))} {(DQ ($ VSub_Name '$state_dir')) (/stopped-sha)}
                )
                (command.ControlFlow token:<ControlFlow_Exit exit>)
              ]
            )
            (command.SimpleCommand
              words: [{(read)} {(-r)} {(command)} {(sha1)} {(rest)}]
              redirects: [
                (redir.Redir
                  op: <Redir_Less '<'>
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_Name '$todo'))}
                )
              ]
            )
            (command.Case
              to_match: {(DQ ($ VSub_Name '$command'))}
              arms: [
                (case_arm
                  pat_list: [
                    {(DQ ($ VSub_Name '$comment_char')) (Lit_Other '*')}
                    {(SQ )}
                    {(noop)}
                    {(drop)}
                    {(d)}
                  ]
                  action: [(C {(mark_action_done)})]
                  spids: [3516 3529 3535 16777215]
                )
                (case_arm
                  pat_list: [{(DQ ($ VSub_Name '$cr'))}]
                  action: [(C {(mark_action_done)})]
                  spids: [3538 3541 3551 16777215]
                )
                (case_arm
                  pat_list: [{(pick)} {(p)}]
                  action: [
                    (C {(comment_for_reflog)} {(pick)})
                    (C {(mark_action_done)})
                    (C {(do_pick)} {($ VSub_Name '$sha1')} {(DQ ($ VSub_Name '$rest'))})
                    (C {(record_in_rewritten)} {($ VSub_Name '$sha1')})
                  ]
                  spids: [3554 3557 3583 16777215]
                )
                (case_arm
                  pat_list: [{(reword)} {(r)}]
                  action: [
                    (C {(comment_for_reflog)} {(reword)})
                    (C {(mark_action_done)})
                    (C {(do_pick)} {($ VSub_Name '$sha1')} {(DQ ($ VSub_Name '$rest'))})
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(git)} {(commit)} {(--amend)} {(--no-post-rewrite)} 
                          {
                            (word_part.BracedVarSub
                              token: <VSub_Name gpg_sign_opt>
                              suffix_op: 
                                (suffix_op.StringUnary
                                  op_id: VTest_ColonPlus
                                  arg_word: {(DQ ($ VSub_Name '$gpg_sign_opt'))}
                                )
                              spids: [3618 3624]
                            )
                          }
                        )
                        (command.BraceGroup
                          children: [
                            (C {(warn)} 
                              {
                                (DQ 
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(eval_gettext)} 
                                            {
                                              (DQ 
                                                (
'Could not amend commit after successfully picking '
                                                ) (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) ('sha1... ') 
                                                (word_part.EscapedLiteralPart
                                                  token: <Lit_EscapedChar '\\$'>
                                                ) ('rest\n') ('This is most likely due to an empty commit message, or the pre-commit hook\n') 
                                                (
'failed. If the pre-commit hook failed, you may need to resolve the issue before\n'
                                                ) ('you are able to reword the commit.')
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [3634 3648]
                                  )
                                )
                              }
                            )
                            (C {(exit_with_patch)} {($ VSub_Name '$sha1')} {(1)})
                          ]
                          spids: [3628]
                        )
                      ]
                    )
                    (C {(record_in_rewritten)} {($ VSub_Name '$sha1')})
                  ]
                  spids: [3586 3589 3667 16777215]
                )
                (case_arm
                  pat_list: [{(edit)} {(e)}]
                  action: [
                    (C {(comment_for_reflog)} {(edit)})
                    (C {(mark_action_done)})
                    (C {(do_pick)} {($ VSub_Name '$sha1')} {(DQ ($ VSub_Name '$rest'))})
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:sha1_abbrev spids:[3694])
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(git)} {(rev-parse)} {(--short)} {($ VSub_Name '$sha1')})
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [3695 3703]
                              )
                            }
                          spids: [3694]
                        )
                      ]
                      spids: [3694]
                    )
                    (C {(warn)} 
                      {
                        (DQ 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ ('Stopped at ') 
                                        (word_part.EscapedLiteralPart
                                          token: <Lit_EscapedChar '\\$'>
                                        ) ('sha1_abbrev... ') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) (rest)
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [3709 3719]
                          )
                        )
                      }
                    )
                    (C {(exit_with_patch)} {($ VSub_Name '$sha1')} {(0)})
                  ]
                  spids: [3670 3673 3730 16777215]
                )
                (case_arm
                  pat_list: [{(squash)} {(s)} {(fixup)} {(f)}]
                  action: [
                    (command.Case
                      to_match: {(DQ ($ VSub_Name '$command'))}
                      arms: [
                        (case_arm
                          pat_list: [{(squash)} {(s)}]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:squash_style spids:[3758])
                                  op: Equal
                                  rhs: {(squash)}
                                  spids: [3758]
                                )
                              ]
                              spids: [3758]
                            )
                          ]
                          spids: [3752 3755 3762 16777215]
                        )
                        (case_arm
                          pat_list: [{(fixup)} {(f)}]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:squash_style spids:[3771])
                                  op: Equal
                                  rhs: {(fixup)}
                                  spids: [3771]
                                )
                              ]
                              spids: [3771]
                            )
                          ]
                          spids: [3765 3768 3775 16777215]
                        )
                      ]
                      spids: [3743 3749 3778]
                    )
                    (C {(comment_for_reflog)} {($ VSub_Name '$squash_style')})
                    (command.AndOr
                      ops: [Op_DAmp Op_DPipe]
                      children: [
                        (C {(test)} {(-f)} {(DQ ($ VSub_Name '$done'))})
                        (C {(has_action)} {(DQ ($ VSub_Name '$done'))})
                        (C {(die)} 
                          {
                            (DQ 
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(eval_gettext)} 
                                        {
                                          (DQ ("Cannot '") 
                                            (word_part.EscapedLiteralPart
                                              token: <Lit_EscapedChar '\\$'>
                                            ) ("squash_style' without a previous commit")
                                          )
                                        }
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [3809 3817]
                              )
                            )
                          }
                        )
                      ]
                    )
                    (C {(mark_action_done)})
                    (C {(update_squash_messages)} {($ VSub_Name '$squash_style')} 
                      {($ VSub_Name '$sha1')}
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:author_script_content spids:[3832])
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [(C {(get_author_ident_from_commit)} {(HEAD)})]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [3833 3837]
                              )
                            }
                          spids: [3832]
                        )
                      ]
                      spids: [3832]
                    )
                    (command.SimpleCommand
                      words: [{(echo)} {(DQ ($ VSub_Name '$author_script_content'))}]
                      redirects: [
                        (redir.Redir
                          op: <Redir_Great '>'>
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_Name '$author_script'))}
                        )
                      ]
                    )
                    (C {(eval)} {(DQ ($ VSub_Name '$author_script_content'))})
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Pipeline
                              children: [(C {(pick_one)} {(-n)} {($ VSub_Name '$sha1')})]
                              negated: T
                            )
                          ]
                          action: [
                            (command.SimpleCommand
                              words: [{(git)} {(rev-parse)} {(--verify)} {(HEAD)}]
                              redirects: [
                                (redir.Redir
                                  op: <Redir_Great '>'>
                                  fd: 16777215
                                  arg_word: {(DQ ($ VSub_Name '$amend'))}
                                )
                              ]
                            )
                            (C {(die_failed_squash)} {($ VSub_Name '$sha1')} {(DQ ($ VSub_Name '$rest'))})
                          ]
                          spids: [16777215 3871]
                        )
                      ]
                      spids: [16777215 3897]
                    )
                    (command.Case
                      to_match: 
                        {
                          (DQ 
                            (word_part.CommandSubPart
                              command_list: 
                                (command.CommandList
                                  children: [(C {(peek_next_command)})]
                                )
                              left_token: <Left_CommandSub '$('>
                              spids: [3903 3905]
                            )
                          )
                        }
                      arms: [
                        (case_arm
                          pat_list: [{(squash)} {(s)} {(fixup)} {(f)}]
                          action: [
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {(do_with_author)} {(output)} {(git)} {(commit)} {(--amend)} 
                                  {(--no-verify)} {(-F)} {(DQ ($ VSub_Name '$squash_msg'))} 
                                  {
                                    (word_part.BracedVarSub
                                      token: <VSub_Name gpg_sign_opt>
                                      suffix_op: 
                                        (suffix_op.StringUnary
                                          op_id: VTest_ColonPlus
                                          arg_word: {(DQ ($ VSub_Name '$gpg_sign_opt'))}
                                        )
                                      spids: [3949 3955]
                                    )
                                  }
                                )
                                (C {(die_failed_squash)} {($ VSub_Name '$sha1')} 
                                  {(DQ ($ VSub_Name '$rest'))}
                                )
                              ]
                            )
                          ]
                          spids: [3911 3918 3969 16777215]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other '*')}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [(C {(test)} {(-f)} {(DQ ($ VSub_Name '$fixup_msg'))})]
                                  action: [
                                    (command.AndOr
                                      ops: [Op_DPipe]
                                      children: [
                                        (C {(do_with_author)} {(git)} {(commit)} {(--amend)} 
                                          {(--no-verify)} {(-F)} {(DQ ($ VSub_Name '$fixup_msg'))} 
                                          {
                                            (word_part.BracedVarSub
                                              token: <VSub_Name gpg_sign_opt>
                                              suffix_op: 
                                                (suffix_op.StringUnary
                                                  op_id: VTest_ColonPlus
                                                  arg_word: {(DQ ($ VSub_Name '$gpg_sign_opt'))}
                                                )
                                              spids: [4012 4018]
                                            )
                                          }
                                        )
                                        (C {(die_failed_squash)} {($ VSub_Name '$sha1')} 
                                          {(DQ ($ VSub_Name '$rest'))}
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [16777215 3991]
                                )
                              ]
                              else_action: [
                                (command.AndOr
                                  ops: [Op_DPipe]
                                  children: [
                                    (C {(cp)} {(DQ ($ VSub_Name '$squash_msg'))} 
                                      {(DQ ($ VSub_Name '$GIT_DIR')) (/SQUASH_MSG)}
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Exit exit>
                                    )
                                  ]
                                )
                                (C {(rm)} {(-f)} {(DQ ($ VSub_Name '$GIT_DIR')) (/MERGE_MSG)})
                                (command.AndOr
                                  ops: [Op_DPipe]
                                  children: [
                                    (C {(do_with_author)} {(git)} {(commit)} {(--amend)} {(--no-verify)} 
                                      {(-F)} {(DQ ($ VSub_Name '$GIT_DIR')) (/SQUASH_MSG)} {(-e)} 
                                      {
                                        (word_part.BracedVarSub
                                          token: <VSub_Name gpg_sign_opt>
                                          suffix_op: 
                                            (suffix_op.StringUnary
                                              op_id: VTest_ColonPlus
                                              arg_word: {(DQ ($ VSub_Name '$gpg_sign_opt'))}
                                            )
                                          spids: [4082 4088]
                                        )
                                      }
                                    )
                                    (C {(die_failed_squash)} {($ VSub_Name '$sha1')} 
                                      {(DQ ($ VSub_Name '$rest'))}
                                    )
                                  ]
                                )
                              ]
                              spids: [4032 4102]
                            )
                            (C {(rm)} {(-f)} {(DQ ($ VSub_Name '$squash_msg'))} 
                              {(DQ ($ VSub_Name '$fixup_msg'))}
                            )
                          ]
                          spids: [3972 3973 4118 16777215]
                        )
                      ]
                      spids: [3900 3908 4121]
                    )
                    (C {(record_in_rewritten)} {($ VSub_Name '$sha1')})
                  ]
                  spids: [3733 3740 4129 16777215]
                )
                (case_arm
                  pat_list: [{(x)} {(DQ (exec))}]
                  action: [
                    (command.SimpleCommand
                      words: [{(read)} {(-r)} {(command)} {(rest)}]
                      redirects: [
                        (redir.Redir
                          op: <Redir_Less '<'>
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_Name '$todo'))}
                        )
                      ]
                    )
                    (C {(mark_action_done)})
                    (C {(eval_gettextln)} 
                      {
                        (DQ ('Executing: ') 
                          (word_part.EscapedLiteralPart
                            token: <Lit_EscapedChar '\\$'>
                          ) (rest)
                        )
                      }
                    )
                    (C 
                      {
                        (DQ 
                          (word_part.BracedVarSub
                            token: <VSub_Name SHELL>
                            suffix_op: 
                              (suffix_op.StringUnary
                                op_id: VTest_ColonHyphen
                                arg_word: {('@SHELL_PATH@')}
                              )
                            spids: [4168 4172]
                          )
                        )
                      } {(-c)} {(DQ ($ VSub_Name '$rest'))}
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:status spids:[4185])
                          op: Equal
                          rhs: {($ VSub_QMark '$?')}
                          spids: [4185]
                        )
                      ]
                      spids: [4185]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:dirty spids:[4193])
                          op: Equal
                          rhs: {(f)}
                          spids: [4193]
                        )
                      ]
                      spids: [4193]
                    )
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (command.Subshell
                          child: 
                            (command.SimpleCommand
                              words: [{(require_clean_work_tree)} {(DQ (rebase))}]
                              redirects: [
                                (redir.Redir
                                  op: <Redir_Great '2>'>
                                  fd: 2
                                  arg_word: {(/dev/null)}
                                )
                              ]
                            )
                          spids: [4197 4206]
                        )
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:dirty spids:[4210])
                              op: Equal
                              rhs: {(t)}
                              spids: [4210]
                            )
                          ]
                          spids: [4210]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [(C {(test)} {(DQ ($ VSub_Name '$status'))} {(-ne)} {(0)})]
                          action: [
                            (C {(warn)} 
                              {
                                (DQ 
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(eval_gettext)} 
                                            {
                                              (DQ ('Execution failed: ') 
                                                (word_part.EscapedLiteralPart
                                                  token: <Lit_EscapedChar '\\$'>
                                                ) (rest)
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [4233 4241]
                                  )
                                )
                              }
                            )
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {(test)} {(DQ ($ VSub_Name '$dirty'))} {(Lit_Other '=')} {(f)})
                                (C {(warn)} 
                                  {
                                    (DQ 
                                      (word_part.CommandSubPart
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (C {(gettext)} 
                                                {
                                                  (DQ 
                                                    (
'and made changes to the index and/or the working tree'
                                                    )
                                                  )
                                                }
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub '$('>
                                        spids: [4261 4267]
                                      )
                                    )
                                  }
                                )
                              ]
                            )
                            (C {(warn)} 
                              {
                                (DQ 
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(gettext)} 
                                            {
                                              (DQ ('You can fix the problem, and then run\n') ('\n') 
                                                ('\tgit rebase --continue')
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [4275 4284]
                                  )
                                )
                              }
                            )
                            (C {(warn)})
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [(C {(test)} {($ VSub_Name '$status')} {(-eq)} {(127)})]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:status spids:[4308])
                                          op: Equal
                                          rhs: {(1)}
                                          spids: [4308]
                                        )
                                      ]
                                      spids: [4308]
                                    )
                                  ]
                                  spids: [16777215 4305]
                                )
                              ]
                              spids: [16777215 4312]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Exit exit>
                              arg_word: {(DQ ($ VSub_Name '$status'))}
                            )
                          ]
                          spids: [16777215 4227]
                        )
                        (if_arm
                          cond: [(C {(test)} {(DQ ($ VSub_Name '$dirty'))} {(Lit_Other '=')} {(t)})]
                          action: [
                            (C {(warn)} 
                              {
                                (DQ 
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(eval_gettext)} 
                                            {
                                              (DQ ('Execution succeeded: ') 
                                                (word_part.EscapedLiteralPart
                                                  token: <Lit_EscapedChar '\\$'>
                                                ) ('rest\n') ('but left changes to the index and/or the working tree\n') 
                                                ('Commit or stash your changes, and then run\n') ('\n') ('\tgit rebase --continue')
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [4345 4358]
                                  )
                                )
                              }
                            )
                            (C {(warn)})
                            (command.ControlFlow
                              token: <ControlFlow_Exit exit>
                              arg_word: {(1)}
                            )
                          ]
                          spids: [4322 4335]
                        )
                      ]
                      spids: [16777215 4370]
                    )
                  ]
                  spids: [4132 4137 4373 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [
                    (C {(warn)} 
                      {
                        (DQ 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ ('Unknown command: ') 
                                        (word_part.EscapedLiteralPart
                                          token: <Lit_EscapedChar '\\$'>
                                        ) ('command ') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) ('sha1 ') 
                                        (word_part.EscapedLiteralPart
                                          token: <Lit_EscapedChar '\\$'>
                                        ) (rest)
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [4383 4395]
                          )
                        )
                      }
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:fixtodo spids:[4399])
                          op: Equal
                          rhs: 
                            {
                              (DQ 
                                (word_part.CommandSubPart
                                  command_list: 
                                    (command.CommandList
                                      children: [
                                        (C {(gettext)} 
                                          {(DQ ("Please fix this using 'git rebase --edit-todo'."))}
                                        )
                                      ]
                                    )
                                  left_token: <Left_CommandSub '$('>
                                  spids: [4401 4407]
                                )
                              )
                            }
                          spids: [4399]
                        )
                      ]
                      spids: [4399]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.SimpleCommand
                              words: [
                                {(git)}
                                {(rev-parse)}
                                {(--verify)}
                                {(-q)}
                                {(DQ ($ VSub_Name '$sha1'))}
                              ]
                              redirects: [
                                (redir.Redir
                                  op: <Redir_Great '>'>
                                  fd: 16777215
                                  arg_word: {(/dev/null)}
                                )
                              ]
                            )
                          ]
                          action: [
                            (C {(die_with_patch)} {($ VSub_Name '$sha1')} {(DQ ($ VSub_Name '$fixtodo'))})
                          ]
                          spids: [16777215 4429]
                        )
                      ]
                      else_action: [(C {(die)} {(DQ ($ VSub_Name '$fixtodo'))})]
                      spids: [4441 4451]
                    )
                  ]
                  spids: [4376 4377 4454 16777215]
                )
              ]
              spids: [3507 3513 4457]
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-s)} {(DQ ($ VSub_Name '$todo'))})
                (command.ControlFlow token:<ControlFlow_Return return>)
              ]
            )
            (command.AndOr
              ops: [Op_DAmp Op_DAmp Op_DAmp Op_DAmp Op_DAmp]
              children: [
                (C {(comment_for_reflog)} {(finish)})
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:newhead spids:[4481])
                      op: Equal
                      rhs: 
                        {
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [(C {(git)} {(rev-parse)} {(HEAD)})]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [4482 4488]
                          )
                        }
                      spids: [4481]
                    )
                  ]
                  spids: [4481]
                )
                (command.Case
                  to_match: {($ VSub_Name '$head_name')}
                  arms: [
                    (case_arm
                      pat_list: [{(refs/) (Lit_Other '*')}]
                      action: [
                        (command.AndOr
                          ops: [Op_DAmp Op_DAmp]
                          children: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:message spids:[4505])
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ ($ VSub_Name '$GIT_REFLOG_ACTION') (': ') 
                                        ($ VSub_Name '$head_name') (' onto ') ($ VSub_Name '$onto')
                                      )
                                    }
                                  spids: [4505]
                                )
                              ]
                              spids: [4505]
                            )
                            (C {(git)} {(update-ref)} {(-m)} {(DQ ($ VSub_Name '$message'))} 
                              {($ VSub_Name '$head_name')} {($ VSub_Name '$newhead')} {($ VSub_Name '$orig_head')}
                            )
                            (C {(git)} {(symbolic-ref)} {(-m)} 
                              {
                                (DQ ($ VSub_Name '$GIT_REFLOG_ACTION') (': returning to ') 
                                  ($ VSub_Name '$head_name')
                                )
                              } {(HEAD)} {($ VSub_Name '$head_name')}
                            )
                          ]
                        )
                      ]
                      spids: [4500 4502 4557 16777215]
                    )
                  ]
                  spids: [4493 4497 4560]
                )
                (command.BraceGroup
                  children: [
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(test)} {(KW_Bang '!')} {(-f)} {(DQ ($ VSub_Name '$state_dir')) (/verbose)})
                        (C {(git)} {(diff-tree)} {(--stat)} {($ VSub_Name '$orig_head') (..HEAD)})
                      ]
                    )
                  ]
                  spids: [4564]
                )
                (command.BraceGroup
                  children: [
                    (command.AndOr
                      ops: [Op_DAmp Op_DPipe]
                      children: [
                        (C {(test)} {(-s)} {(DQ ($ VSub_Name '$rewritten_list'))})
                        (command.SimpleCommand
                          words: [{(git)} {(notes)} {(copy)} {(--for-rewrite) (Lit_Other '=') (rebase)}]
                          redirects: [
                            (redir.Redir
                              op: <Redir_Less '<'>
                              fd: 16777215
                              arg_word: {(DQ ($ VSub_Name '$rewritten_list'))}
                            )
                          ]
                        )
                        (C {(true)})
                      ]
                    )
                  ]
                  spids: [4596]
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:hook spids:[4640])
                      op: Equal
                      rhs: 
                        {
                          (DQ 
                            (word_part.CommandSubPart
                              command_list: 
                                (command.CommandList
                                  children: [
                                    (C {(git)} {(rev-parse)} {(--git-path)} {(hooks/post-rewrite)})
                                  ]
                                )
                              left_token: <Left_CommandSub '$('>
                              spids: [4642 4650]
                            )
                          )
                        }
                      spids: [4640]
                    )
                  ]
                  spids: [4640]
                )
              ]
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (command.If
                  arms: [
                    (if_arm
                      cond: [
                        (command.Sentence
                          child: 
                            (command.AndOr
                              ops: [Op_DAmp]
                              children: [
                                (C {(test)} {(-x)} {(DQ ($ VSub_Name '$hook'))})
                                (C {(test)} {(-s)} {(DQ ($ VSub_Name '$rewritten_list'))})
                              ]
                            )
                          terminator: <Op_Semi ';'>
                        )
                      ]
                      action: [
                        (command.SimpleCommand
                          words: [{(DQ ($ VSub_Name '$hook'))} {(rebase)}]
                          redirects: [
                            (redir.Redir
                              op: <Redir_Less '<'>
                              fd: 16777215
                              arg_word: {(DQ ($ VSub_Name '$rewritten_list'))}
                            )
                          ]
                        )
                        (C {(true)})
                      ]
                      spids: [16777215 4675]
                    )
                  ]
                  spids: [16777215 4697]
                )
                (C {(warn)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {(eval_gettext)} 
                                {
                                  (DQ ('Successfully rebased and updated ') 
                                    (word_part.EscapedLiteralPart
                                      token: <Lit_EscapedChar '\\$'>
                                    ) (head_name.)
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [4705 4713]
                      )
                    )
                  }
                )
              ]
            )
            (command.ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
          ]
          spids: [3461]
        )
      spids: [3456 3460]
    )
    (command.FuncDef
      name: do_rest
      body: 
        (command.BraceGroup
          children: [
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [(C {(Lit_Other ':')})]
              body: 
                (command.DoGroup
                  children: [
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [(C {(do_next)}) (command.ControlFlow token:<ControlFlow_Break break>)]
                    )
                  ]
                  spids: [4744 4754]
                )
            )
          ]
          spids: [4736]
        )
      spids: [4731 4735]
    )
    (command.FuncDef
      name: skip_unnecessary_picks
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:fd spids:[4770])
                  op: Equal
                  rhs: {(3)}
                  spids: [4770]
                )
              ]
              spids: [4770]
            )
            (command.AndOr
              ops: [Op_DAmp Op_DAmp Op_DPipe]
              children: [
                (command.WhileUntil
                  keyword: <KW_While while>
                  cond: [(C {(read)} {(-r)} {(command)} {(rest)})]
                  body: 
                    (command.DoGroup
                      children: [
                        (command.Case
                          to_match: {(DQ ($ VSub_Name '$fd') (',') ($ VSub_Name '$command'))}
                          arms: [
                            (case_arm
                              pat_list: [{(3) (Lit_Comma ',') (pick)} {(3) (Lit_Comma ',') (p)}]
                              action: [
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:sha1 spids:[4817])
                                      op: Equal
                                      rhs: 
                                        {
                                          (word_part.BracedVarSub
                                            token: <VSub_Name rest>
                                            suffix_op: 
                                              (suffix_op.StringUnary
                                                op_id: VOp1_DPercent
                                                arg_word: {(' *')}
                                              )
                                            spids: [4818 4822]
                                          )
                                        }
                                      spids: [4817]
                                    )
                                  ]
                                  spids: [4817]
                                )
                                (command.Case
                                  to_match: 
                                    {
                                      (DQ 
                                        (word_part.CommandSubPart
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {(git)} {(rev-parse)} {(--verify)} {(--quiet)} 
                                                  {(DQ ($ VSub_Name '$sha1')) (Lit_Other '^')}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                          spids: [4828 4841]
                                        )
                                      )
                                    }
                                  arms: [
                                    (case_arm
                                      pat_list: [{(DQ ($ VSub_Name '$onto')) (Lit_Other '*')}]
                                      action: [
                                        (command.Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (lhs_expr.LhsName name:onto spids:[4854])
                                              op: Equal
                                              rhs: {($ VSub_Name '$sha1')}
                                              spids: [4854]
                                            )
                                          ]
                                          spids: [4854]
                                        )
                                      ]
                                      spids: [4847 4851 4858 16777215]
                                    )
                                    (case_arm
                                      pat_list: [{(Lit_Other '*')}]
                                      action: [
                                        (command.Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (lhs_expr.LhsName name:fd spids:[4865])
                                              op: Equal
                                              rhs: {(1)}
                                              spids: [4865]
                                            )
                                          ]
                                          spids: [4865]
                                        )
                                      ]
                                      spids: [4861 4862 4869 16777215]
                                    )
                                  ]
                                  spids: [4825 4844 4872]
                                )
                              ]
                              spids: [4803 4810 4875 16777215]
                            )
                            (case_arm
                              pat_list: [
                                {(3) (Lit_Comma ',') (DQ ($ VSub_Name '$comment_char')) 
                                  (Lit_Other '*')
                                }
                                {(3) (Lit_Comma ',')}
                              ]
                              spids: [4878 4887 4894 16777215]
                            )
                            (case_arm
                              pat_list: [{(Lit_Other '*')}]
                              action: [
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:fd spids:[4901])
                                      op: Equal
                                      rhs: {(1)}
                                      spids: [4901]
                                    )
                                  ]
                                  spids: [4901]
                                )
                              ]
                              spids: [4897 4898 4905 16777215]
                            )
                          ]
                          spids: [4792 4800 4908]
                        )
                        (command.SimpleCommand
                          words: [
                            {(printf)}
                            {(SQ <'%s\\n'>)}
                            {
                              (DQ ($ VSub_Name '$command') 
                                (word_part.BracedVarSub
                                  token: <VSub_Name rest>
                                  suffix_op: 
                                    (suffix_op.StringUnary
                                      op_id: VTest_ColonPlus
                                      arg_word: {(' ')}
                                    )
                                  spids: [4919 4923]
                                ) ($ VSub_Name '$rest')
                              )
                            }
                          ]
                          redirects: [
                            (redir.Redir
                              op: <Redir_GreatAnd '>&'>
                              fd: 16777215
                              arg_word: {($ VSub_Name '$fd')}
                            )
                          ]
                        )
                      ]
                      spids: [4785 4931]
                    )
                  redirects: [
                    (redir.Redir
                      op: <Redir_Less '<'>
                      fd: 16777215
                      arg_word: {(DQ ($ VSub_Name '$todo'))}
                    )
                    (redir.Redir
                      op: <Redir_Great '>'>
                      fd: 16777215
                      arg_word: {(DQ ($ VSub_Name '$todo') (.new))}
                    )
                    (redir.Redir
                      op: <Redir_DGreat '3>>'>
                      fd: 3
                      arg_word: {(DQ ($ VSub_Name '$done'))}
                    )
                  ]
                )
                (C {(mv)} {(-f)} {(DQ ($ VSub_Name '$todo')) (.new)} {(DQ ($ VSub_Name '$todo'))})
                (command.Case
                  to_match: 
                    {
                      (DQ 
                        (word_part.CommandSubPart
                          command_list: (command.CommandList children:[(C {(peek_next_command)})])
                          left_token: <Left_CommandSub '$('>
                          spids: [4971 4973]
                        )
                      )
                    }
                  arms: [
                    (case_arm
                      pat_list: [{(squash)} {(s)} {(fixup)} {(f)}]
                      action: [(C {(record_in_rewritten)} {(DQ ($ VSub_Name '$onto'))})]
                      spids: [4979 4986 4996 16777215]
                    )
                  ]
                  spids: [4968 4976 4999]
                )
                (C {(die)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {(gettext)} {(DQ ('Could not skip unnecessary pick commands'))})
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [5007 5013]
                      )
                    )
                  }
                )
              ]
            )
          ]
          spids: [4767]
        )
      spids: [4762 4766]
    )
    (command.FuncDef
      name: transform_todo_ids
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (command.WhileUntil
                  keyword: <KW_While while>
                  cond: [(C {(read)} {(-r)} {(command)} {(rest)})]
                  body: 
                    (command.DoGroup
                      children: [
                        (command.Case
                          to_match: {(DQ ($ VSub_Name '$command'))}
                          arms: [
                            (case_arm
                              pat_list: [{(DQ ($ VSub_Name '$comment_char')) (Lit_Other '*')} {(exec)}]
                              spids: [5050 5058 5069 16777215]
                            )
                            (case_arm
                              pat_list: [{(Lit_Other '*')}]
                              action: [
                                (command.AndOr
                                  ops: [Op_DAmp]
                                  children: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:sha1 spids:[5076])
                                          op: Equal
                                          rhs: 
                                            {
                                              (word_part.CommandSubPart
                                                command_list: 
                                                  (command.CommandList
                                                    children: [
                                                      (C {(git)} {(rev-parse)} {(--verify)} {(--quiet)} 
                                                        {(DQ ($ VSub_At '$@'))} 
                                                        {
                                                          (word_part.BracedVarSub
                                                            token: <VSub_Name rest>
                                                            suffix_op: 
                                                              (suffix_op.StringUnary
                                                                op_id: VOp1_DPercent
                                                                arg_word: {('[\t ]*')}
                                                              )
                                                            spids: [5090 5094]
                                                          )
                                                        }
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_CommandSub '$('>
                                                spids: [5077 5095]
                                              )
                                            }
                                          spids: [5076]
                                        )
                                      ]
                                      spids: [5076]
                                    )
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:rest spids:[5100])
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name '$sha1') (' ') 
                                                (word_part.BracedVarSub
                                                  token: <VSub_Name rest>
                                                  suffix_op: 
                                                    (suffix_op.StringUnary
                                                      op_id: VOp1_Pound
                                                      arg_word: {('*[\t ]')}
                                                    )
                                                  spids: [5104 5108]
                                                )
                                              )
                                            }
                                          spids: [5100]
                                        )
                                      ]
                                      spids: [5100]
                                    )
                                  ]
                                )
                              ]
                              spids: [5072 5073 5112 16777215]
                            )
                          ]
                          spids: [5041 5047 5115]
                        )
                        (C {(printf)} {(SQ <'%s\\n'>)} 
                          {
                            (DQ ($ VSub_Name '$command') 
                              (word_part.BracedVarSub
                                token: <VSub_Name rest>
                                suffix_op: 
                                  (suffix_op.StringUnary
                                    op_id: VTest_ColonPlus
                                    arg_word: {(' ')}
                                  )
                                spids: [5126 5130]
                              ) ($ VSub_Name '$rest')
                            )
                          }
                        )
                      ]
                      spids: [5038 5135]
                    )
                  redirects: [
                    (redir.Redir
                      op: <Redir_Less '<'>
                      fd: 16777215
                      arg_word: {(DQ ($ VSub_Name '$todo'))}
                    )
                    (redir.Redir
                      op: <Redir_Great '>'>
                      fd: 16777215
                      arg_word: {(DQ ($ VSub_Name '$todo') (.new))}
                    )
                  ]
                )
                (C {(mv)} {(-f)} {(DQ ($ VSub_Name '$todo') (.new))} {(DQ ($ VSub_Name '$todo'))})
              ]
            )
          ]
          spids: [5024]
        )
      spids: [5019 5023]
    )
    (command.FuncDef
      name: expand_todo_ids
      body: (command.BraceGroup children:[(C {(transform_todo_ids)})] spids:[5171])
      spids: [5167 5170]
    )
    (command.FuncDef
      name: collapse_todo_ids
      body: (command.BraceGroup children:[(C {(transform_todo_ids)} {(--short)})] spids:[5183])
      spids: [5179 5182]
    )
    (command.FuncDef
      name: rearrange_squash
      body: 
        (command.BraceGroup
          children: [
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [(C {(read)} {(-r)} {(pick)} {(sha1)} {(message)})]
              body: 
                (command.DoGroup
                  children: [
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(test)} {(-z)} {(DQ (${ VSub_Name format))})
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:message spids:[5257])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(git)} {(log)} {(-n)} {(1)} 
                                            {(--format) (Lit_Other '=') (DQ ('%s'))} {(${ VSub_Name sha1)}
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [5258 5276]
                                  )
                                }
                              spids: [5257]
                            )
                          ]
                          spids: [5257]
                        )
                      ]
                    )
                    (command.Case
                      to_match: {(DQ ($ VSub_Name '$message'))}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(DQ ('squash! ')) (Lit_Other '*')}
                            {(DQ ('fixup! ')) (Lit_Other '*')}
                          ]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:action spids:[5300])
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (word_part.BracedVarSub
                                          token: <VSub_Name message>
                                          suffix_op: 
                                            (suffix_op.StringUnary
                                              op_id: VOp1_DPercent
                                              arg_word: {('!*')}
                                            )
                                          spids: [5302 5306]
                                        )
                                      )
                                    }
                                  spids: [5300]
                                )
                              ]
                              spids: [5300]
                            )
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:rest spids:[5310])
                                  op: Equal
                                  rhs: {($ VSub_Name '$message')}
                                  spids: [5310]
                                )
                              ]
                              spids: [5310]
                            )
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:prefix spids:[5314])
                                  op: Equal
                                  rhs: (word.EmptyWord)
                                  spids: [5314]
                                )
                              ]
                              spids: [5314]
                            )
                            (command.WhileUntil
                              keyword: <KW_While while>
                              cond: [(C {(Lit_Other ':')})]
                              body: 
                                (command.DoGroup
                                  children: [
                                    (command.Case
                                      to_match: {(DQ ($ VSub_Name '$rest'))}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(DQ ('squash! ')) (Lit_Other '*')}
                                            {(DQ ('fixup! ')) (Lit_Other '*')}
                                          ]
                                          action: [
                                            (command.Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (lhs_expr.LhsName name:prefix spids:[5350])
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name '$prefix') 
                                                        (word_part.BracedVarSub
                                                          token: <VSub_Name rest>
                                                          suffix_op: 
                                                            (suffix_op.StringUnary
                                                              op_id: VOp1_DPercent
                                                              arg_word: {('!*')}
                                                            )
                                                          spids: [5353 5357]
                                                        ) (',')
                                                      )
                                                    }
                                                  spids: [5350]
                                                )
                                              ]
                                              spids: [5350]
                                            )
                                            (command.Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (lhs_expr.LhsName name:rest spids:[5362])
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (word_part.BracedVarSub
                                                          token: <VSub_Name rest>
                                                          suffix_op: 
                                                            (suffix_op.StringUnary
                                                              op_id: VOp1_Pound
                                                              arg_word: {('*! ')}
                                                            )
                                                          spids: [5364 5368]
                                                        )
                                                      )
                                                    }
                                                  spids: [5362]
                                                )
                                              ]
                                              spids: [5362]
                                            )
                                          ]
                                          spids: [5338 5347 5372 16777215]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other '*')}]
                                          action: [
                                            (command.ControlFlow
                                              token: <ControlFlow_Break break>
                                            )
                                          ]
                                          spids: [5375 5376 5382 16777215]
                                        )
                                      ]
                                      spids: [5329 5335 5385]
                                    )
                                  ]
                                  spids: [5326 5388]
                                )
                            )
                            (C {(printf)} {(SQ <'%s %s %s %s\\n'>)} {(DQ ($ VSub_Name '$sha1'))} 
                              {(DQ ($ VSub_Name '$action'))} {(DQ ($ VSub_Name '$prefix'))} {(DQ ($ VSub_Name '$rest'))}
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} 
                                          {
                                            (DQ 
                                              (word_part.BracedVarSub
                                                token: <VSub_Name rest>
                                                suffix_op: 
                                                  (suffix_op.StringUnary
                                                    op_id: VOp1_Pound
                                                    arg_word: {('* ')}
                                                  )
                                                spids: [5431 5435]
                                              )
                                            )
                                          } {(Lit_Other '=')} {(DQ ($ VSub_Name '$rest'))}
                                        )
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:fullsha spids:[5448])
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (word_part.CommandSubPart
                                                  command_list: 
                                                    (command.CommandList
                                                      children: [
                                                        (command.SimpleCommand
                                                          words: [
                                                            {(git)}
                                                            {(rev-parse)}
                                                            {(-q)}
                                                            {(--verify)}
                                                            {(DQ ($ VSub_Name '$rest'))}
                                                          ]
                                                          redirects: [
                                                            (redir.Redir
                                                              op: <Redir_Great '2>'>
                                                              fd: 2
                                                              arg_word: {(/dev/null)}
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  left_token: <Left_CommandSub '$('>
                                                  spids: [5450 5465]
                                                )
                                              )
                                            }
                                          spids: [5448]
                                        )
                                      ]
                                      spids: [5448]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Sentence
                                              child: (C {(test)} {(-n)} {(DQ ($ VSub_Name '$fullsha'))})
                                              terminator: <Op_Semi ';'>
                                            )
                                          ]
                                          action: [
                                            (C {(echo)} 
                                              {
                                                (DQ ($ VSub_Name '$sha1') (' +') 
                                                  ($ VSub_Name '$action') (' ') ($ VSub_Name '$prefix') (' ') ($ VSub_Name '$fullsha')
                                                )
                                              }
                                            )
                                          ]
                                          spids: [16777215 5480]
                                        )
                                      ]
                                      spids: [16777215 5504]
                                    )
                                  ]
                                  spids: [16777215 5445]
                                )
                              ]
                              spids: [16777215 5507]
                            )
                          ]
                          spids: [5288 5297 16777215 5510]
                        )
                      ]
                      spids: [5279 5285 5510]
                    )
                  ]
                  spids: [5242 5513]
                )
              redirects: [
                (redir.Redir
                  op: <Redir_Great '>'>
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_Number '$1') (.sq))}
                )
                (redir.Redir
                  op: <Redir_Less '<'>
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_Number '$1'))}
                )
              ]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(test)} {(-s)} {(DQ ($ VSub_Number '$1') (.sq))})
                (command.ControlFlow token:<ControlFlow_Return return>)
              ]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:used spids:[5542])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [5542]
                )
              ]
              spids: [5542]
            )
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [(C {(read)} {(-r)} {(pick)} {(sha1)} {(message)})]
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ (' ') ($ VSub_Name '$used'))}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(Lit_Other '*') (DQ (' ') ($ VSub_Name '$sha1') (' ')) (Lit_Other '*')}
                          ]
                          action: [(command.ControlFlow token:<ControlFlow_Continue continue>)]
                          spids: [5571 5578 5582 16777215]
                        )
                      ]
                      spids: [5561 5568 5585]
                    )
                    (C {(printf)} {(SQ <'%s\\n'>)} 
                      {
                        (DQ ($ VSub_Name '$pick') (' ') ($ VSub_Name '$sha1') (' ') 
                          ($ VSub_Name '$message')
                        )
                      }
                    )
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(test)} {(-z)} {(DQ (${ VSub_Name format))})
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:message spids:[5615])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(git)} {(log)} {(-n)} {(1)} 
                                            {(--format) (Lit_Other '=') (DQ ('%s'))} {(${ VSub_Name sha1)}
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [5616 5634]
                                  )
                                }
                              spids: [5615]
                            )
                          ]
                          spids: [5615]
                        )
                      ]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:used spids:[5637])
                          op: Equal
                          rhs: {(DQ ($ VSub_Name '$used') ($ VSub_Name '$sha1') (' '))}
                          spids: [5637]
                        )
                      ]
                      spids: [5637]
                    )
                    (command.WhileUntil
                      keyword: <KW_While while>
                      cond: [(C {(read)} {(-r)} {(squash)} {(action)} {(msg_prefix)} {(msg_content)})]
                      body: 
                        (command.DoGroup
                          children: [
                            (command.Case
                              to_match: {(DQ (' ') ($ VSub_Name '$used'))}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(Lit_Other '*') (DQ (' ') ($ VSub_Name '$squash') (' ')) 
                                      (Lit_Other '*')
                                    }
                                  ]
                                  action: [(command.ControlFlow token:<ControlFlow_Continue continue>)]
                                  spids: [5673 5680 5684 16777215]
                                )
                              ]
                              spids: [5663 5670 5687]
                            )
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:emit spids:[5690])
                                  op: Equal
                                  rhs: {(0)}
                                  spids: [5690]
                                )
                              ]
                              spids: [5690]
                            )
                            (command.Case
                              to_match: {(DQ ($ VSub_Name '$action'))}
                              arms: [
                                (case_arm
                                  pat_list: [{(Lit_Other '+') (Lit_Other '*')}]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:action spids:[5708])
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (word_part.BracedVarSub
                                                  token: <VSub_Name action>
                                                  suffix_op: 
                                                    (suffix_op.StringUnary
                                                      op_id: VOp1_Pound
                                                      arg_word: {('+')}
                                                    )
                                                  spids: [5710 5714]
                                                )
                                              )
                                            }
                                          spids: [5708]
                                        )
                                      ]
                                      spids: [5708]
                                    )
                                    (command.Case
                                      to_match: {(DQ ($ VSub_Name '$msg_content'))}
                                      arms: [
                                        (case_arm
                                          pat_list: [{(DQ ($ VSub_Name '$sha1')) (Lit_Other '*')}]
                                          action: [
                                            (command.Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (lhs_expr.LhsName name:emit spids:[5736])
                                                  op: Equal
                                                  rhs: {(1)}
                                                  spids: [5736]
                                                )
                                              ]
                                              spids: [5736]
                                            )
                                          ]
                                          spids: [5730 5734 5738 16777215]
                                        )
                                      ]
                                      spids: [5722 5728 5740]
                                    )
                                  ]
                                  spids: [5703 5705 5742 16777215]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Other '*')}]
                                  action: [
                                    (command.Case
                                      to_match: {(DQ ($ VSub_Name '$message'))}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ VSub_Name '$msg_content')) (Lit_Other '*')}
                                          ]
                                          action: [
                                            (command.Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (lhs_expr.LhsName name:emit spids:[5767])
                                                  op: Equal
                                                  rhs: {(1)}
                                                  spids: [5767]
                                                )
                                              ]
                                              spids: [5767]
                                            )
                                          ]
                                          spids: [5761 5765 5769 16777215]
                                        )
                                      ]
                                      spids: [5753 5759 5771]
                                    )
                                  ]
                                  spids: [5745 5746 5773 16777215]
                                )
                              ]
                              spids: [5694 5700 5776]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (C {(test)} {($ VSub_Name '$emit')} {(Lit_Other '=')} {(1)})
                                      terminator: <Op_Semi ';'>
                                    )
                                  ]
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [(C {(test)} {(-n)} {(DQ (${ VSub_Name format))})]
                                          action: [
                                            (command.Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: 
                                                    (lhs_expr.LhsName
                                                      name: msg_content
                                                      spids: [5809]
                                                    )
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (word_part.CommandSubPart
                                                        command_list: 
                                                          (command.CommandList
                                                            children: [
                                                              (C {(git)} {(log)} {(-n)} {(1)} 
                                                                {(--format) (Lit_Other '=') 
                                                                  (DQ (${ VSub_Name format))
                                                                } {(${ VSub_Name squash)}
                                                              )
                                                            ]
                                                          )
                                                        left_token: <Left_CommandSub '$('>
                                                        spids: [5810 5830]
                                                      )
                                                    }
                                                  spids: [5809]
                                                )
                                              ]
                                              spids: [5809]
                                            )
                                          ]
                                          spids: [16777215 5806]
                                        )
                                      ]
                                      else_action: [
                                        (command.Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (lhs_expr.LhsName name:msg_content spids:[5836])
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ 
                                                    (word_part.CommandSubPart
                                                      command_list: 
                                                        (command.CommandList
                                                          children: [
                                                            (command.Pipeline
                                                              children: [
                                                                (C {(echo)} 
                                                                  {(DQ ($ VSub_Name '$msg_prefix'))}
                                                                )
                                                                (C {(sed)} {(DQ ('s/,/! /g'))})
                                                              ]
                                                              negated: F
                                                            )
                                                          ]
                                                        )
                                                      left_token: <Left_CommandSub '$('>
                                                      spids: [5838 5852]
                                                    ) ($ VSub_Name '$msg_content')
                                                  )
                                                }
                                              spids: [5836]
                                            )
                                          ]
                                          spids: [5836]
                                        )
                                      ]
                                      spids: [5833 5857]
                                    )
                                    (C {(printf)} {(SQ <'%s\\n'>)} 
                                      {
                                        (DQ ($ VSub_Name '$action') (' ') ($ VSub_Name '$squash') (' ') 
                                          ($ VSub_Name '$msg_content')
                                        )
                                      }
                                    )
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:used spids:[5875])
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name '$used') ($ VSub_Name '$squash') (' '))
                                            }
                                          spids: [5875]
                                        )
                                      ]
                                      spids: [5875]
                                    )
                                  ]
                                  spids: [16777215 5790]
                                )
                              ]
                              spids: [16777215 5883]
                            )
                          ]
                          spids: [5660 5886]
                        )
                      redirects: [
                        (redir.Redir
                          op: <Redir_Less '<'>
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_Number '$1') (.sq))}
                        )
                      ]
                    )
                  ]
                  spids: [5558 5895]
                )
              redirects: [
                (redir.Redir
                  op: <Redir_Great '>'>
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_Number '$1') (.rearranged))}
                )
                (redir.Redir
                  op: <Redir_Less '<'>
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_Number '$1'))}
                )
              ]
            )
            (command.SimpleCommand
              words: [{(cat)} {(DQ ($ VSub_Number '$1') (.rearranged))}]
              redirects: [
                (redir.Redir
                  op: <Redir_Great '>'>
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_Number '$1'))}
                )
              ]
            )
            (C {(rm)} {(-f)} {(DQ ($ VSub_Number '$1') (.sq))} {(DQ ($ VSub_Number '$1') (.rearranged))})
          ]
          spids: [5222]
        )
      spids: [5217 5221]
    )
    (command.FuncDef
      name: add_exec_commands
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (command.BraceGroup
                  children: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:first spids:[5956])
                          op: Equal
                          rhs: {(t)}
                          spids: [5956]
                        )
                      ]
                      spids: [5956]
                    )
                    (command.WhileUntil
                      keyword: <KW_While while>
                      cond: [(C {(read)} {(-r)} {(insn)} {(rest)})]
                      body: 
                        (command.DoGroup
                          children: [
                            (command.Case
                              to_match: {($ VSub_Name '$insn')}
                              arms: [
                                (case_arm
                                  pat_list: [{(pick)}]
                                  action: [
                                    (command.AndOr
                                      ops: [Op_DPipe]
                                      children: [
                                        (C {(test)} {(-n)} {(DQ ($ VSub_Name '$first'))})
                                        (C {(printf)} {(DQ ('%s'))} {(DQ ($ VSub_Name '$cmd'))})
                                      ]
                                    )
                                  ]
                                  spids: [5981 5982 6007 16777215]
                                )
                              ]
                              spids: [5974 5978 6010]
                            )
                            (C {(printf)} {(DQ ('%s %s') (Lit_Other '\\') (n))} 
                              {(DQ ($ VSub_Name '$insn'))} {(DQ ($ VSub_Name '$rest'))}
                            )
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:first spids:[6030])
                                  op: Equal
                                  rhs: (word.EmptyWord)
                                  spids: [6030]
                                )
                              ]
                              spids: [6030]
                            )
                          ]
                          spids: [5971 6033]
                        )
                    )
                    (C {(printf)} {(DQ ('%s'))} {(DQ ($ VSub_Name '$cmd'))})
                  ]
                  redirects: [
                    (redir.Redir
                      op: <Redir_Less '<'>
                      fd: 16777215
                      arg_word: {(DQ ($ VSub_Number '$1'))}
                    )
                    (redir.Redir
                      op: <Redir_Great '>'>
                      fd: 16777215
                      arg_word: {(DQ ($ VSub_Number '$1') (.new))}
                    )
                  ]
                  spids: [5953]
                )
                (C {(mv)} {(DQ ($ VSub_Number '$1') (.new))} {(DQ ($ VSub_Number '$1'))})
              ]
            )
          ]
          spids: [5950]
        )
      spids: [5945 5949]
    )
    (command.FuncDef
      name: check_commit_sha
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:badsha spids:[6100])
                  op: Equal
                  rhs: {(0)}
                  spids: [6100]
                )
              ]
              spids: [6100]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Number '$1'))})]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:badsha spids:[6118])
                          op: Equal
                          rhs: {(1)}
                          spids: [6118]
                        )
                      ]
                      spids: [6118]
                    )
                  ]
                  spids: [16777215 6115]
                )
              ]
              else_action: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:sha1_verif spids:[6125])
                      op: Equal
                      rhs: 
                        {
                          (DQ 
                            (word_part.CommandSubPart
                              command_list: 
                                (command.CommandList
                                  children: [
                                    (C {(git)} {(rev-parse)} {(--verify)} {(--quiet)} 
                                      {($ VSub_Number '$1') (Lit_Other '^') (Lit_LBrace '{') (commit) 
                                        (Lit_RBrace '}')
                                      }
                                    )
                                  ]
                                )
                              left_token: <Left_CommandSub '$('>
                              spids: [6127 6141]
                            )
                          )
                        }
                      spids: [6125]
                    )
                  ]
                  spids: [6125]
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name '$sha1_verif'))})]
                      action: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:badsha spids:[6159])
                              op: Equal
                              rhs: {(1)}
                              spids: [6159]
                            )
                          ]
                          spids: [6159]
                        )
                      ]
                      spids: [16777215 6156]
                    )
                  ]
                  spids: [16777215 6163]
                )
              ]
              spids: [6122 6166]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {($ VSub_Name '$badsha')} {(-ne)} {(0)})]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:line spids:[6184])
                          op: Equal
                          rhs: 
                            {
                              (DQ 
                                (word_part.CommandSubPart
                                  command_list: 
                                    (command.CommandList
                                      children: [
                                        (C {(sed)} {(-n)} {(-e)} {(DQ (${ VSub_Number 2) (p))} 
                                          {(DQ ($ VSub_Number '$3'))}
                                        )
                                      ]
                                    )
                                  left_token: <Left_CommandSub '$('>
                                  spids: [6186 6203]
                                )
                              )
                            }
                          spids: [6184]
                        )
                      ]
                      spids: [6184]
                    )
                    (C {(warn)} 
                      {
                        (DQ 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ 
                                        (
"Warning: the SHA-1 is missing or isn't a commit in the following line:\n"
                                        ) (' - ') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) (line)
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [6210 6220]
                          )
                        )
                      }
                    )
                    (C {(warn)})
                  ]
                  spids: [16777215 6181]
                )
              ]
              spids: [16777215 6227]
            )
            (command.ControlFlow
              token: <ControlFlow_Return return>
              arg_word: {($ VSub_Name '$badsha')}
            )
          ]
          spids: [6097]
        )
      spids: [6092 6096]
    )
    (command.FuncDef
      name: check_bad_cmd_and_sha
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:retval spids:[6252])
                  op: Equal
                  rhs: {(0)}
                  spids: [6252]
                )
              ]
              spids: [6252]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:lineno spids:[6256])
                  op: Equal
                  rhs: {(0)}
                  spids: [6256]
                )
              ]
              spids: [6256]
            )
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [(C {(read)} {(-r)} {(command)} {(rest)})]
              body: 
                (command.DoGroup
                  children: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:lineno spids:[6274])
                          op: Equal
                          rhs: 
                            {
                              (word_part.ArithSubPart
                                anode: 
                                  (arith_expr.ArithBinary
                                    op_id: Arith_Plus
                                    left: (arith_expr.ArithWord w:{($ VSub_Name '$lineno')})
                                    right: (arith_expr.ArithWord w:{(Lit_Digits 1)})
                                  )
                                spids: [6275 6284]
                              )
                            }
                          spids: [6274]
                        )
                      ]
                      spids: [6274]
                    )
                    (command.Case
                      to_match: {($ VSub_Name '$command')}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(DQ ($ VSub_Name '$comment_char')) (Lit_Other '*')}
                            {(SQ )}
                            {(noop)}
                            {(x)}
                            {(exec)}
                          ]
                          spids: [6294 6307 6314 16777215]
                        )
                        (case_arm
                          pat_list: [{(DQ ($ VSub_Name '$cr'))}]
                          spids: [6317 6320 6331 16777215]
                        )
                        (case_arm
                          pat_list: [
                            {(pick)}
                            {(p)}
                            {(drop)}
                            {(d)}
                            {(reword)}
                            {(r)}
                            {(edit)}
                            {(e)}
                            {(squash)}
                            {(s)}
                            {(fixup)}
                            {(f)}
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Pipeline
                                      children: [
                                        (C {(check_commit_sha)} 
                                          {
                                            (DQ 
                                              (word_part.BracedVarSub
                                                token: <VSub_Name rest>
                                                suffix_op: 
                                                  (suffix_op.StringUnary
                                                    op_id: VOp1_DPercent
                                                    arg_word: {('[ \t]*')}
                                                  )
                                                spids: [6367 6371]
                                              )
                                            )
                                          } {(DQ ($ VSub_Name '$lineno'))} {(DQ ($ VSub_Number '$1'))}
                                        )
                                      ]
                                      negated: T
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:retval spids:[6386])
                                          op: Equal
                                          rhs: {(1)}
                                          spids: [6386]
                                        )
                                      ]
                                      spids: [6386]
                                    )
                                  ]
                                  spids: [16777215 6383]
                                )
                              ]
                              spids: [16777215 6390]
                            )
                          ]
                          spids: [6334 6357 6393 16777215]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other '*')}]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:line spids:[6400])
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (word_part.CommandSubPart
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {(sed)} {(-n)} {(-e)} {(DQ (${ VSub_Name lineno) (p))} 
                                                  {(DQ ($ VSub_Number '$1'))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                          spids: [6402 6419]
                                        )
                                      )
                                    }
                                  spids: [6400]
                                )
                              ]
                              spids: [6400]
                            )
                            (C {(warn)} 
                              {
                                (DQ 
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(eval_gettext)} 
                                            {
                                              (DQ 
                                                (
"Warning: the command isn't recognized in the following line:\n"
                                                ) (' - ') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) (line)
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [6426 6436]
                                  )
                                )
                              }
                            )
                            (C {(warn)})
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:retval spids:[6443])
                                  op: Equal
                                  rhs: {(1)}
                                  spids: [6443]
                                )
                              ]
                              spids: [6443]
                            )
                          ]
                          spids: [6396 6397 6447 16777215]
                        )
                      ]
                      spids: [6287 6291 6450]
                    )
                  ]
                  spids: [6271 6453]
                )
              redirects: [
                (redir.Redir
                  op: <Redir_Less '<'>
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_Number '$1'))}
                )
              ]
            )
            (command.ControlFlow
              token: <ControlFlow_Return return>
              arg_word: {($ VSub_Name '$retval')}
            )
          ]
          spids: [6249]
        )
      spids: [6244 6248]
    )
    (command.FuncDef
      name: todo_list_to_sha_list
      body: 
        (command.BraceGroup
          children: [
            (command.Pipeline
              children: [
                (C {(git)} {(stripspace)} {(--strip-comments)})
                (command.WhileUntil
                  keyword: <KW_While while>
                  cond: [(C {(read)} {(-r)} {(command)} {(sha1)} {(rest)})]
                  body: 
                    (command.DoGroup
                      children: [
                        (command.Case
                          to_match: {($ VSub_Name '$command')}
                          arms: [
                            (case_arm
                              pat_list: [
                                {(DQ ($ VSub_Name '$comment_char')) (Lit_Other '*')}
                                {(SQ )}
                                {(noop)}
                                {(x)}
                                {(DQ (exec))}
                              ]
                              spids: [6514 6529 6532 16777215]
                            )
                            (case_arm
                              pat_list: [{(Lit_Other '*')}]
                              action: [
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:long_sha spids:[6539])
                                      op: Equal
                                      rhs: 
                                        {
                                          (word_part.CommandSubPart
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (command.SimpleCommand
                                                    words: [
                                                      {(git)}
                                                      {(rev-list)}
                                                      {(--no-walk)}
                                                      {(DQ ($ VSub_Name '$sha1'))}
                                                    ]
                                                    redirects: [
                                                      (redir.Redir
                                                        op: <Redir_Great '2>'>
                                                        fd: 2
                                                        arg_word: {(/dev/null)}
                                                      )
                                                    ]
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub '$('>
                                            spids: [6540 6553]
                                          )
                                        }
                                      spids: [6539]
                                    )
                                  ]
                                  spids: [6539]
                                )
                                (C {(printf)} {(DQ ('%s') (Lit_Other '\\') (n))} 
                                  {(DQ ($ VSub_Name '$long_sha'))}
                                )
                              ]
                              spids: [6535 6536 6569 16777215]
                            )
                          ]
                          spids: [6507 6511 6572]
                        )
                      ]
                      spids: [6504 6575]
                    )
                )
              ]
              negated: F
            )
          ]
          spids: [6479]
        )
      spids: [6474 6478]
    )
    (command.FuncDef
      name: warn_lines
      body: 
        (command.BraceGroup
          children: [
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [(C {(read)} {(-r)} {(line)})]
              body: 
                (command.DoGroup
                  children: [(C {(warn)} {(DQ (' - ') ($ VSub_Name '$line'))})]
                  spids: [6600 6611]
                )
            )
          ]
          spids: [6588]
        )
      spids: [6583 6587]
    )
    (command.FuncDef
      name: checkout_onto
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:GIT_REFLOG_ACTION spids:[6627])
                  op: Equal
                  rhs: 
                    {
                      (DQ ($ VSub_Name '$GIT_REFLOG_ACTION') (': checkout ') ($ VSub_Name '$onto_name'))
                    }
                  spids: [6627]
                )
              ]
              spids: [6627]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(output)} {(git)} {(checkout)} {($ VSub_Name '$onto')})
                (C {(die_abort)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [(C {(gettext)} {(DQ ('could not detach HEAD'))})]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [6648 6654]
                      )
                    )
                  }
                )
              ]
            )
            (C {(git)} {(update-ref)} {(ORIG_HEAD)} {($ VSub_Name '$orig_head')})
          ]
          spids: [6624]
        )
      spids: [6619 6623]
    )
    (command.FuncDef
      name: get_missing_commit_check_level
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:check_level spids:[6677])
                  op: Equal
                  rhs: 
                    {
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [(C {(git)} {(config)} {(--get)} {(rebase.missingCommitsCheck)})]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [6678 6686]
                      )
                    }
                  spids: [6677]
                )
              ]
              spids: [6677]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:check_level spids:[6689])
                  op: Equal
                  rhs: 
                    {
                      (word_part.BracedVarSub
                        token: <VSub_Name check_level>
                        suffix_op: (suffix_op.StringUnary op_id:VTest_ColonHyphen arg_word:{(ignore)})
                        spids: [6690 6694]
                      )
                    }
                  spids: [6689]
                )
              ]
              spids: [6689]
            )
            (command.Pipeline
              children: [
                (C {(printf)} {(SQ <'%s'>)} {(DQ ($ VSub_Name '$check_level'))})
                (C {(tr)} {(SQ <A-Z>)} {(SQ <a-z>)})
              ]
              negated: F
            )
          ]
          spids: [6674]
        )
      spids: [6669 6673]
    )
    (command.FuncDef
      name: check_todo_list
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:raise_error spids:[6746])
                  op: Equal
                  rhs: {(f)}
                  spids: [6746]
                )
              ]
              spids: [6746]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:check_level spids:[6751])
                  op: Equal
                  rhs: 
                    {
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [(C {(get_missing_commit_check_level)})]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [6752 6754]
                      )
                    }
                  spids: [6751]
                )
              ]
              spids: [6751]
            )
            (command.Case
              to_match: {(DQ ($ VSub_Name '$check_level'))}
              arms: [
                (case_arm
                  pat_list: [{(warn)} {(error)}]
                  action: [
                    (command.SimpleCommand
                      words: [{(todo_list_to_sha_list)}]
                      redirects: [
                        (redir.Redir
                          op: <Redir_Less '<'>
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_Name '$todo')) (.backup)}
                        )
                        (redir.Redir
                          op: <Redir_Great '>'>
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_Name '$todo')) (.oldsha1)}
                        )
                      ]
                    )
                    (command.SimpleCommand
                      words: [{(todo_list_to_sha_list)}]
                      redirects: [
                        (redir.Redir
                          op: <Redir_Less '<'>
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_Name '$todo'))}
                        )
                        (redir.Redir
                          op: <Redir_Great '>'>
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_Name '$todo')) (.newsha1)}
                        )
                      ]
                    )
                    (command.SimpleCommand
                      words: [{(sort)} {(-u)} {(DQ ($ VSub_Name '$todo')) (.oldsha1)}]
                      redirects: [
                        (redir.Redir
                          op: <Redir_Great '>'>
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_Name '$todo')) (.oldsha1) (Lit_Other '+')}
                        )
                      ]
                    )
                    (C {(mv)} {(DQ ($ VSub_Name '$todo')) (.oldsha1) (Lit_Other '+')} 
                      {(DQ ($ VSub_Name '$todo')) (.oldsha1)}
                    )
                    (command.SimpleCommand
                      words: [{(sort)} {(-u)} {(DQ ($ VSub_Name '$todo')) (.newsha1)}]
                      redirects: [
                        (redir.Redir
                          op: <Redir_Great '>'>
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_Name '$todo')) (.newsha1) (Lit_Other '+')}
                        )
                      ]
                    )
                    (C {(mv)} {(DQ ($ VSub_Name '$todo')) (.newsha1) (Lit_Other '+')} 
                      {(DQ ($ VSub_Name '$todo')) (.newsha1)}
                    )
                    (command.SimpleCommand
                      words: [
                        {(comm)}
                        {(-2)}
                        {(-3)}
                        {(DQ ($ VSub_Name '$todo')) (.oldsha1)}
                        {(DQ ($ VSub_Name '$todo')) (.newsha1)}
                      ]
                      redirects: [
                        (redir.Redir
                          op: <Redir_Great '>'>
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_Name '$todo')) (.miss)}
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [(C {(test)} {(-s)} {(DQ ($ VSub_Name '$todo')) (.miss)})]
                          action: [
                            (command.AndOr
                              ops: [Op_DAmp]
                              children: [
                                (C {(test)} {(DQ ($ VSub_Name '$check_level'))} {(Lit_Other '=')} 
                                  {(error)}
                                )
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:raise_error spids:[6928])
                                      op: Equal
                                      rhs: {(t)}
                                      spids: [6928]
                                    )
                                  ]
                                  spids: [6928]
                                )
                              ]
                            )
                            (C {(warn)} 
                              {
                                (DQ 
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(gettext)} 
                                            {
                                              (DQ 
                                                (
'Warning: some commits may have been dropped accidentally.\n'
                                                ) ('Dropped commits (newer to older):')
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [6936 6944]
                                  )
                                )
                              }
                            )
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:opt spids:[6953])
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (
'--no-walk=sorted --format=oneline --abbrev-commit --stdin'
                                        )
                                      )
                                    }
                                  spids: [6953]
                                )
                              ]
                              spids: [6953]
                            )
                            (command.Pipeline
                              children: [
                                (command.SimpleCommand
                                  words: [{(git)} {(rev-list)} {($ VSub_Name '$opt')}]
                                  redirects: [
                                    (redir.Redir
                                      op: <Redir_Less '<'>
                                      fd: 16777215
                                      arg_word: {(DQ ($ VSub_Name '$todo')) (.miss)}
                                    )
                                  ]
                                )
                                (C {(warn_lines)})
                              ]
                              negated: F
                            )
                            (C {(warn)} 
                              {
                                (DQ 
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(gettext)} 
                                            {
                                              (DQ ('To avoid this message, use ') 
                                                (word_part.EscapedLiteralPart
                                                  token: <Lit_EscapedChar '\\"'>
                                                ) (drop) (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\"'>) 
                                                (' to explicitly remove a commit.\n') ('\n') ("Use 'git config rebase.missingCommitsCheck' to change the level of warnings.\n") 
                                                (
'The possible behaviours are: ignore, warn, error.'
                                                )
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [6980 6994]
                                  )
                                )
                              }
                            )
                            (C {(warn)})
                          ]
                          spids: [16777215 6913]
                        )
                      ]
                      spids: [16777215 7001]
                    )
                  ]
                  spids: [6767 6770 7004 16777215]
                )
                (case_arm pat_list:[{(ignore)}] spids:[7007 7008 7011 16777215])
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [
                    (C {(warn)} 
                      {
                        (DQ 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ ('Unrecognized setting ') 
                                        (word_part.EscapedLiteralPart
                                          token: <Lit_EscapedChar '\\$'>
                                        ) ('check_level for option rebase.missingCommitsCheck. Ignoring.')
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [7021 7029]
                          )
                        )
                      }
                    )
                  ]
                  spids: [7014 7015 7033 16777215]
                )
              ]
              spids: [6758 6764 7036]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Pipeline
                      children: [(C {(check_bad_cmd_and_sha)} {(DQ ($ VSub_Name '$todo'))})]
                      negated: T
                    )
                  ]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:raise_error spids:[7054])
                          op: Equal
                          rhs: {(t)}
                          spids: [7054]
                        )
                      ]
                      spids: [7054]
                    )
                  ]
                  spids: [16777215 7051]
                )
              ]
              spids: [16777215 7058]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {($ VSub_Name '$raise_error')} {(Lit_Other '=')} {(t)})]
                  action: [
                    (C {(checkout_onto)})
                    (C {(warn)} 
                      {
                        (DQ 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(gettext)} 
                                    {
                                      (DQ 
                                        (
"You can fix this with 'git rebase --edit-todo' and then run 'git rebase --continue'."
                                        )
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [7099 7105]
                          )
                        )
                      }
                    )
                    (C {(die)} 
                      {
                        (DQ 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(gettext)} 
                                    {(DQ ("Or you can abort the rebase with 'git rebase --abort'."))}
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [7112 7118]
                          )
                        )
                      }
                    )
                  ]
                  spids: [16777215 7073]
                )
              ]
              spids: [16777215 7122]
            )
          ]
          spids: [6743]
        )
      spids: [6738 6742]
    )
    (command.FuncDef
      name: git_rebase__interactive
      body: 
        (command.BraceGroup
          children: [
            (command.Case
              to_match: {(DQ ($ VSub_Name '$action'))}
              arms: [
                (case_arm
                  pat_list: [{(ControlFlow_Continue continue)}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [(C {(git)} {(diff-index)} {(--cached)} {(--quiet)} {(HEAD)} {(--)})]
                          action: [
                            (command.AndOr
                              ops: [Op_DPipe Op_DPipe]
                              children: [
                                (C {(test)} {(KW_Bang '!')} {(-f)} 
                                  {(DQ ($ VSub_Name '$GIT_DIR')) (/CHERRY_PICK_HEAD)}
                                )
                                (C {(rm)} {(DQ ($ VSub_Name '$GIT_DIR')) (/CHERRY_PICK_HEAD)})
                                (C {(die)} 
                                  {
                                    (DQ 
                                      (word_part.CommandSubPart
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (C {(gettext)} 
                                                {(DQ ('Could not remove CHERRY_PICK_HEAD'))}
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub '$('>
                                        spids: [7228 7234]
                                      )
                                    )
                                  }
                                )
                              ]
                            )
                          ]
                          spids: [16777215 7193]
                        )
                      ]
                      else_action: [
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Pipeline
                                  children: [(C {(test)} {(-f)} {(DQ ($ VSub_Name '$author_script'))})]
                                  negated: T
                                )
                              ]
                              action: [
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:gpg_sign_opt_quoted spids:[7257])
                                      op: Equal
                                      rhs: 
                                        {
                                          (word_part.BracedVarSub
                                            token: <VSub_Name gpg_sign_opt>
                                            suffix_op: 
                                              (suffix_op.StringUnary
                                                op_id: VTest_ColonPlus
                                                arg_word: 
                                                  {
                                                    (word_part.CommandSubPart
                                                      command_list: 
                                                        (command.CommandList
                                                          children: [
                                                            (C {(git)} {(rev-parse)} {(--sq-quote)} 
                                                              {(DQ ($ VSub_Name '$gpg_sign_opt'))}
                                                            )
                                                          ]
                                                        )
                                                      left_token: <Left_CommandSub '$('>
                                                      spids: [7261 7271]
                                                    )
                                                  }
                                              )
                                            spids: [7258 7272]
                                          )
                                        }
                                      spids: [7257]
                                    )
                                  ]
                                  spids: [7257]
                                )
                                (C {(die)} 
                                  {
                                    (DQ 
                                      (word_part.CommandSubPart
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (C {(eval_gettext)} 
                                                {
                                                  (DQ 
                                                    (
'You have staged changes in your working tree.\n'
                                                    ) ('If these changes are meant to be\n') ('squashed into the previous commit, run:\n') ('\n') 
                                                    ('  git commit --amend ') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) ('gpg_sign_opt_quoted\n') ('\n') 
                                                    (
'If they are meant to go into a new commit, run:\n'
                                                    ) ('\n') ('  git commit ') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) 
                                                    ('gpg_sign_opt_quoted\n') ('\n') ("In both cases, once you're done, continue with:\n") ('\n') ('  git rebase --continue\n')
                                                  )
                                                }
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub '$('>
                                        spids: [7278 7301]
                                      )
                                    )
                                  }
                                )
                              ]
                              spids: [16777215 7254]
                            )
                          ]
                          spids: [16777215 7305]
                        )
                        (command.AndOr
                          ops: [Op_DPipe]
                          children: [
                            (C {(.)} {(DQ ($ VSub_Name '$author_script'))})
                            (C {(die)} 
                              {
                                (DQ 
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(gettext)} 
                                            {
                                              (DQ 
                                                (
'Error trying to find the author identity to amend commit'
                                                )
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [7320 7326]
                                  )
                                )
                              }
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: [(C {(test)} {(-f)} {(DQ ($ VSub_Name '$amend'))})]
                              action: [
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:current_head spids:[7344])
                                      op: Equal
                                      rhs: 
                                        {
                                          (word_part.CommandSubPart
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (C {(git)} {(rev-parse)} {(--verify)} {(HEAD)})
                                                ]
                                              )
                                            left_token: <Left_CommandSub '$('>
                                            spids: [7345 7353]
                                          )
                                        }
                                      spids: [7344]
                                    )
                                  ]
                                  spids: [7344]
                                )
                                (command.AndOr
                                  ops: [Op_DPipe]
                                  children: [
                                    (C {(test)} {(DQ ($ VSub_Name '$current_head'))} {(Lit_Other '=')} 
                                      {
                                        (word_part.CommandSubPart
                                          command_list: 
                                            (command.CommandList
                                              children: [(C {(cat)} {(DQ ($ VSub_Name '$amend'))})]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                          spids: [7364 7370]
                                        )
                                      }
                                    )
                                    (C {(die)} 
                                      {
                                        (DQ 
                                          (word_part.CommandSubPart
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (C {(gettext)} 
                                                    {
                                                      (DQ 
                                                        (
'You have uncommitted changes in your working tree. Please commit them\n'
                                                        ) ("first and then run 'git rebase --continue' again.")
                                                      )
                                                    }
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub '$('>
                                            spids: [7378 7386]
                                          )
                                        )
                                      }
                                    )
                                  ]
                                )
                                (command.AndOr
                                  ops: [Op_DPipe]
                                  children: [
                                    (C {(do_with_author)} {(git)} {(commit)} {(--amend)} {(--no-verify)} 
                                      {(-F)} {(DQ ($ VSub_Name '$msg'))} {(-e)} 
                                      {
                                        (word_part.BracedVarSub
                                          token: <VSub_Name gpg_sign_opt>
                                          suffix_op: 
                                            (suffix_op.StringUnary
                                              op_id: VTest_ColonPlus
                                              arg_word: {(DQ ($ VSub_Name '$gpg_sign_opt'))}
                                            )
                                          spids: [7410 7416]
                                        )
                                      }
                                    )
                                    (C {(die)} 
                                      {
                                        (DQ 
                                          (word_part.CommandSubPart
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (C {(gettext)} 
                                                    {(DQ ('Could not commit staged changes.'))}
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub '$('>
                                            spids: [7424 7430]
                                          )
                                        )
                                      }
                                    )
                                  ]
                                )
                              ]
                              spids: [16777215 7341]
                            )
                          ]
                          else_action: [
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {(do_with_author)} {(git)} {(commit)} {(--no-verify)} {(-F)} 
                                  {(DQ ($ VSub_Name '$msg'))} {(-e)} 
                                  {
                                    (word_part.BracedVarSub
                                      token: <VSub_Name gpg_sign_opt>
                                      suffix_op: 
                                        (suffix_op.StringUnary
                                          op_id: VTest_ColonPlus
                                          arg_word: {(DQ ($ VSub_Name '$gpg_sign_opt'))}
                                        )
                                      spids: [7455 7461]
                                    )
                                  }
                                )
                                (C {(die)} 
                                  {
                                    (DQ 
                                      (word_part.CommandSubPart
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (C {(gettext)} {(DQ ('Could not commit staged changes.'))})
                                            ]
                                          )
                                        left_token: <Left_CommandSub '$('>
                                        spids: [7469 7475]
                                      )
                                    )
                                  }
                                )
                              ]
                            )
                          ]
                          spids: [7434 7479]
                        )
                      ]
                      spids: [7238 7482]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [(C {(test)} {(-r)} {(DQ ($ VSub_Name '$state_dir')) (/stopped-sha)})]
                          action: [
                            (C {(record_in_rewritten)} 
                              {
                                (DQ 
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(cat)} {(DQ ($ VSub_Name '$state_dir')) (/stopped-sha)})
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [7504 7511]
                                  )
                                )
                              }
                            )
                          ]
                          spids: [16777215 7498]
                        )
                      ]
                      spids: [16777215 7515]
                    )
                    (C {(require_clean_work_tree)} {(DQ (rebase))})
                    (C {(do_rest)})
                    (command.ControlFlow
                      token: <ControlFlow_Return return>
                      arg_word: {(0)}
                    )
                  ]
                  spids: [7170 7171 7534 16777215]
                )
                (case_arm
                  pat_list: [{(skip)}]
                  action: [
                    (C {(git)} {(rerere)} {(clear)})
                    (C {(do_rest)})
                    (command.ControlFlow
                      token: <ControlFlow_Return return>
                      arg_word: {(0)}
                    )
                  ]
                  spids: [7536 7537 7556 16777215]
                )
                (case_arm
                  pat_list: [{(edit-todo)}]
                  action: [
                    (command.SimpleCommand
                      words: [{(git)} {(stripspace)} {(--strip-comments)}]
                      redirects: [
                        (redir.Redir
                          op: <Redir_Less '<'>
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_Name '$todo'))}
                        )
                        (redir.Redir
                          op: <Redir_Great '>'>
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_Name '$todo')) (.new)}
                        )
                      ]
                    )
                    (C {(mv)} {(-f)} {(DQ ($ VSub_Name '$todo')) (.new)} {(DQ ($ VSub_Name '$todo'))})
                    (C {(collapse_todo_ids)})
                    (C {(append_todo_help)})
                    (command.Pipeline
                      children: [
                        (C {(gettext)} 
                          {
                            (DQ ('\n') 
                              ('You are editing the todo file of an ongoing interactive rebase.\n') ('To continue rebase after editing, run:\n') ('    git rebase --continue\n') ('\n')
                            )
                          }
                        )
                        (command.SimpleCommand
                          words: [{(git)} {(stripspace)} {(--comment-lines)}]
                          redirects: [
                            (redir.Redir
                              op: <Redir_DGreat '>>'>
                              fd: 16777215
                              arg_word: {(DQ ($ VSub_Name '$todo'))}
                            )
                          ]
                        )
                      ]
                      negated: F
                    )
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(git_sequence_editor)} {(DQ ($ VSub_Name '$todo'))})
                        (C {(die)} 
                          {
                            (DQ 
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [(C {(gettext)} {(DQ ('Could not execute editor'))})]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [7637 7643]
                              )
                            )
                          }
                        )
                      ]
                    )
                    (C {(expand_todo_ids)})
                    (command.ControlFlow token:<ControlFlow_Exit exit>)
                  ]
                  spids: [7558 7559 7654 16777215]
                )
              ]
              spids: [7162 7168 7656]
            )
            (C {(comment_for_reflog)} {(start)})
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(KW_Bang '!')} {(-z)} {(DQ ($ VSub_Name '$switch_to'))})]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:GIT_REFLOG_ACTION spids:[7679])
                          op: Equal
                          rhs: 
                            {
                              (DQ ($ VSub_Name '$GIT_REFLOG_ACTION') (': checkout ') 
                                ($ VSub_Name '$switch_to')
                              )
                            }
                          spids: [7679]
                        )
                      ]
                      spids: [7679]
                    )
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(output)} {(git)} {(checkout)} {(DQ ($ VSub_Name '$switch_to'))} {(--)})
                        (C {(die)} 
                          {
                            (DQ 
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(eval_gettext)} 
                                        {
                                          (DQ ('Could not checkout ') 
                                            (word_part.EscapedLiteralPart
                                              token: <Lit_EscapedChar '\\$'>
                                            ) (switch_to)
                                          )
                                        }
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [7705 7713]
                              )
                            )
                          }
                        )
                      ]
                    )
                    (C {(comment_for_reflog)} {(start)})
                  ]
                  spids: [16777215 7676]
                )
              ]
              spids: [16777215 7722]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:orig_head spids:[7725])
                      op: Equal
                      rhs: 
                        {
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [(C {(git)} {(rev-parse)} {(--verify)} {(HEAD)})]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [7726 7734]
                          )
                        }
                      spids: [7725]
                    )
                  ]
                  spids: [7725]
                )
                (C {(die)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [(C {(gettext)} {(DQ ('No HEAD?'))})]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [7741 7747]
                      )
                    )
                  }
                )
              ]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(mkdir)} {(-p)} {(DQ ($ VSub_Name '$state_dir'))})
                (C {(die)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {(eval_gettext)} 
                                {
                                  (DQ ('Could not create temporary ') 
                                    (word_part.EscapedLiteralPart
                                      token: <Lit_EscapedChar '\\$'>
                                    ) (state_dir)
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [7763 7771]
                      )
                    )
                  }
                )
              ]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (command.SimpleCommand
                  words: [{(Lit_Other ':')}]
                  redirects: [
                    (redir.Redir
                      op: <Redir_Great '>'>
                      fd: 16777215
                      arg_word: {(DQ ($ VSub_Name '$state_dir')) (/interactive)}
                    )
                  ]
                )
                (C {(die)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [(C {(gettext)} {(DQ ('Could not mark as interactive'))})]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [7789 7795]
                      )
                    )
                  }
                )
              ]
            )
            (C {(write_basic_state)})
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(t)} {(Lit_Other '=')} {(DQ ($ VSub_Name '$preserve_merges'))})]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name '$rebase_root'))})]
                          action: [
                            (command.AndOr
                              ops: [Op_DAmp]
                              children: [
                                (C {(mkdir)} {(DQ ($ VSub_Name '$rewritten'))})
                                (command.ForEach
                                  iter_name: c
                                  iter_words: [
                                    {
                                      (word_part.CommandSubPart
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (C {(git)} {(merge-base)} {(--all)} 
                                                {($ VSub_Name '$orig_head')} {($ VSub_Name '$upstream')}
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub '$('>
                                        spids: [7844 7854]
                                      )
                                    }
                                  ]
                                  do_arg_iter: F
                                  body: 
                                    (command.DoGroup
                                      children: [
                                        (command.AndOr
                                          ops: [Op_DPipe]
                                          children: [
                                            (command.SimpleCommand
                                              words: [{(echo)} {($ VSub_Name '$onto')}]
                                              redirects: [
                                                (redir.Redir
                                                  op: <Redir_Great '>'>
                                                  fd: 16777215
                                                  arg_word: 
                                                    {(DQ ($ VSub_Name '$rewritten')) (/) 
                                                      ($ VSub_Name '$c')
                                                    }
                                                )
                                              ]
                                            )
                                            (C {(die)} 
                                              {
                                                (DQ 
                                                  (word_part.CommandSubPart
                                                    command_list: 
                                                      (command.CommandList
                                                        children: [
                                                          (C {(gettext)} 
                                                            {
                                                              (DQ 
                                                                (
'Could not init rewritten commits'
                                                                )
                                                              )
                                                            }
                                                          )
                                                        ]
                                                      )
                                                    left_token: <Left_CommandSub '$('>
                                                    spids: [7878 7884]
                                                  )
                                                )
                                              }
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [7857 7888]
                                    )
                                  spids: [7843 16777215]
                                )
                              ]
                            )
                          ]
                          spids: [16777215 7826]
                        )
                      ]
                      else_action: [
                        (command.AndOr
                          ops: [Op_DAmp Op_DPipe]
                          children: [
                            (C {(mkdir)} {(DQ ($ VSub_Name '$rewritten'))})
                            (command.SimpleCommand
                              words: [{(echo)} {($ VSub_Name '$onto')}]
                              redirects: [
                                (redir.Redir
                                  op: <Redir_Great '>'>
                                  fd: 16777215
                                  arg_word: {(DQ ($ VSub_Name '$rewritten')) (/root)}
                                )
                              ]
                            )
                            (C {(die)} 
                              {
                                (DQ 
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(gettext)} {(DQ ('Could not init rewritten commits'))})
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [7920 7926]
                                  )
                                )
                              }
                            )
                          ]
                        )
                      ]
                      spids: [7891 7930]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:merges_option spids:[7945])
                          op: Equal
                          rhs: (word.EmptyWord)
                          spids: [7945]
                        )
                      ]
                      spids: [7945]
                    )
                  ]
                  spids: [16777215 7812]
                )
              ]
              else_action: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:merges_option spids:[7950])
                      op: Equal
                      rhs: {(DQ ('--no-merges --cherry-pick'))}
                      spids: [7950]
                    )
                  ]
                  spids: [7950]
                )
              ]
              spids: [7947 7955]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:shorthead spids:[7958])
                  op: Equal
                  rhs: 
                    {
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {(git)} {(rev-parse)} {(--short)} {($ VSub_Name '$orig_head')})
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [7959 7967]
                      )
                    }
                  spids: [7958]
                )
              ]
              spids: [7958]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:shortonto spids:[7969])
                  op: Equal
                  rhs: 
                    {
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [(C {(git)} {(rev-parse)} {(--short)} {($ VSub_Name '$onto')})]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [7970 7978]
                      )
                    }
                  spids: [7969]
                )
              ]
              spids: [7969]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name '$rebase_root'))})]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:shortupstream spids:[7997])
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(git)} {(rev-parse)} {(--short)} {($ VSub_Name '$upstream')})
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [7998 8006]
                              )
                            }
                          spids: [7997]
                        )
                      ]
                      spids: [7997]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:revisions spids:[8009])
                          op: Equal
                          rhs: {($ VSub_Name '$upstream') (...) ($ VSub_Name '$orig_head')}
                          spids: [8009]
                        )
                      ]
                      spids: [8009]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:shortrevisions spids:[8015])
                          op: Equal
                          rhs: {($ VSub_Name '$shortupstream') (..) ($ VSub_Name '$shorthead')}
                          spids: [8015]
                        )
                      ]
                      spids: [8015]
                    )
                  ]
                  spids: [16777215 7994]
                )
              ]
              else_action: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:revisions spids:[8023])
                      op: Equal
                      rhs: {($ VSub_Name '$onto') (...) ($ VSub_Name '$orig_head')}
                      spids: [8023]
                    )
                  ]
                  spids: [8023]
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:shortrevisions spids:[8029])
                      op: Equal
                      rhs: {($ VSub_Name '$shorthead')}
                      spids: [8029]
                    )
                  ]
                  spids: [8029]
                )
              ]
              spids: [8020 8032]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:format spids:[8034])
                  op: Equal
                  rhs: 
                    {
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [(C {(git)} {(config)} {(--get)} {(rebase.instructionFormat)})]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [8035 8043]
                      )
                    }
                  spids: [8034]
                )
              ]
              spids: [8034]
            )
            (command.Pipeline
              children: [
                (C {(git)} {(rev-list)} {($ VSub_Name '$merges_option')} 
                  {(--format) (Lit_Other '=') 
                    (DQ ('%m%H ') 
                      (word_part.BracedVarSub
                        token: <VSub_Name format>
                        suffix_op: 
                          (suffix_op.StringUnary
                            op_id: VTest_ColonHyphen
                            arg_word: {(Lit_Percent '%') (s)}
                          )
                        spids: [8058 8063]
                      )
                    )
                  } {(--reverse)} {(--left-right)} {(--topo-order)} {($ VSub_Name '$revisions')} 
                  {
                    (word_part.BracedVarSub
                      token: <VSub_Name restrict_revision>
                      suffix_op: 
                        (suffix_op.StringUnary
                          op_id: VTest_Plus
                          arg_word: {('^') ($ VSub_Name '$restrict_revision')}
                        )
                      spids: [8078 8083]
                    )
                  }
                )
                (C {(sed)} {(-n)} {(DQ ('s/^>//p'))})
                (command.WhileUntil
                  keyword: <KW_While while>
                  cond: [(C {(read)} {(-r)} {(sha1)} {(rest)})]
                  body: 
                    (command.DoGroup
                      children: [
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.AndOr
                                  ops: [Op_DAmp Op_DAmp]
                                  children: [
                                    (C {(test)} {(-z)} {(DQ ($ VSub_Name '$keep_empty'))})
                                    (C {(is_empty_commit)} {($ VSub_Name '$sha1')})
                                    (command.Pipeline
                                      children: [(C {(is_merge_commit)} {($ VSub_Name '$sha1')})]
                                      negated: T
                                    )
                                  ]
                                )
                              ]
                              action: [
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:comment_out spids:[8141])
                                      op: Equal
                                      rhs: {(DQ ($ VSub_Name '$comment_char') (' '))}
                                      spids: [8141]
                                    )
                                  ]
                                  spids: [8141]
                                )
                              ]
                              spids: [16777215 8138]
                            )
                          ]
                          else_action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:comment_out spids:[8151])
                                  op: Equal
                                  rhs: (word.EmptyWord)
                                  spids: [8151]
                                )
                              ]
                              spids: [8151]
                            )
                          ]
                          spids: [8148 8154]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (C {(test)} {(t)} {(KW_Bang '!') (Lit_Other '=')} 
                                  {(DQ ($ VSub_Name '$preserve_merges'))}
                                )
                              ]
                              action: [
                                (command.SimpleCommand
                                  words: [
                                    {(printf)}
                                    {(SQ <'%s\\n'>)}
                                    {
                                      (DQ (${ VSub_Name comment_out) ('pick ') ($ VSub_Name '$sha1') 
                                        (' ') ($ VSub_Name '$rest')
                                      )
                                    }
                                  ]
                                  redirects: [
                                    (redir.Redir
                                      op: <Redir_DGreat '>>'>
                                      fd: 16777215
                                      arg_word: {(DQ ($ VSub_Name '$todo'))}
                                    )
                                  ]
                                )
                              ]
                              spids: [16777215 8172]
                            )
                          ]
                          else_action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name '$rebase_root'))})]
                                  action: [
                                    (command.Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:preserve spids:[8214])
                                          op: Equal
                                          rhs: {(t)}
                                          spids: [8214]
                                        )
                                      ]
                                      spids: [8214]
                                    )
                                    (command.ForEach
                                      iter_name: p
                                      iter_words: [
                                        {
                                          (word_part.CommandSubPart
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (command.Pipeline
                                                    children: [
                                                      (C {(git)} {(rev-list)} {(--parents)} {(-1)} 
                                                        {($ VSub_Name '$sha1')}
                                                      )
                                                      (C {(cut)} {(-d) (SQ <' '>)} {(-s)} {(-f2-)})
                                                    ]
                                                    negated: F
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub '$('>
                                            spids: [8224 8247]
                                          )
                                        }
                                      ]
                                      do_arg_iter: F
                                      body: 
                                        (command.DoGroup
                                          children: [
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (C {(test)} {(-f)} 
                                                      {(DQ ($ VSub_Name '$rewritten')) (/) 
                                                        ($ VSub_Name '$p')
                                                      }
                                                    )
                                                  ]
                                                  action: [
                                                    (command.Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: 
                                                            (lhs_expr.LhsName
                                                              name: preserve
                                                              spids: [8269]
                                                            )
                                                          op: Equal
                                                          rhs: {(f)}
                                                          spids: [8269]
                                                        )
                                                      ]
                                                      spids: [8269]
                                                    )
                                                  ]
                                                  spids: [16777215 8266]
                                                )
                                              ]
                                              spids: [16777215 8273]
                                            )
                                          ]
                                          spids: [8250 8276]
                                        )
                                      spids: [8223 16777215]
                                    )
                                  ]
                                  spids: [16777215 8211]
                                )
                              ]
                              else_action: [
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:preserve spids:[8282])
                                      op: Equal
                                      rhs: {(f)}
                                      spids: [8282]
                                    )
                                  ]
                                  spids: [8282]
                                )
                              ]
                              spids: [8279 8286]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (C {(test)} {(f)} {(Lit_Other '=')} {(DQ ($ VSub_Name '$preserve'))})
                                  ]
                                  action: [
                                    (C {(touch)} 
                                      {(DQ ($ VSub_Name '$rewritten')) (/) ($ VSub_Name '$sha1')}
                                    )
                                    (command.SimpleCommand
                                      words: [
                                        {(printf)}
                                        {(SQ <'%s\\n'>)}
                                        {
                                          (DQ (${ VSub_Name comment_out) ('pick ') 
                                            ($ VSub_Name '$sha1') (' ') ($ VSub_Name '$rest')
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (redir.Redir
                                          op: <Redir_DGreat '>>'>
                                          fd: 16777215
                                          arg_word: {(DQ ($ VSub_Name '$todo'))}
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [16777215 8302]
                                )
                              ]
                              spids: [16777215 8336]
                            )
                          ]
                          spids: [8197 8339]
                        )
                      ]
                      spids: [8109 8341]
                    )
                )
              ]
              negated: F
            )
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(t)} {(Lit_Other '=')} {(DQ ($ VSub_Name '$preserve_merges'))})]
                  action: [
                    (C {(mkdir)} {(DQ ($ VSub_Name '$dropped'))})
                    (command.Pipeline
                      children: [
                        (C {(git)} {(rev-list)} {($ VSub_Name '$revisions')} {(--left-right)} 
                          {(--cherry-pick)}
                        )
                        (command.SimpleCommand
                          words: [{(sed)} {(-n)} {(DQ ('s/^>//p'))}]
                          redirects: [
                            (redir.Redir
                              op: <Redir_Great '>'>
                              fd: 16777215
                              arg_word: {(DQ ($ VSub_Name '$state_dir')) (/not-cherry-picks)}
                            )
                          ]
                        )
                      ]
                      negated: F
                    )
                    (command.Pipeline
                      children: [
                        (C {(git)} {(rev-list)} {($ VSub_Name '$revisions')})
                        (command.WhileUntil
                          keyword: <KW_While while>
                          cond: [(C {(read)} {(rev)})]
                          body: 
                            (command.DoGroup
                              children: [
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (command.AndOr
                                          ops: [Op_DAmp]
                                          children: [
                                            (C {(test)} {(-f)} 
                                              {(DQ ($ VSub_Name '$rewritten')) (/) 
                                                ($ VSub_Name '$rev')
                                              }
                                            )
                                            (command.Pipeline
                                              children: [
                                                (command.SimpleCommand
                                                  words: [
                                                    {(sane_grep)}
                                                    {(DQ ($ VSub_Name '$rev'))}
                                                    {(DQ ($ VSub_Name '$state_dir')) 
                                                      (/not-cherry-picks)
                                                    }
                                                  ]
                                                  redirects: [
                                                    (redir.Redir
                                                      op: <Redir_Great '>'>
                                                      fd: 16777215
                                                      arg_word: {(/dev/null)}
                                                    )
                                                  ]
                                                )
                                              ]
                                              negated: T
                                            )
                                          ]
                                        )
                                      ]
                                      action: [
                                        (command.Pipeline
                                          children: [
                                            (C {(git)} {(rev-list)} {(--parents)} {(-1)} 
                                              {($ VSub_Name '$rev')}
                                            )
                                            (command.SimpleCommand
                                              words: [{(cut)} {(-d) (SQ <' '>)} {(-s)} {(-f2)}]
                                              redirects: [
                                                (redir.Redir
                                                  op: <Redir_Great '>'>
                                                  fd: 16777215
                                                  arg_word: 
                                                    {(DQ ($ VSub_Name '$dropped')) (/) 
                                                      ($ VSub_Name '$rev')
                                                    }
                                                )
                                              ]
                                            )
                                          ]
                                          negated: F
                                        )
                                        (command.Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (lhs_expr.LhsName name:sha1 spids:[8513])
                                              op: Equal
                                              rhs: 
                                                {
                                                  (word_part.CommandSubPart
                                                    command_list: 
                                                      (command.CommandList
                                                        children: [
                                                          (C {(git)} {(rev-list)} {(-1)} 
                                                            {($ VSub_Name '$rev')}
                                                          )
                                                        ]
                                                      )
                                                    left_token: <Left_CommandSub '$('>
                                                    spids: [8514 8522]
                                                  )
                                                }
                                              spids: [8513]
                                            )
                                          ]
                                          spids: [8513]
                                        )
                                        (command.Sentence
                                          child: 
                                            (command.SimpleCommand
                                              words: [
                                                {(sane_grep)}
                                                {(-v)}
                                                {(DQ ('^[a-z][a-z]* ') ($ VSub_Name '$sha1'))}
                                              ]
                                              redirects: [
                                                (redir.Redir
                                                  op: <Redir_Less '<'>
                                                  fd: 16777215
                                                  arg_word: {(DQ ($ VSub_Name '$todo'))}
                                                )
                                                (redir.Redir
                                                  op: <Redir_Great '>'>
                                                  fd: 16777215
                                                  arg_word: {(DQ (${ VSub_Name todo) (2))}
                                                )
                                              ]
                                            )
                                          terminator: <Op_Semi ';'>
                                        )
                                        (C {(mv)} {(DQ (${ VSub_Name todo) (2))} 
                                          {(DQ ($ VSub_Name '$todo'))}
                                        )
                                        (C {(rm)} 
                                          {(DQ ($ VSub_Name '$rewritten')) (/) ($ VSub_Name '$rev')}
                                        )
                                      ]
                                      spids: [16777215 8462]
                                    )
                                  ]
                                  spids: [16777215 8573]
                                )
                              ]
                              spids: [8427 8576]
                            )
                        )
                      ]
                      negated: F
                    )
                  ]
                  spids: [16777215 8359]
                )
              ]
              spids: [16777215 8578]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(test)} {(-s)} {(DQ ($ VSub_Name '$todo'))})
                (command.SimpleCommand
                  words: [{(echo)} {(noop)}]
                  redirects: [
                    (redir.Redir
                      op: <Redir_DGreat '>>'>
                      fd: 16777215
                      arg_word: {(DQ ($ VSub_Name '$todo'))}
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_Name '$autosquash'))})
                (C {(rearrange_squash)} {(DQ ($ VSub_Name '$todo'))})
              ]
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_Name '$cmd'))})
                (C {(add_exec_commands)} {(DQ ($ VSub_Name '$todo'))})
              ]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:todocount spids:[8634])
                  op: Equal
                  rhs: 
                    {
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [
                              (command.Pipeline
                                children: [
                                  (command.SimpleCommand
                                    words: [{(git)} {(stripspace)} {(--strip-comments)}]
                                    redirects: [
                                      (redir.Redir
                                        op: <Redir_Less '<'>
                                        fd: 16777215
                                        arg_word: {(DQ ($ VSub_Name '$todo'))}
                                      )
                                    ]
                                  )
                                  (C {(wc)} {(-l)})
                                ]
                                negated: F
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [8635 8652]
                      )
                    }
                  spids: [8634]
                )
              ]
              spids: [8634]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:todocount spids:[8654])
                  op: Equal
                  rhs: 
                    {
                      (word_part.BracedVarSub
                        token: <VSub_Name todocount>
                        suffix_op: (suffix_op.StringUnary op_id:VOp1_DPound arg_word:{('* ')})
                        spids: [8655 8659]
                      )
                    }
                  spids: [8654]
                )
              ]
              spids: [8654]
            )
            (command.SimpleCommand
              words: [{(cat)}]
              redirects: [
                (redir.Redir
                  op: <Redir_DGreat '>>'>
                  fd: 16777215
                  arg_word: {(DQ ($ VSub_Name '$todo'))}
                )
                (redir.HereDoc
                  op: <Redir_DLess '<<'>
                  fd: 16777215
                  here_begin: {(EOF)}
                  here_end_span_id: 8710
                  stdin_parts: [
                    ('\n')
                    ($ VSub_Name '$comment_char')
                    (' ')
                    (word_part.CommandSubPart
                      command_list: 
                        (command.CommandList
                          children: [
                            (C {(eval_ngettext)} 
                              {
                                (DQ ('Rebase ') 
                                  (word_part.EscapedLiteralPart
                                    token: <Lit_EscapedChar '\\$'>
                                  ) ('shortrevisions onto ') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) ('shortonto (') 
                                  (word_part.EscapedLiteralPart
                                    token: <Lit_EscapedChar '\\$'>
                                  ) ('todocount command)')
                                )
                              } 
                              {
                                (DQ ('Rebase ') 
                                  (word_part.EscapedLiteralPart
                                    token: <Lit_EscapedChar '\\$'>
                                  ) ('shortrevisions onto ') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) ('shortonto (') 
                                  (word_part.EscapedLiteralPart
                                    token: <Lit_EscapedChar '\\$'>
                                  ) ('todocount commands)')
                                )
                              } {(DQ ($ VSub_Name '$todocount'))}
                            )
                          ]
                        )
                      left_token: <Left_CommandSub '$('>
                      spids: [8675 8707]
                    )
                    ('\n')
                  ]
                )
              ]
            )
            (C {(append_todo_help)})
            (command.Pipeline
              children: [
                (C {(gettext)} 
                  {
                    (DQ ('\n') ('However, if you remove everything, the rebase will be aborted.\n') 
                      ('\n')
                    )
                  }
                )
                (command.SimpleCommand
                  words: [{(git)} {(stripspace)} {(--comment-lines)}]
                  redirects: [
                    (redir.Redir
                      op: <Redir_DGreat '>>'>
                      fd: 16777215
                      arg_word: {(DQ ($ VSub_Name '$todo'))}
                    )
                  ]
                )
              ]
              negated: F
            )
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name '$keep_empty'))})]
                  action: [
                    (command.SimpleCommand
                      words: [
                        {(printf)}
                        {(SQ <'%s\\n'>)}
                        {
                          (DQ ($ VSub_Name '$comment_char') (' ') 
                            (word_part.CommandSubPart
                              command_list: 
                                (command.CommandList
                                  children: [
                                    (C {(gettext)} {(DQ ('Note that empty commits are commented out'))})
                                  ]
                                )
                              left_token: <Left_CommandSub '$('>
                              spids: [8757 8763]
                            )
                          )
                        }
                      ]
                      redirects: [
                        (redir.Redir
                          op: <Redir_DGreat '>>'>
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_Name '$todo'))}
                        )
                      ]
                    )
                  ]
                  spids: [16777215 8745]
                )
              ]
              spids: [16777215 8771]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(has_action)} {(DQ ($ VSub_Name '$todo'))})
                (command.ControlFlow token:<ControlFlow_Return return> arg_word:{(2)})
              ]
            )
            (C {(cp)} {(DQ ($ VSub_Name '$todo'))} {(DQ ($ VSub_Name '$todo')) (.backup)})
            (C {(collapse_todo_ids)})
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(git_sequence_editor)} {(DQ ($ VSub_Name '$todo'))})
                (C {(die_abort)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [(C {(gettext)} {(DQ ('Could not execute editor'))})]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [8814 8820]
                      )
                    )
                  }
                )
              ]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(has_action)} {(DQ ($ VSub_Name '$todo'))})
                (command.ControlFlow token:<ControlFlow_Return return> arg_word:{(2)})
              ]
            )
            (C {(check_todo_list)})
            (C {(expand_todo_ids)})
            (command.AndOr
              ops: [Op_DPipe Op_DPipe]
              children: [
                (C {(test)} {(-d)} {(DQ ($ VSub_Name '$rewritten'))})
                (C {(test)} {(-n)} {(DQ ($ VSub_Name '$force_rebase'))})
                (C {(skip_unnecessary_picks)})
              ]
            )
            (C {(checkout_onto)})
            (C {(do_rest)})
          ]
          spids: [7159]
        )
      spids: [7154 7158]
    )
    (C {(git_rebase__interactive)})
  ]
)