(command.CommandList
  children: [
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:todo)
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_DollarName '$state_dir')) <'/git-rebase-todo'>}
          spids: [39]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:done)
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_DollarName '$state_dir')) <'/done'>}
          spids: [55]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:msg)
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_DollarName '$state_dir')) <'/message'>}
          spids: [68]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:squash_msg)
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_DollarName '$state_dir')) <'/message-squash'>}
          spids: [114]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:fixup_msg)
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_DollarName '$state_dir')) <'/message-fixup'>}
          spids: [136]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:rewritten)
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_DollarName '$state_dir')) <'/rewritten'>}
          spids: [161]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:dropped)
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_DollarName '$state_dir')) <'/dropped'>}
          spids: [168]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:end)
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_DollarName '$state_dir')) <'/end'>}
          spids: [175]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:msgnum)
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_DollarName '$state_dir')) <'/msgnum'>}
          spids: [181]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:author_script)
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_DollarName '$state_dir')) <'/author-script'>}
          spids: [197]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:amend)
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_DollarName '$state_dir')) <'/amend'>}
          spids: [222]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:rewritten_list)
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_DollarName '$state_dir')) <'/rewritten-list'>}
          spids: [241]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:rewritten_pending)
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_DollarName '$state_dir')) <'/rewritten-pending'>}
          spids: [247]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:cr)
          op: assign_op.Equal
          rhs: 
            {
              (command_sub
                left_token: <Id.Left_DollarParen '$('>
                child: (C {<printf>} {(DQ <Id.Lit_BadBackslash '\\'> <015>)})
              )
            }
          spids: [260]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:strategy_args)
          op: assign_op.Equal
          rhs: 
            {
              (braced_var_sub
                token: <Id.VSub_Name strategy>
                suffix_op: 
                  (suffix_op.Unary
                    tok: <Id.VTest_ColonPlus ':+'>
                    arg_word: {<'--strategy='> ($ Id.VSub_DollarName '$strategy')}
                  )
              )
            }
          spids: [271]
        )
      ]
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$strategy_opts'))})
        (C {<eval>} 
          {(SQ <'\n'> <'\tfor strategy_opt in '>) (DQ ($ Id.VSub_DollarName '$strategy_opts')) 
            (SQ <'\n'> <'\tdo\n'> 
              <
'\t\tstrategy_args="$strategy_args -X$(git rev-parse --sq-quote "${strategy_opt#--}")"\n'
              > <'\tdone\n'>
            )
          }
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:GIT_CHERRY_PICK_HELP)
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_DollarName '$resolvemsg'))}
          spids: [306]
        )
      ]
    )
    (C {<export>} {<GIT_CHERRY_PICK_HELP>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:comment_char)
          op: assign_op.Equal
          rhs: 
            {
              (command_sub
                left_token: <Id.Left_DollarParen '$('>
                child: 
                  (command.Pipeline
                    children: [
                      (command.Simple
                        words: [{<git>} {<config>} {<--get>} {<core.commentchar>}]
                        redirects: [
                          (redir
                            op: <Id.Redir_Great '2>'>
                            loc: (redir_loc.Fd fd:2)
                            arg: {<'/dev/null'>}
                          )
                        ]
                        do_fork: T
                      )
                      (C {<cut>} {<-c1>})
                    ]
                    negated: F
                  )
              )
            }
          spids: [316]
        )
      ]
    )
    (C {<Id.Lit_Colon ':'>} 
      {
        (braced_var_sub
          token: <Id.VSub_Name comment_char>
          suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonEquals ':='> arg_word:{<Id.Lit_Pound '#'>})
        )
      }
    )
    (command.ShFunction
      name: warn
      body: 
        (BraceGroup
          children: [
            (command.Simple
              words: [{<printf>} {(SQ <'%s\\n'>)} {(DQ ($ Id.VSub_Star '$*'))}]
              redirects: [(redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
              do_fork: T
            )
          ]
        )
    )
    (command.ShFunction
      name: commit_message
      body: 
        (BraceGroup
          children: [
            (command.Pipeline
              children: [
                (C {<git>} {<cat-file>} {<commit>} {(DQ ($ Id.VSub_Number '$1'))})
                (C {<sed>} {(DQ <'1,/^'> <Id.Lit_Dollar '$'> <'/d'>)})
              ]
              negated: F
            )
          ]
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:orig_reflog_action)
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_DollarName '$GIT_REFLOG_ACTION'))}
          spids: [403]
        )
      ]
    )
    (command.ShFunction
      name: comment_for_reflog
      body: 
        (BraceGroup
          children: [
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName '$orig_reflog_action'))}
              arms: [
                (case_arm
                  pat_list: [{(SQ )} {<rebase> <Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:GIT_REFLOG_ACTION)
                          op: assign_op.Equal
                          rhs: {(DQ <'rebase -i ('> ($ Id.VSub_Number '$1') <')'>)}
                          spids: [434]
                        )
                      ]
                    )
                    (C {<export>} {<GIT_REFLOG_ACTION>})
                  ]
                  spids: [426 431 447 -1]
                )
              ]
            )
          ]
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:last_count)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [455]
        )
      ]
    )
    (command.ShFunction
      name: mark_action_done
      body: 
        (BraceGroup
          children: [
            (command.Simple
              words: [{<sed>} {<-e>} {<1q>}]
              redirects: [
                (redir
                  op: <Id.Redir_Less '<'>
                  loc: (redir_loc.Fd fd:0)
                  arg: {(DQ ($ Id.VSub_DollarName '$todo'))}
                )
                (redir
                  op: <Id.Redir_DGreat '>>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ ($ Id.VSub_DollarName '$done'))}
                )
              ]
              do_fork: T
            )
            (command.Simple
              words: [{<sed>} {<-e>} {<1d>}]
              redirects: [
                (redir
                  op: <Id.Redir_Less '<'>
                  loc: (redir_loc.Fd fd:0)
                  arg: {(DQ ($ Id.VSub_DollarName '$todo'))}
                )
                (redir
                  op: <Id.Redir_DGreat '>>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ ($ Id.VSub_DollarName '$todo')) <.new>}
                )
              ]
              do_fork: T
            )
            (C {<mv>} {<-f>} {(DQ ($ Id.VSub_DollarName '$todo')) <.new>} 
              {(DQ ($ Id.VSub_DollarName '$todo'))}
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:new_count)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (word_part.ArithSub
                        anode: 
                          {
                            (command_sub
                              left_token: <Id.Left_DollarParen '$('>
                              child: 
                                (command.Pipeline
                                  children: [
                                    (command.Simple
                                      words: [{<git>} {<stripspace>} {<--strip-comments>}]
                                      redirects: [
                                        (redir
                                          op: <Id.Redir_Less '<'>
                                          loc: (redir_loc.Fd fd:0)
                                          arg: {(DQ ($ Id.VSub_DollarName '$done'))}
                                        )
                                      ]
                                      do_fork: T
                                    )
                                    (C {<wc>} {<-l>})
                                  ]
                                  negated: F
                                )
                            )
                          }
                      )
                    }
                  spids: [518]
                )
              ]
            )
            (command.Simple
              words: [{<echo>} {($ Id.VSub_DollarName '$new_count')}]
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ ($ Id.VSub_DollarName '$msgnum'))}
                )
              ]
              do_fork: T
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:total)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (word_part.ArithSub
                        anode: 
                          (arith_expr.Binary
                            op_id: Id.Arith_Plus
                            left: {($ Id.VSub_DollarName '$new_count')}
                            right: 
                              {
                                (command_sub
                                  left_token: <Id.Left_DollarParen '$('>
                                  child: 
                                    (command.Pipeline
                                      children: [
                                        (command.Simple
                                          words: [{<git>} {<stripspace>} {<--strip-comments>}]
                                          redirects: [
                                            (redir
                                              op: <Id.Redir_Less '<'>
                                              loc: (redir_loc.Fd fd:0)
                                              arg: {(DQ ($ Id.VSub_DollarName '$todo'))}
                                            )
                                          ]
                                          do_fork: T
                                        )
                                        (C {<wc>} {<-l>})
                                      ]
                                      negated: F
                                    )
                                )
                              }
                          )
                      )
                    }
                  spids: [554]
                )
              ]
            )
            (command.Simple
              words: [{<echo>} {($ Id.VSub_DollarName '$total')}]
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ ($ Id.VSub_DollarName '$end'))}
                )
              ]
              do_fork: T
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (C {<test>} {(DQ ($ Id.VSub_DollarName '$last_count'))} 
                          {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ ($ Id.VSub_DollarName '$new_count'))}
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:last_count)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName '$new_count')}
                          spids: [611]
                        )
                      ]
                    )
                    (command.Sentence
                      child: 
                        (C {<eval_gettext>} 
                          {
                            (DQ <'Rebasing ('> 
                              (word_part.EscapedLiteral
                                token: <Id.Lit_EscapedChar '\\$'>
                              ) <'new_count/'> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'total)'>
                            )
                          }
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (C {<printf>} {(DQ <Id.Lit_BadBackslash '\\'> <r>)})
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$verbose'))})
                        (C {<echo>})
                      ]
                    )
                  ]
                  spids: [592 608]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: reschedule_last_action
      body: 
        (BraceGroup
          children: [
            (command.Pipeline
              children: [
                (C {<tail>} {<-n>} {<1>} {(DQ ($ Id.VSub_DollarName '$done'))})
                (command.Simple
                  words: [{<cat>} {<->} {(DQ ($ Id.VSub_DollarName '$todo'))}]
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {(DQ ($ Id.VSub_DollarName '$todo')) <.new>}
                    )
                  ]
                  do_fork: T
                )
              ]
              negated: F
            )
            (command.Simple
              words: [{<sed>} {<-e>} {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <d>}]
              redirects: [
                (redir
                  op: <Id.Redir_Less '<'>
                  loc: (redir_loc.Fd fd:0)
                  arg: {(DQ ($ Id.VSub_DollarName '$done'))}
                )
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ ($ Id.VSub_DollarName '$done')) <.new>}
                )
              ]
              do_fork: T
            )
            (C {<mv>} {<-f>} {(DQ ($ Id.VSub_DollarName '$todo')) <.new>} 
              {(DQ ($ Id.VSub_DollarName '$todo'))}
            )
            (C {<mv>} {<-f>} {(DQ ($ Id.VSub_DollarName '$done')) <.new>} 
              {(DQ ($ Id.VSub_DollarName '$done'))}
            )
          ]
        )
    )
    (command.ShFunction
      name: append_todo_help
      body: 
        (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.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) <squash> 
                      (word_part.EscapedLiteral
                        token: <Id.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.Simple
                  words: [{<git>} {<stripspace>} {<--comment-lines>}]
                  redirects: [
                    (redir
                      op: <Id.Redir_DGreat '>>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {(DQ ($ Id.VSub_DollarName '$todo'))}
                    )
                  ]
                  do_fork: T
                )
              ]
              negated: F
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (C {<test>} 
                          {
                            (command_sub
                              left_token: <Id.Left_DollarParen '$('>
                              child: (C {<get_missing_commit_check_level>})
                            )
                          } {<Id.Lit_Equals '='>} {<error>}
                        )
                      ]
                    )
                  action: [
                    (command.Pipeline
                      children: [
                        (C {<gettext>} 
                          {
                            (DQ <'\n'> 
                              <
'Do not remove any line. Use \'drop\' explicitly to remove a commit.\n'
                              >
                            )
                          }
                        )
                        (command.Simple
                          words: [{<git>} {<stripspace>} {<--comment-lines>}]
                          redirects: [
                            (redir
                              op: <Id.Redir_DGreat '>>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {(DQ ($ Id.VSub_DollarName '$todo'))}
                            )
                          ]
                          do_fork: T
                        )
                      ]
                      negated: F
                    )
                  ]
                  spids: [788 801]
                )
              ]
              else_action: [
                (command.Pipeline
                  children: [
                    (C {<gettext>} 
                      {(DQ <'\n'> <'If you remove a line here THAT COMMIT WILL BE LOST.\n'>)}
                    )
                    (command.Simple
                      words: [{<git>} {<stripspace>} {<--comment-lines>}]
                      redirects: [
                        (redir
                          op: <Id.Redir_DGreat '>>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(DQ ($ Id.VSub_DollarName '$todo'))}
                        )
                      ]
                      do_fork: T
                    )
                  ]
                  negated: F
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: make_patch
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:sha1_and_parents)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ 
                        (command_sub
                          left_token: <Id.Left_DollarParen '$('>
                          child: 
                            (C {<git>} {<rev-list>} {<--parents>} {<-1>} {(DQ ($ Id.VSub_Number '$1'))})
                        )
                      )
                    }
                  spids: [862]
                )
              ]
            )
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName '$sha1_and_parents'))}
              arms: [
                (case_arm
                  pat_list: [
                    {<Id.Lit_QMark '?'> <Id.Lit_Star '*'> (SQ <' '>) <Id.Lit_QMark '?'> 
                      <Id.Lit_Star '*'> (SQ <' '>) <Id.Lit_QMark '?'> <Id.Lit_Star '*'>
                    }
                  ]
                  action: [(C {<git>} {<diff>} {<--cc>} {($ Id.VSub_DollarName '$sha1_and_parents')})]
                  spids: [889 901 913 -1]
                )
                (case_arm
                  pat_list: [
                    {<Id.Lit_QMark '?'> <Id.Lit_Star '*'> (SQ <' '>) <Id.Lit_QMark '?'> 
                      <Id.Lit_Star '*'>
                    }
                  ]
                  action: [(C {<git>} {<diff-tree>} {<-p>} {(DQ ($ Id.VSub_Number '$1') <'^!'>)})]
                  spids: [916 923 938 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [(C {<echo>} {(DQ <'Root commit'>)})]
                  spids: [941 942 952 -1]
                )
              ]
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ ($ Id.VSub_DollarName '$state_dir')) <'/patch'>}
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<test>} {<-f>} {(DQ ($ Id.VSub_DollarName '$msg'))})
                (command.Simple
                  words: [{<commit_message>} {(DQ ($ Id.VSub_Number '$1'))}]
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {(DQ ($ Id.VSub_DollarName '$msg'))}
                    )
                  ]
                  do_fork: T
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<test>} {<-f>} {(DQ ($ Id.VSub_DollarName '$author_script'))})
                (command.Simple
                  words: [{<get_author_ident_from_commit>} {(DQ ($ Id.VSub_Number '$1'))}]
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {(DQ ($ Id.VSub_DollarName '$author_script'))}
                    )
                  ]
                  do_fork: T
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: die_with_patch
      body: 
        (BraceGroup
          children: [
            (command.Simple
              words: [{<echo>} {(DQ ($ Id.VSub_Number '$1'))}]
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ ($ Id.VSub_DollarName '$state_dir')) <'/stopped-sha'>}
                )
              ]
              do_fork: T
            )
            (C {<make_patch>} {(DQ ($ Id.VSub_Number '$1'))})
            (C {<die>} {(DQ ($ Id.VSub_Number '$2'))})
          ]
        )
    )
    (command.ShFunction
      name: exit_with_patch
      body: 
        (BraceGroup
          children: [
            (command.Simple
              words: [{<echo>} {(DQ ($ Id.VSub_Number '$1'))}]
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ ($ Id.VSub_DollarName '$state_dir')) <'/stopped-sha'>}
                )
              ]
              do_fork: T
            )
            (C {<make_patch>} {($ Id.VSub_Number '$1')})
            (command.Simple
              words: [{<git>} {<rev-parse>} {<--verify>} {<HEAD>}]
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ ($ Id.VSub_DollarName '$amend'))}
                )
              ]
              do_fork: T
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:gpg_sign_opt_quoted)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <Id.VSub_Name gpg_sign_opt>
                        suffix_op: 
                          (suffix_op.Unary
                            tok: <Id.VTest_ColonPlus ':+'>
                            arg_word: 
                              {
                                (command_sub
                                  left_token: <Id.Left_DollarParen '$('>
                                  child: 
                                    (C {<git>} {<rev-parse>} {<--sq-quote>} 
                                      {(DQ ($ Id.VSub_DollarName '$gpg_sign_opt'))}
                                    )
                                )
                              }
                          )
                      )
                    }
                  spids: [1095]
                )
              ]
            )
            (C {<warn>} 
              {
                (DQ 
                  (command_sub
                    left_token: <Id.Left_DollarParen '$('>
                    child: 
                      (C {<eval_gettext>} 
                        {
                          (DQ <'You can amend the commit now, with\n'> <'\n'> <'\tgit commit --amend '> 
                            (word_part.EscapedLiteral
                              token: <Id.Lit_EscapedChar '\\$'>
                            ) <'gpg_sign_opt_quoted\n'> <'\n'> <'Once you are satisfied with your changes, run\n'> <'\n'> 
                            <'\tgit rebase --continue'>
                          )
                        }
                      )
                  )
                )
              }
            )
            (C {<warn>})
            (command.ControlFlow
              token: <Id.ControlFlow_Exit exit>
              arg_word: {($ Id.VSub_Number '$2')}
            )
          ]
        )
    )
    (command.ShFunction
      name: die_abort
      body: 
        (BraceGroup
          children: [
            (C {<apply_autostash>})
            (C {<rm>} {<-rf>} {(DQ ($ Id.VSub_DollarName '$state_dir'))})
            (C {<die>} {(DQ ($ Id.VSub_Number '$1'))})
          ]
        )
    )
    (command.ShFunction
      name: has_action
      body: 
        (BraceGroup
          children: [
            (C {<test>} {<-n>} 
              {
                (DQ 
                  (command_sub
                    left_token: <Id.Left_DollarParen '$('>
                    child: 
                      (command.Simple
                        words: [{<git>} {<stripspace>} {<--strip-comments>}]
                        redirects: [
                          (redir
                            op: <Id.Redir_Less '<'>
                            loc: (redir_loc.Fd fd:0)
                            arg: {(DQ ($ Id.VSub_Number '$1'))}
                          )
                        ]
                        do_fork: T
                      )
                  )
                )
              }
            )
          ]
        )
    )
    (command.ShFunction
      name: is_empty_commit
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:tree)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (command.Simple
                                words: [
                                  {<git>}
                                  {<rev-parse>}
                                  {<-q>}
                                  {<--verify>}
                                  {(DQ ($ Id.VSub_Number '$1')) <Id.Lit_Other '^'> <Id.Lit_LBrace '{'> 
                                    <tree> <Id.Lit_RBrace '}'>
                                  }
                                ]
                                redirects: [
                                  (redir
                                    op: <Id.Redir_Great '2>'>
                                    loc: (redir_loc.Fd fd:2)
                                    arg: {<'/dev/null'>}
                                  )
                                ]
                                do_fork: T
                              )
                          )
                        }
                      spids: [1211]
                    )
                  ]
                )
                (BraceGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:sha1)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_Number '$1')}
                          spids: [1238]
                        )
                      ]
                    )
                    (C {<die>} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (C {<eval_gettext>} 
                                {
                                  (DQ (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) 
                                    <'sha1: not a commit that can be picked'>
                                  )
                                }
                              )
                          )
                        )
                      }
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:ptree)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (command.Simple
                                words: [
                                  {<git>}
                                  {<rev-parse>}
                                  {<-q>}
                                  {<--verify>}
                                  {(DQ ($ Id.VSub_Number '$1')) <Id.Lit_Other '^'> <Id.Lit_Other '^'> 
                                    <Id.Lit_LBrace '{'> <tree> <Id.Lit_RBrace '}'>
                                  }
                                ]
                                redirects: [
                                  (redir
                                    op: <Id.Redir_Great '2>'>
                                    loc: (redir_loc.Fd fd:2)
                                    arg: {<'/dev/null'>}
                                  )
                                ]
                                do_fork: T
                              )
                          )
                        }
                      spids: [1259]
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:ptree)
                      op: assign_op.Equal
                      rhs: {<4b825dc642cb6eb9a060e54bf8d69288fbee4904>}
                      spids: [1285]
                    )
                  ]
                )
              ]
            )
            (C {<test>} {(DQ ($ Id.VSub_DollarName '$tree'))} {<Id.Lit_Equals '='>} 
              {(DQ ($ Id.VSub_DollarName '$ptree'))}
            )
          ]
        )
    )
    (command.ShFunction
      name: is_merge_commit
      body: 
        (BraceGroup
          children: [
            (command.Simple
              words: [
                {<git>}
                {<rev-parse>}
                {<--verify>}
                {<--quiet>}
                {(DQ ($ Id.VSub_Number '$1')) <Id.Lit_Other '^'> <2>}
              ]
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {<'/dev/null'>}
                )
                (redir op:<Id.Redir_GreatAnd '2>&'> loc:(redir_loc.Fd fd:2) arg:{<1>})
              ]
              do_fork: T
            )
          ]
        )
    )
    (command.ShFunction
      name: do_with_author
      body: 
        (BraceGroup
          children: [
            (command.Subshell
              child: 
                (command.CommandList
                  children: [
                    (C {<export>} {<GIT_AUTHOR_NAME>} {<GIT_AUTHOR_EMAIL>} {<GIT_AUTHOR_DATE>})
                    (C {(DQ ($ Id.VSub_At '$@'))})
                  ]
                )
            )
          ]
        )
    )
    (command.ShFunction
      name: git_sequence_editor
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$GIT_SEQUENCE_EDITOR'))})
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:GIT_SEQUENCE_EDITOR)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (command_sub
                                  left_token: <Id.Left_DollarParen '$('>
                                  child: (C {<git>} {<config>} {<sequence.editor>})
                                )
                              )
                            }
                          spids: [1392]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (C {<Id.Lit_LBracket '['>} {<-z>} 
                                  {(DQ ($ Id.VSub_DollarName '$GIT_SEQUENCE_EDITOR'))} {<Id.Lit_RBracket ']'>}
                                )
                              ]
                            )
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:GIT_SEQUENCE_EDITOR)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (DQ 
                                            (command_sub
                                              left_token: <Id.Left_DollarParen '$('>
                                              child: (C {<git>} {<Id.KW_Var var>} {<GIT_EDITOR>})
                                            )
                                          )
                                        }
                                      spids: [1420]
                                    )
                                  ]
                                )
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Return return>
                                  arg_word: {($ Id.VSub_QMark '$?')}
                                )
                              ]
                            )
                          ]
                          spids: [1404 1417]
                        )
                      ]
                    )
                  ]
                  spids: [1378 1389]
                )
              ]
            )
            (C {<eval>} {(DQ ($ Id.VSub_DollarName '$GIT_SEQUENCE_EDITOR'))} {(SQ <'"$@"'>)})
          ]
        )
    )
    (command.ShFunction
      name: pick_one
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:ff)
                  op: assign_op.Equal
                  rhs: {<--ff>}
                  spids: [1466]
                )
              ]
            )
            (command.Case
              to_match: {(DQ ($ Id.VSub_Number '$1'))}
              arms: [
                (case_arm
                  pat_list: [{<-n>}]
                  action: [
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:sha1)
                              op: assign_op.Equal
                              rhs: {($ Id.VSub_Number '$2')}
                              spids: [1482]
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:ff)
                          op: assign_op.Equal
                          rhs: (word.Empty)
                          spids: [1486]
                        )
                      ]
                    )
                  ]
                  spids: [1479 1480 1488 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:sha1)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_Number '$1')}
                          spids: [1493]
                        )
                      ]
                    )
                  ]
                  spids: [1490 1491 1496 -1]
                )
              ]
            )
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName '$force_rebase'))}
              arms: [
                (case_arm pat_list:[{(SQ )}] spids:[1509 1511 1513 -1])
                (case_arm
                  pat_list: [{<Id.Lit_QMark '?'> <Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:ff)
                          op: assign_op.Equal
                          rhs: (word.Empty)
                          spids: [1519]
                        )
                      ]
                    )
                  ]
                  spids: [1515 1517 1521 -1]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<output>} {<git>} {<rev-parse>} {<--verify>} {($ Id.VSub_DollarName '$sha1')})
                (C {<die>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (C {<eval_gettext>} 
                            {
                              (DQ <'Invalid commit name: '> 
                                (word_part.EscapedLiteral
                                  token: <Id.Lit_EscapedChar '\\$'>
                                ) <sha1>
                              )
                            }
                          )
                      )
                    )
                  }
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [(C {<is_empty_commit>} {(DQ ($ Id.VSub_DollarName '$sha1'))})]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:empty_args)
                          op: assign_op.Equal
                          rhs: {(DQ <--allow-empty>)}
                          spids: [1566]
                        )
                      ]
                    )
                  ]
                  spids: [1554 1563]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DAmp]
              children: [
                (C {<test>} {<-d>} {(DQ ($ Id.VSub_DollarName '$rewritten'))})
                (C {<pick_one_preserving_merges>} {(DQ ($ Id.VSub_At '$@'))})
                (command.ControlFlow token:<Id.ControlFlow_Return return>)
              ]
            )
            (C {<output>} {<eval>} {<git>} {<cherry-pick>} 
              {
                (braced_var_sub
                  token: <Id.VSub_Name gpg_sign_opt>
                  suffix_op: 
                    (suffix_op.Unary
                      tok: <Id.VTest_ColonPlus ':+'>
                      arg_word: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (C {<git>} {<rev-parse>} {<--sq-quote>} 
                                {(DQ ($ Id.VSub_DollarName '$gpg_sign_opt'))}
                              )
                          )
                        }
                    )
                )
              } {(DQ ($ Id.VSub_DollarName '$strategy_args'))} {($ Id.VSub_DollarName '$empty_args')} 
              {($ Id.VSub_DollarName '$ff')} {(DQ ($ Id.VSub_At '$@'))}
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:ret)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_QMark '$?')}
                  spids: [1648]
                )
              ]
            )
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName '$ret'))}
              arms: [
                (case_arm
                  pat_list: [{<Id.Lit_LBracket '['> <01> <Id.Lit_RBracket ']'>}]
                  spids: [1660 1663 1665 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [(C {<reschedule_last_action>})]
                  spids: [1667 1668 1672 -1]
                )
              ]
            )
            (command.ControlFlow
              token: <Id.ControlFlow_Return return>
              arg_word: {($ Id.VSub_DollarName '$ret')}
            )
          ]
        )
    )
    (command.ShFunction
      name: pick_one_preserving_merges
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:fast_forward)
                  op: assign_op.Equal
                  rhs: {<t>}
                  spids: [1692]
                )
              ]
            )
            (command.Case
              to_match: {(DQ ($ Id.VSub_Number '$1'))}
              arms: [
                (case_arm
                  pat_list: [{<-n>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:fast_forward)
                          op: assign_op.Equal
                          rhs: {<f>}
                          spids: [1709]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:sha1)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_Number '$2')}
                          spids: [1713]
                        )
                      ]
                    )
                  ]
                  spids: [1705 1706 1717 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:sha1)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_Number '$1')}
                          spids: [1724]
                        )
                      ]
                    )
                  ]
                  spids: [1720 1721 1728 -1]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:sha1)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<git>} {<rev-parse>} {($ Id.VSub_DollarName '$sha1')})
                      )
                    }
                  spids: [1734]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (C {<test>} {<-f>} 
                          {(DQ ($ Id.VSub_DollarName '$state_dir')) <'/current-commit'>}
                        )
                      ]
                    )
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (C {<test>} {(DQ ($ Id.VSub_DollarName '$fast_forward'))} 
                                  {<Id.Lit_Equals '='>} {<t>}
                                )
                              ]
                            )
                          action: [
                            (command.WhileUntil
                              keyword: <Id.KW_While while>
                              cond: (condition.Shell commands:[(C {<read>} {<current_commit>})])
                              body: 
                                (command.DoGroup
                                  children: [
                                    (command.Simple
                                      words: [{<git>} {<rev-parse>} {<HEAD>}]
                                      redirects: [
                                        (redir
                                          op: <Id.Redir_Great '>'>
                                          loc: (redir_loc.Fd fd:1)
                                          arg: 
                                            {(DQ ($ Id.VSub_DollarName '$rewritten')) <'/'> 
                                              ($ Id.VSub_DollarName '$current_commit')
                                            }
                                        )
                                      ]
                                      do_fork: T
                                    )
                                  ]
                                )
                              redirects: [
                                (redir
                                  op: <Id.Redir_Less '<'>
                                  loc: (redir_loc.Fd fd:0)
                                  arg: {(DQ ($ Id.VSub_DollarName '$state_dir')) <'/current-commit'>}
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (C {<rm>} 
                                  {(DQ ($ Id.VSub_DollarName '$state_dir')) <'/current-commit'>}
                                )
                                (C {<die>} 
                                  {
                                    (DQ 
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (C {<gettext>} 
                                            {(DQ <'Cannot write current commit\'s replacement sha1'>)}
                                          )
                                      )
                                    )
                                  }
                                )
                              ]
                            )
                          ]
                          spids: [1760 1773]
                        )
                      ]
                    )
                  ]
                  spids: [1745 1757]
                )
              ]
            )
            (command.Simple
              words: [{<echo>} {($ Id.VSub_DollarName '$sha1')}]
              redirects: [
                (redir
                  op: <Id.Redir_DGreat '>>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ ($ Id.VSub_DollarName '$state_dir')) <'/current-commit'>}
                )
              ]
              do_fork: T
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:new_parents)
                  op: assign_op.Equal
                  rhs: (word.Empty)
                  spids: [1857]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:pend)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ <' '> 
                        (command_sub
                          left_token: <Id.Left_DollarParen '$('>
                          child: 
                            (command.Pipeline
                              children: [
                                (C {<git>} {<rev-list>} {<--parents>} {<-1>} 
                                  {($ Id.VSub_DollarName '$sha1')}
                                )
                                (C {<cut>} {<-d> (SQ <' '>)} {<-s>} {<-f2->})
                              ]
                              negated: F
                            )
                        )
                      )
                    }
                  spids: [1860]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (C {<test>} {(DQ ($ Id.VSub_DollarName '$pend'))} {<Id.Lit_Equals '='>} 
                          {(DQ <' '>)}
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:pend)
                          op: assign_op.Equal
                          rhs: {(DQ <' root'>)}
                          spids: [1908]
                        )
                      ]
                    )
                  ]
                  spids: [1890 1905]
                )
              ]
            )
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$pend'))} 
                      {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ )} {<Id.Lit_RBracket ']'>}
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:p)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<expr>} {(DQ ($ Id.VSub_DollarName '$pend'))} {<Id.Lit_Colon ':'>} 
                                    {(SQ <' \\([^ ]*\\)'>)}
                                  )
                              )
                            }
                          spids: [1937]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:pend)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name pend>
                                  suffix_op: 
                                    (suffix_op.Unary
                                      tok: <Id.VOp1_Pound '#'>
                                      arg_word: {<' '> ($ Id.VSub_DollarName '$p')}
                                    )
                                )
                              )
                            }
                          spids: [1953]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (C {<test>} {<-f>} 
                                  {(DQ ($ Id.VSub_DollarName '$rewritten')) <'/'> 
                                    ($ Id.VSub_DollarName '$p')
                                  }
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:new_p)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (C {<cat>} 
                                            {(DQ ($ Id.VSub_DollarName '$rewritten')) <'/'> 
                                              ($ Id.VSub_DollarName '$p')
                                            }
                                          )
                                      )
                                    }
                                  spids: [1981]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$new_p'))})
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:new_p)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Id.Left_DollarParen '$('>
                                                child: (C {<git>} {<rev-parse>} {<HEAD>})
                                              )
                                            }
                                          spids: [2020]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [2006 2017]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<test>} {($ Id.VSub_DollarName '$p')} 
                                  {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {($ Id.VSub_DollarName '$new_p')}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:fast_forward)
                                      op: assign_op.Equal
                                      rhs: {<f>}
                                      spids: [2045]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.Case
                              to_match: {(DQ ($ Id.VSub_DollarName '$new_parents'))}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {<Id.Lit_Star '*'> ($ Id.VSub_DollarName '$new_p') 
                                      <Id.Lit_Star '*'>
                                    }
                                  ]
                                  spids: [2058 2061 2064 -1]
                                )
                                (case_arm
                                  pat_list: [{<Id.Lit_Star '*'>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:new_parents)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (DQ ($ Id.VSub_DollarName '$new_parents') <' '> 
                                                ($ Id.VSub_DollarName '$new_p')
                                              )
                                            }
                                          spids: [2074]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [2070 2071 2082 -1]
                                )
                              ]
                            )
                          ]
                          spids: [1965 1978]
                        )
                      ]
                      else_action: [
                        (command.If
                          arms: [
                            (if_arm
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (C {<test>} {<-f>} 
                                      {(DQ ($ Id.VSub_DollarName '$dropped')) <'/'> 
                                        ($ Id.VSub_DollarName '$p')
                                      }
                                    )
                                  ]
                                )
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:fast_forward)
                                      op: assign_op.Equal
                                      rhs: {<f>}
                                      spids: [2107]
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:replacement)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (DQ 
                                            (command_sub
                                              left_token: <Id.Left_DollarParen '$('>
                                              child: 
                                                (C {<cat>} 
                                                  {(DQ ($ Id.VSub_DollarName '$dropped')) <'/'> 
                                                    ($ Id.VSub_DollarName '$p')
                                                  }
                                                )
                                            )
                                          )
                                        }
                                      spids: [2111]
                                    )
                                  ]
                                )
                                (command.AndOr
                                  ops: [Id.Op_DAmp]
                                  children: [
                                    (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$replacement'))})
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:replacement)
                                          op: assign_op.Equal
                                          rhs: {<root>}
                                          spids: [2135]
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:pend)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (DQ <' '> ($ Id.VSub_DollarName '$replacement') 
                                            ($ Id.VSub_DollarName '$pend')
                                          )
                                        }
                                      spids: [2139]
                                    )
                                  ]
                                )
                              ]
                              spids: [2091 2104]
                            )
                          ]
                          else_action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:new_parents)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ ($ Id.VSub_DollarName '$new_parents') <' '> 
                                        ($ Id.VSub_DollarName '$p')
                                      )
                                    }
                                  spids: [2150]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
            )
            (command.Case
              to_match: {($ Id.VSub_DollarName '$fast_forward')}
              arms: [
                (case_arm
                  pat_list: [{<t>}]
                  action: [
                    (C {<output>} {<warn>} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (C {<eval_gettext>} 
                                {
                                  (DQ <'Fast-forward to '> 
                                    (word_part.EscapedLiteral
                                      token: <Id.Lit_EscapedChar '\\$'>
                                    ) <sha1>
                                  )
                                }
                              )
                          )
                        )
                      }
                    )
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<output>} {<git>} {<reset>} {<--hard>} {($ Id.VSub_DollarName '$sha1')})
                        (C {<die>} 
                          {
                            (DQ 
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<eval_gettext>} 
                                    {
                                      (DQ <'Cannot fast-forward to '> 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\$'>
                                        ) <sha1>
                                      )
                                    }
                                  )
                              )
                            )
                          }
                        )
                      ]
                    )
                  ]
                  spids: [2174 2175 2223 -1]
                )
                (case_arm
                  pat_list: [{<f>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:first_parent)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<expr>} {(DQ ($ Id.VSub_DollarName '$new_parents'))} 
                                    {<Id.Lit_Colon ':'>} {(SQ <' \\([^ ]*\\)'>)}
                                  )
                              )
                            }
                          spids: [2230]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_Number '$1'))} 
                                  {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ <-n>)} {<Id.Lit_RBracket ']'>}
                                )
                              ]
                            )
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (command.Simple
                                  words: [
                                    {<output>}
                                    {<git>}
                                    {<checkout>}
                                    {($ Id.VSub_DollarName '$first_parent')}
                                  ]
                                  redirects: [
                                    (redir
                                      op: <Id.Redir_Great '2>'>
                                      loc: (redir_loc.Fd fd:2)
                                      arg: {<'/dev/null'>}
                                    )
                                  ]
                                  do_fork: T
                                )
                                (C {<die>} 
                                  {
                                    (DQ 
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (C {<eval_gettext>} 
                                            {
                                              (DQ <'Cannot move HEAD to '> 
                                                (word_part.EscapedLiteral
                                                  token: <Id.Lit_EscapedChar '\\$'>
                                                ) <first_parent>
                                              )
                                            }
                                          )
                                      )
                                    )
                                  }
                                )
                              ]
                            )
                          ]
                          spids: [2247 2265]
                        )
                      ]
                    )
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_DollarName '$new_parents'))}
                      arms: [
                        (case_arm
                          pat_list: [{(SQ <' '>) <Id.Lit_Star '*'> (SQ <' '>) <Id.Lit_Star '*'>}]
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<test>} {(DQ <a> ($ Id.VSub_Number '$1'))} {<Id.Lit_Equals '='>} 
                                  {<a-n>}
                                )
                                (C {<die>} 
                                  {
                                    (DQ 
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (C {<eval_gettext>} 
                                            {
                                              (DQ <'Refusing to squash a merge: '> 
                                                (word_part.EscapedLiteral
                                                  token: <Id.Lit_EscapedChar '\\$'>
                                                ) <sha1>
                                              )
                                            }
                                          )
                                      )
                                    )
                                  }
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:author_script_content)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (C {<get_author_ident_from_commit>} 
                                            {($ Id.VSub_DollarName '$sha1')}
                                          )
                                      )
                                    }
                                  spids: [2359]
                                )
                              ]
                            )
                            (C {<eval>} {(DQ ($ Id.VSub_DollarName '$author_script_content'))})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:msg_content)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (C {<commit_message>} {($ Id.VSub_DollarName '$sha1')})
                                        )
                                      )
                                    }
                                  spids: [2374]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:new_parents)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (braced_var_sub
                                        token: <Id.VSub_Name new_parents>
                                        suffix_op: 
                                          (suffix_op.Unary
                                            tok: <Id.VOp1_Pound '#'>
                                            arg_word: {<' '> ($ Id.VSub_DollarName '$first_parent')}
                                          )
                                      )
                                    }
                                  spids: [2388]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:merge_args)
                                  op: assign_op.Equal
                                  rhs: {(DQ <'--no-log --no-ff'>)}
                                  spids: [2397]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (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.Simple
                                      words: [
                                        {<printf>}
                                        {(DQ <'%s'> <Id.Lit_BadBackslash '\\'> <n>)}
                                        {(DQ ($ Id.VSub_DollarName '$msg_content'))}
                                      ]
                                      redirects: [
                                        (redir
                                          op: <Id.Redir_Great '>'>
                                          loc: (redir_loc.Fd fd:1)
                                          arg: {(DQ ($ Id.VSub_DollarName '$GIT_DIR')) <'/MERGE_MSG'>}
                                        )
                                      ]
                                      do_fork: T
                                    )
                                    (C {<die_with_patch>} {($ Id.VSub_DollarName '$sha1')} 
                                      {
                                        (DQ 
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            child: 
                                              (C {<eval_gettext>} 
                                                {
                                                  (DQ <'Error redoing merge '> 
                                                    (word_part.EscapedLiteral
                                                      token: <Id.Lit_EscapedChar '\\$'>
                                                    ) <sha1>
                                                  )
                                                }
                                              )
                                          )
                                        )
                                      }
                                    )
                                  ]
                                  spids: [2403 2421]
                                )
                              ]
                            )
                            (command.Simple
                              words: [
                                {<echo>}
                                {
                                  (DQ ($ Id.VSub_DollarName '$sha1') <' '> 
                                    (command_sub
                                      left_token: <Id.Left_DollarParen '$('>
                                      child: (C {<git>} {<rev-parse>} {<HEAD> <Id.Lit_Other '^'> <0>})
                                    )
                                  )
                                }
                              ]
                              redirects: [
                                (redir
                                  op: <Id.Redir_DGreat '>>'>
                                  loc: (redir_loc.Fd fd:1)
                                  arg: {(DQ ($ Id.VSub_DollarName '$rewritten_list'))}
                                )
                              ]
                              do_fork: T
                            )
                          ]
                          spids: [2315 2323 2487 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (C {<output>} {<eval>} {<git>} {<cherry-pick>} 
                                  {
                                    (braced_var_sub
                                      token: <Id.VSub_Name gpg_sign_opt>
                                      suffix_op: 
                                        (suffix_op.Unary
                                          tok: <Id.VTest_ColonPlus ':+'>
                                          arg_word: 
                                            {
                                              (command_sub
                                                left_token: <Id.Left_DollarParen '$('>
                                                child: 
                                                  (C {<git>} {<rev-parse>} {<--sq-quote>} 
                                                    {(DQ ($ Id.VSub_DollarName '$gpg_sign_opt'))}
                                                  )
                                              )
                                            }
                                        )
                                    )
                                  } {(DQ ($ Id.VSub_DollarName '$strategy_args'))} {(DQ ($ Id.VSub_At '$@'))}
                                )
                                (C {<die_with_patch>} {($ Id.VSub_DollarName '$sha1')} 
                                  {
                                    (DQ 
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (C {<eval_gettext>} 
                                            {
                                              (DQ <'Could not pick '> 
                                                (word_part.EscapedLiteral
                                                  token: <Id.Lit_EscapedChar '\\$'>
                                                ) <sha1>
                                              )
                                            }
                                          )
                                      )
                                    )
                                  }
                                )
                              ]
                            )
                          ]
                          spids: [2490 2491 2550 -1]
                        )
                      ]
                    )
                  ]
                  spids: [2226 2227 2556 -1]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: this_nth_commit_message
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:n)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$1')}
                  spids: [2572]
                )
              ]
            )
            (C {<eval_gettext>} 
              {
                (DQ <'This is the commit message #'> 
                  (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'{n}:'>
                )
              }
            )
          ]
        )
    )
    (command.ShFunction
      name: skip_nth_commit_message
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:n)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$1')}
                  spids: [2595]
                )
              ]
            )
            (C {<eval_gettext>} 
              {
                (DQ <'The commit message #'> 
                  (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'{n} will be skipped:'>
                )
              }
            )
          ]
        )
    )
    (command.ShFunction
      name: update_squash_messages
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: (C {<test>} {<-f>} {(DQ ($ Id.VSub_DollarName '$squash_msg'))})
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<mv>} {(DQ ($ Id.VSub_DollarName '$squash_msg'))} 
                          {(DQ ($ Id.VSub_DollarName '$squash_msg')) <.bak>}
                        )
                        (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:count)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (word_part.ArithSub
                                anode: 
                                  (arith_expr.Binary
                                    op_id: Id.Arith_Plus
                                    left: 
                                      {
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.Simple
                                              words: [
                                                {<sed>}
                                                {<-n>}
                                                {<-e>}
                                                {
                                                  (DQ <'1s/^'> ($ Id.VSub_DollarName '$comment_char') 
                                                    <'.*'> <Id.Lit_BadBackslash '\\'> <'([0-9][0-9]*'> <Id.Lit_BadBackslash '\\'> <').*/'> 
                                                    <Id.Lit_BadBackslash '\\'> <'1/p'>
                                                  )
                                                }
                                                {<-e>}
                                                {(DQ <q>)}
                                              ]
                                              redirects: [
                                                (redir
                                                  op: <Id.Redir_Less '<'>
                                                  loc: (redir_loc.Fd fd:0)
                                                  arg: 
                                                    {(DQ ($ Id.VSub_DollarName '$squash_msg')) <.bak>}
                                                )
                                              ]
                                              do_fork: T
                                            )
                                        )
                                      }
                                    right: {<Id.Lit_Digits 1>}
                                  )
                              )
                            }
                          spids: [2648]
                        )
                      ]
                    )
                    (BraceGroup
                      children: [
                        (C {<printf>} {(SQ <'%s\\n'>)} 
                          {
                            (DQ ($ Id.VSub_DollarName '$comment_char') <' '> 
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<eval_ngettext>} 
                                    {
                                      (DQ <'This is a combination of '> 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\$'>
                                        ) <'count commit.'>
                                      )
                                    } 
                                    {
                                      (DQ <'This is a combination of '> 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\$'>
                                        ) <'count commits.'>
                                      )
                                    } {($ Id.VSub_DollarName '$count')}
                                  )
                              )
                            )
                          }
                        )
                        (command.Simple
                          words: [
                            {<sed>}
                            {<-e>}
                            {<1d>}
                            {<-e>}
                            {(SQ <'2,/^./{\n'> <'\t\t\t\t/^$/d\n'> <'\t\t\t}'>)}
                          ]
                          redirects: [
                            (redir
                              op: <Id.Redir_Less '<'>
                              loc: (redir_loc.Fd fd:0)
                              arg: {(DQ ($ Id.VSub_DollarName '$squash_msg')) <.bak>}
                            )
                          ]
                          do_fork: T
                        )
                      ]
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(DQ ($ Id.VSub_DollarName '$squash_msg'))}
                        )
                      ]
                    )
                  ]
                  spids: [2618 2629]
                )
              ]
              else_action: [
                (command.AndOr
                  ops: [Id.Op_DPipe]
                  children: [
                    (command.Simple
                      words: [{<commit_message>} {<HEAD>}]
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(DQ ($ Id.VSub_DollarName '$fixup_msg'))}
                        )
                      ]
                      do_fork: T
                    )
                    (C {<die>} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (C {<gettext>} 
                                {
                                  (DQ <'Cannot write '> 
                                    (word_part.EscapedLiteral
                                      token: <Id.Lit_EscapedChar '\\$'>
                                    ) <fixup_msg>
                                  )
                                }
                              )
                          )
                        )
                      }
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:count)
                      op: assign_op.Equal
                      rhs: {<2>}
                      spids: [2789]
                    )
                  ]
                )
                (BraceGroup
                  children: [
                    (C {<printf>} {(SQ <'%s\\n'>)} 
                      {
                        (DQ ($ Id.VSub_DollarName '$comment_char') <' '> 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: (C {<gettext>} {(DQ <'This is a combination of 2 commits.'>)})
                          )
                        )
                      }
                    )
                    (C {<printf>} {(SQ <'%s\\n'>)} 
                      {
                        (DQ ($ Id.VSub_DollarName '$comment_char') <' '> 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: (C {<gettext>} {(DQ <'This is the 1st commit message:'>)})
                          )
                        )
                      }
                    )
                    (C {<echo>})
                    (C {<cat>} {(DQ ($ Id.VSub_DollarName '$fixup_msg'))})
                  ]
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {(DQ ($ Id.VSub_DollarName '$squash_msg'))}
                    )
                  ]
                )
              ]
            )
            (command.Case
              to_match: {($ Id.VSub_Number '$1')}
              arms: [
                (case_arm
                  pat_list: [{<squash>}]
                  action: [
                    (C {<rm>} {<-f>} {(DQ ($ Id.VSub_DollarName '$fixup_msg'))})
                    (C {<echo>})
                    (C {<printf>} {(SQ <'%s\\n'>)} 
                      {
                        (DQ ($ Id.VSub_DollarName '$comment_char') <' '> 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: (C {<this_nth_commit_message>} {($ Id.VSub_DollarName '$count')})
                          )
                        )
                      }
                    )
                    (C {<echo>})
                    (C {<commit_message>} {($ Id.VSub_Number '$2')})
                  ]
                  spids: [2862 2863 2903 -1]
                )
                (case_arm
                  pat_list: [{<fixup>}]
                  action: [
                    (C {<echo>})
                    (C {<printf>} {(SQ <'%s\\n'>)} 
                      {
                        (DQ ($ Id.VSub_DollarName '$comment_char') <' '> 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: (C {<skip_nth_commit_message>} {($ Id.VSub_DollarName '$count')})
                          )
                        )
                      }
                    )
                    (C {<echo>})
                    (command.Pipeline
                      children: [
                        (C {<commit_message>} {($ Id.VSub_Number '$2')})
                        (C {<git>} {<stripspace>} {<--comment-lines>})
                        (C {<sed>} {<-e>} {(SQ <'s/ /\t/'>)})
                      ]
                      negated: F
                    )
                  ]
                  spids: [2906 2907 2960 -1]
                )
              ]
              redirects: [
                (redir
                  op: <Id.Redir_DGreat '>>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ ($ Id.VSub_DollarName '$squash_msg'))}
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: peek_next_command
      body: 
        (BraceGroup
          children: [
            (command.Pipeline
              children: [
                (command.Simple
                  words: [{<git>} {<stripspace>} {<--strip-comments>}]
                  redirects: [
                    (redir
                      op: <Id.Redir_Less '<'>
                      loc: (redir_loc.Fd fd:0)
                      arg: {(DQ ($ Id.VSub_DollarName '$todo'))}
                    )
                  ]
                  do_fork: T
                )
                (C {<sed>} {<-n>} {<-e>} {(SQ <'s/ .*//p'>)} {<-e>} {<q>})
              ]
              negated: F
            )
          ]
        )
    )
    (command.ShFunction
      name: die_failed_squash
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:sha1)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$1')}
                  spids: [3036]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:rest)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$2')}
                  spids: [3040]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<mv>} {(DQ ($ Id.VSub_DollarName '$squash_msg'))} 
                  {(DQ ($ Id.VSub_DollarName '$msg'))}
                )
                (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
              ]
            )
            (C {<rm>} {<-f>} {(DQ ($ Id.VSub_DollarName '$fixup_msg'))})
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<cp>} {(DQ ($ Id.VSub_DollarName '$msg'))} 
                  {(DQ ($ Id.VSub_DollarName '$GIT_DIR')) <'/MERGE_MSG'>}
                )
                (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
              ]
            )
            (C {<warn>})
            (C {<warn>} 
              {
                (DQ 
                  (command_sub
                    left_token: <Id.Left_DollarParen '$('>
                    child: 
                      (C {<eval_gettext>} 
                        {
                          (DQ <'Could not apply '> 
                            (word_part.EscapedLiteral
                              token: <Id.Lit_EscapedChar '\\$'>
                            ) <'sha1... '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <rest>
                          )
                        }
                      )
                  )
                )
              }
            )
            (C {<die_with_patch>} {($ Id.VSub_DollarName '$sha1')} {(DQ )})
          ]
        )
    )
    (command.ShFunction
      name: flush_rewritten_pending
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<test>} {<-s>} {(DQ ($ Id.VSub_DollarName '$rewritten_pending'))})
                (command.ControlFlow token:<Id.ControlFlow_Return return>)
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:newsha1)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ 
                        (command_sub
                          left_token: <Id.Left_DollarParen '$('>
                          child: (C {<git>} {<rev-parse>} {<HEAD> <Id.Lit_Other '^'> <0>})
                        )
                      )
                    }
                  spids: [3134]
                )
              ]
            )
            (command.Simple
              words: [
                {<sed>}
                {(DQ <'s/'> <Id.Lit_Dollar '$'> <'/ '> ($ Id.VSub_DollarName '$newsha1') <'/'>)}
              ]
              redirects: [
                (redir
                  op: <Id.Redir_Less '<'>
                  loc: (redir_loc.Fd fd:0)
                  arg: {(DQ ($ Id.VSub_DollarName '$rewritten_pending'))}
                )
                (redir
                  op: <Id.Redir_DGreat '>>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ ($ Id.VSub_DollarName '$rewritten_list'))}
                )
              ]
              do_fork: T
            )
            (C {<rm>} {<-f>} {(DQ ($ Id.VSub_DollarName '$rewritten_pending'))})
          ]
        )
    )
    (command.ShFunction
      name: record_in_rewritten
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:oldsha1)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ 
                        (command_sub
                          left_token: <Id.Left_DollarParen '$('>
                          child: (C {<git>} {<rev-parse>} {($ Id.VSub_Number '$1')})
                        )
                      )
                    }
                  spids: [3189]
                )
              ]
            )
            (command.Simple
              words: [{<echo>} {(DQ ($ Id.VSub_DollarName '$oldsha1'))}]
              redirects: [
                (redir
                  op: <Id.Redir_DGreat '>>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ ($ Id.VSub_DollarName '$rewritten_pending'))}
                )
              ]
              do_fork: T
            )
            (command.Case
              to_match: 
                {
                  (DQ 
                    (command_sub
                      left_token: <Id.Left_DollarParen '$('>
                      child: (C {<peek_next_command>})
                    )
                  )
                }
              arms: [
                (case_arm
                  pat_list: [{<squash>} {<s>} {<fixup>} {<f>}]
                  spids: [3226 3233 3236 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [(C {<flush_rewritten_pending>})]
                  spids: [3239 3240 3246 -1]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: do_pick
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:sha1)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$1')}
                  spids: [3262]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:rest)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$2')}
                  spids: [3266]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (C {<test>} 
                          {
                            (DQ 
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: (C {<git>} {<rev-parse>} {<HEAD>})
                              )
                            )
                          } {<Id.Lit_Equals '='>} {(DQ ($ Id.VSub_DollarName '$squash_onto'))}
                        )
                      ]
                    )
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp Id.Op_DAmp Id.Op_DPipe]
                      children: [
                        (C {<git>} {<commit>} {<--allow-empty>} {<--allow-empty-message>} {<--amend>} 
                          {<--no-post-rewrite>} {<-n>} {<-q>} {<-C>} {($ Id.VSub_DollarName '$sha1')}
                        )
                        (C {<pick_one>} {<-n>} {($ Id.VSub_DollarName '$sha1')})
                        (C {<git>} {<commit>} {<--allow-empty>} {<--allow-empty-message>} {<--amend>} 
                          {<--no-post-rewrite>} {<-n>} {<-q>} {<-C>} {($ Id.VSub_DollarName '$sha1')} 
                          {
                            (braced_var_sub
                              token: <Id.VSub_Name gpg_sign_opt>
                              suffix_op: 
                                (suffix_op.Unary
                                  tok: <Id.VTest_ColonPlus ':+'>
                                  arg_word: {(DQ ($ Id.VSub_DollarName '$gpg_sign_opt'))}
                                )
                            )
                          }
                        )
                        (C {<die_with_patch>} {($ Id.VSub_DollarName '$sha1')} 
                          {
                            (DQ 
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<eval_gettext>} 
                                    {
                                      (DQ <'Could not apply '> 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\$'>
                                        ) <'sha1... '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <rest>
                                      )
                                    }
                                  )
                              )
                            )
                          }
                        )
                      ]
                    )
                  ]
                  spids: [3270 3291]
                )
              ]
              else_action: [
                (command.AndOr
                  ops: [Id.Op_DPipe]
                  children: [
                    (C {<pick_one>} {($ Id.VSub_DollarName '$sha1')})
                    (C {<die_with_patch>} {($ Id.VSub_DollarName '$sha1')} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (C {<eval_gettext>} 
                                {
                                  (DQ <'Could not apply '> 
                                    (word_part.EscapedLiteral
                                      token: <Id.Lit_EscapedChar '\\$'>
                                    ) <'sha1... '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <rest>
                                  )
                                }
                              )
                          )
                        )
                      }
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: do_next
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<rm>} {<-f>} {(DQ ($ Id.VSub_DollarName '$msg'))} 
                  {(DQ ($ Id.VSub_DollarName '$author_script'))} {(DQ ($ Id.VSub_DollarName '$amend'))} {(DQ ($ Id.VSub_DollarName '$state_dir')) <'/stopped-sha'>}
                )
                (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
              ]
            )
            (command.Simple
              words: [{<read>} {<-r>} {<command>} {<sha1>} {<rest>}]
              redirects: [
                (redir
                  op: <Id.Redir_Less '<'>
                  loc: (redir_loc.Fd fd:0)
                  arg: {(DQ ($ Id.VSub_DollarName '$todo'))}
                )
              ]
              do_fork: T
            )
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName '$command'))}
              arms: [
                (case_arm
                  pat_list: [
                    {(DQ ($ Id.VSub_DollarName '$comment_char')) <Id.Lit_Star '*'>}
                    {(SQ )}
                    {<noop>}
                    {<drop>}
                    {<d>}
                  ]
                  action: [(C {<mark_action_done>})]
                  spids: [3508 3521 3527 -1]
                )
                (case_arm
                  pat_list: [{(DQ ($ Id.VSub_DollarName '$cr'))}]
                  action: [(C {<mark_action_done>})]
                  spids: [3530 3533 3543 -1]
                )
                (case_arm
                  pat_list: [{<pick>} {<p>}]
                  action: [
                    (C {<comment_for_reflog>} {<pick>})
                    (C {<mark_action_done>})
                    (C {<do_pick>} {($ Id.VSub_DollarName '$sha1')} {(DQ ($ Id.VSub_DollarName '$rest'))})
                    (C {<record_in_rewritten>} {($ Id.VSub_DollarName '$sha1')})
                  ]
                  spids: [3546 3549 3575 -1]
                )
                (case_arm
                  pat_list: [{<reword>} {<r>}]
                  action: [
                    (C {<comment_for_reflog>} {<reword>})
                    (C {<mark_action_done>})
                    (C {<do_pick>} {($ Id.VSub_DollarName '$sha1')} {(DQ ($ Id.VSub_DollarName '$rest'))})
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<git>} {<commit>} {<--amend>} {<--no-post-rewrite>} 
                          {
                            (braced_var_sub
                              token: <Id.VSub_Name gpg_sign_opt>
                              suffix_op: 
                                (suffix_op.Unary
                                  tok: <Id.VTest_ColonPlus ':+'>
                                  arg_word: {(DQ ($ Id.VSub_DollarName '$gpg_sign_opt'))}
                                )
                            )
                          }
                        )
                        (BraceGroup
                          children: [
                            (C {<warn>} 
                              {
                                (DQ 
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (C {<eval_gettext>} 
                                        {
                                          (DQ <'Could not amend commit after successfully picking '> 
                                            (word_part.EscapedLiteral
                                              token: <Id.Lit_EscapedChar '\\$'>
                                            ) <'sha1... '> (word_part.EscapedLiteral token:<Id.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.'>
                                          )
                                        }
                                      )
                                  )
                                )
                              }
                            )
                            (C {<exit_with_patch>} {($ Id.VSub_DollarName '$sha1')} {<1>})
                          ]
                        )
                      ]
                    )
                    (C {<record_in_rewritten>} {($ Id.VSub_DollarName '$sha1')})
                  ]
                  spids: [3578 3581 3659 -1]
                )
                (case_arm
                  pat_list: [{<edit>} {<e>}]
                  action: [
                    (C {<comment_for_reflog>} {<edit>})
                    (C {<mark_action_done>})
                    (C {<do_pick>} {($ Id.VSub_DollarName '$sha1')} {(DQ ($ Id.VSub_DollarName '$rest'))})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:sha1_abbrev)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<git>} {<rev-parse>} {<--short>} {($ Id.VSub_DollarName '$sha1')})
                              )
                            }
                          spids: [3686]
                        )
                      ]
                    )
                    (C {<warn>} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (C {<eval_gettext>} 
                                {
                                  (DQ <'Stopped at '> 
                                    (word_part.EscapedLiteral
                                      token: <Id.Lit_EscapedChar '\\$'>
                                    ) <'sha1_abbrev... '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <rest>
                                  )
                                }
                              )
                          )
                        )
                      }
                    )
                    (C {<exit_with_patch>} {($ Id.VSub_DollarName '$sha1')} {<0>})
                  ]
                  spids: [3662 3665 3722 -1]
                )
                (case_arm
                  pat_list: [{<squash>} {<s>} {<fixup>} {<f>}]
                  action: [
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_DollarName '$command'))}
                      arms: [
                        (case_arm
                          pat_list: [{<squash>} {<s>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:squash_style)
                                  op: assign_op.Equal
                                  rhs: {<squash>}
                                  spids: [3750]
                                )
                              ]
                            )
                          ]
                          spids: [3744 3747 3754 -1]
                        )
                        (case_arm
                          pat_list: [{<fixup>} {<f>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:squash_style)
                                  op: assign_op.Equal
                                  rhs: {<fixup>}
                                  spids: [3763]
                                )
                              ]
                            )
                          ]
                          spids: [3757 3760 3767 -1]
                        )
                      ]
                    )
                    (C {<comment_for_reflog>} {($ Id.VSub_DollarName '$squash_style')})
                    (command.AndOr
                      ops: [Id.Op_DAmp Id.Op_DPipe]
                      children: [
                        (C {<test>} {<-f>} {(DQ ($ Id.VSub_DollarName '$done'))})
                        (C {<has_action>} {(DQ ($ Id.VSub_DollarName '$done'))})
                        (C {<die>} 
                          {
                            (DQ 
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<eval_gettext>} 
                                    {
                                      (DQ <'Cannot \''> 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\$'>
                                        ) <'squash_style\' without a previous commit'>
                                      )
                                    }
                                  )
                              )
                            )
                          }
                        )
                      ]
                    )
                    (C {<mark_action_done>})
                    (C {<update_squash_messages>} {($ Id.VSub_DollarName '$squash_style')} 
                      {($ Id.VSub_DollarName '$sha1')}
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:author_script_content)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: (C {<get_author_ident_from_commit>} {<HEAD>})
                              )
                            }
                          spids: [3824]
                        )
                      ]
                    )
                    (command.Simple
                      words: [{<echo>} {(DQ ($ Id.VSub_DollarName '$author_script_content'))}]
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(DQ ($ Id.VSub_DollarName '$author_script'))}
                        )
                      ]
                      do_fork: T
                    )
                    (C {<eval>} {(DQ ($ Id.VSub_DollarName '$author_script_content'))})
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Pipeline
                                  children: [(C {<pick_one>} {<-n>} {($ Id.VSub_DollarName '$sha1')})]
                                  negated: T
                                )
                              ]
                            )
                          action: [
                            (command.Simple
                              words: [{<git>} {<rev-parse>} {<--verify>} {<HEAD>}]
                              redirects: [
                                (redir
                                  op: <Id.Redir_Great '>'>
                                  loc: (redir_loc.Fd fd:1)
                                  arg: {(DQ ($ Id.VSub_DollarName '$amend'))}
                                )
                              ]
                              do_fork: T
                            )
                            (C {<die_failed_squash>} {($ Id.VSub_DollarName '$sha1')} 
                              {(DQ ($ Id.VSub_DollarName '$rest'))}
                            )
                          ]
                          spids: [3852 3863]
                        )
                      ]
                    )
                    (command.Case
                      to_match: 
                        {
                          (DQ 
                            (command_sub
                              left_token: <Id.Left_DollarParen '$('>
                              child: (C {<peek_next_command>})
                            )
                          )
                        }
                      arms: [
                        (case_arm
                          pat_list: [{<squash>} {<s>} {<fixup>} {<f>}]
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (C {<do_with_author>} {<output>} {<git>} {<commit>} {<--amend>} 
                                  {<--no-verify>} {<-F>} {(DQ ($ Id.VSub_DollarName '$squash_msg'))} 
                                  {
                                    (braced_var_sub
                                      token: <Id.VSub_Name gpg_sign_opt>
                                      suffix_op: 
                                        (suffix_op.Unary
                                          tok: <Id.VTest_ColonPlus ':+'>
                                          arg_word: {(DQ ($ Id.VSub_DollarName '$gpg_sign_opt'))}
                                        )
                                    )
                                  }
                                )
                                (C {<die_failed_squash>} {($ Id.VSub_DollarName '$sha1')} 
                                  {(DQ ($ Id.VSub_DollarName '$rest'))}
                                )
                              ]
                            )
                          ]
                          spids: [3903 3910 3961 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (C {<test>} {<-f>} {(DQ ($ Id.VSub_DollarName '$fixup_msg'))})
                                      ]
                                    )
                                  action: [
                                    (command.AndOr
                                      ops: [Id.Op_DPipe]
                                      children: [
                                        (C {<do_with_author>} {<git>} {<commit>} {<--amend>} 
                                          {<--no-verify>} {<-F>} {(DQ ($ Id.VSub_DollarName '$fixup_msg'))} 
                                          {
                                            (braced_var_sub
                                              token: <Id.VSub_Name gpg_sign_opt>
                                              suffix_op: 
                                                (suffix_op.Unary
                                                  tok: <Id.VTest_ColonPlus ':+'>
                                                  arg_word: 
                                                    {(DQ ($ Id.VSub_DollarName '$gpg_sign_opt'))}
                                                )
                                            )
                                          }
                                        )
                                        (C {<die_failed_squash>} {($ Id.VSub_DollarName '$sha1')} 
                                          {(DQ ($ Id.VSub_DollarName '$rest'))}
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [3972 3983]
                                )
                              ]
                              else_action: [
                                (command.AndOr
                                  ops: [Id.Op_DPipe]
                                  children: [
                                    (C {<cp>} {(DQ ($ Id.VSub_DollarName '$squash_msg'))} 
                                      {(DQ ($ Id.VSub_DollarName '$GIT_DIR')) <'/SQUASH_MSG'>}
                                    )
                                    (command.ControlFlow
                                      token: <Id.ControlFlow_Exit exit>
                                    )
                                  ]
                                )
                                (C {<rm>} {<-f>} {(DQ ($ Id.VSub_DollarName '$GIT_DIR')) <'/MERGE_MSG'>})
                                (command.AndOr
                                  ops: [Id.Op_DPipe]
                                  children: [
                                    (C {<do_with_author>} {<git>} {<commit>} {<--amend>} {<--no-verify>} 
                                      {<-F>} {(DQ ($ Id.VSub_DollarName '$GIT_DIR')) <'/SQUASH_MSG'>} {<-e>} 
                                      {
                                        (braced_var_sub
                                          token: <Id.VSub_Name gpg_sign_opt>
                                          suffix_op: 
                                            (suffix_op.Unary
                                              tok: <Id.VTest_ColonPlus ':+'>
                                              arg_word: {(DQ ($ Id.VSub_DollarName '$gpg_sign_opt'))}
                                            )
                                        )
                                      }
                                    )
                                    (C {<die_failed_squash>} {($ Id.VSub_DollarName '$sha1')} 
                                      {(DQ ($ Id.VSub_DollarName '$rest'))}
                                    )
                                  ]
                                )
                              ]
                            )
                            (C {<rm>} {<-f>} {(DQ ($ Id.VSub_DollarName '$squash_msg'))} 
                              {(DQ ($ Id.VSub_DollarName '$fixup_msg'))}
                            )
                          ]
                          spids: [3964 3965 4110 -1]
                        )
                      ]
                    )
                    (C {<record_in_rewritten>} {($ Id.VSub_DollarName '$sha1')})
                  ]
                  spids: [3725 3732 4121 -1]
                )
                (case_arm
                  pat_list: [{<x>} {(DQ <exec>)}]
                  action: [
                    (command.Simple
                      words: [{<read>} {<-r>} {<command>} {<rest>}]
                      redirects: [
                        (redir
                          op: <Id.Redir_Less '<'>
                          loc: (redir_loc.Fd fd:0)
                          arg: {(DQ ($ Id.VSub_DollarName '$todo'))}
                        )
                      ]
                      do_fork: T
                    )
                    (C {<mark_action_done>})
                    (C {<eval_gettextln>} 
                      {
                        (DQ <'Executing: '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) 
                          <rest>
                        )
                      }
                    )
                    (C 
                      {
                        (DQ 
                          (braced_var_sub
                            token: <Id.VSub_Name SHELL>
                            suffix_op: 
                              (suffix_op.Unary
                                tok: <Id.VTest_ColonHyphen ':-'>
                                arg_word: {<'@SHELL_PATH@'>}
                              )
                          )
                        )
                      } {<-c>} {(DQ ($ Id.VSub_DollarName '$rest'))}
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:status)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_QMark '$?')}
                          spids: [4177]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:dirty)
                          op: assign_op.Equal
                          rhs: {<f>}
                          spids: [4185]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (command.Subshell
                          child: 
                            (command.Simple
                              words: [{<require_clean_work_tree>} {(DQ <rebase>)}]
                              redirects: [
                                (redir
                                  op: <Id.Redir_Great '2>'>
                                  loc: (redir_loc.Fd fd:2)
                                  arg: {<'/dev/null'>}
                                )
                              ]
                              do_fork: T
                            )
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:dirty)
                              op: assign_op.Equal
                              rhs: {<t>}
                              spids: [4202]
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (C {<test>} {(DQ ($ Id.VSub_DollarName '$status'))} {<-ne>} {<0>})
                              ]
                            )
                          action: [
                            (C {<warn>} 
                              {
                                (DQ 
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (C {<eval_gettext>} 
                                        {
                                          (DQ <'Execution failed: '> 
                                            (word_part.EscapedLiteral
                                              token: <Id.Lit_EscapedChar '\\$'>
                                            ) <rest>
                                          )
                                        }
                                      )
                                  )
                                )
                              }
                            )
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (C {<test>} {(DQ ($ Id.VSub_DollarName '$dirty'))} {<Id.Lit_Equals '='>} 
                                  {<f>}
                                )
                                (C {<warn>} 
                                  {
                                    (DQ 
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (C {<gettext>} 
                                            {
                                              (DQ 
                                                <
'and made changes to the index and/or the working tree'
                                                >
                                              )
                                            }
                                          )
                                      )
                                    )
                                  }
                                )
                              ]
                            )
                            (C {<warn>} 
                              {
                                (DQ 
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (C {<gettext>} 
                                        {
                                          (DQ <'You can fix the problem, and then run\n'> <'\n'> 
                                            <'\tgit rebase --continue'>
                                          )
                                        }
                                      )
                                  )
                                )
                              }
                            )
                            (C {<warn>})
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (C {<test>} {($ Id.VSub_DollarName '$status')} {<-eq>} {<127>})
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:status)
                                          op: assign_op.Equal
                                          rhs: {<1>}
                                          spids: [4300]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [4283 4297]
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Exit exit>
                              arg_word: {(DQ ($ Id.VSub_DollarName '$status'))}
                            )
                          ]
                          spids: [4206 4219]
                        )
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (C {<test>} {(DQ ($ Id.VSub_DollarName '$dirty'))} {<Id.Lit_Equals '='>} 
                                  {<t>}
                                )
                              ]
                            )
                          action: [
                            (C {<warn>} 
                              {
                                (DQ 
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (C {<eval_gettext>} 
                                        {
                                          (DQ <'Execution succeeded: '> 
                                            (word_part.EscapedLiteral
                                              token: <Id.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'>
                                          )
                                        }
                                      )
                                  )
                                )
                              }
                            )
                            (C {<warn>})
                            (command.ControlFlow
                              token: <Id.ControlFlow_Exit exit>
                              arg_word: {<1>}
                            )
                          ]
                          spids: [4314 4327]
                        )
                      ]
                    )
                  ]
                  spids: [4124 4129 4365 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (C {<warn>} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (C {<eval_gettext>} 
                                {
                                  (DQ <'Unknown command: '> 
                                    (word_part.EscapedLiteral
                                      token: <Id.Lit_EscapedChar '\\$'>
                                    ) <'command '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'sha1 '> 
                                    (word_part.EscapedLiteral
                                      token: <Id.Lit_EscapedChar '\\$'>
                                    ) <rest>
                                  )
                                }
                              )
                          )
                        )
                      }
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:fixtodo)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (command_sub
                                  left_token: <Id.Left_DollarParen '$('>
                                  child: 
                                    (C {<gettext>} 
                                      {(DQ <'Please fix this using \'git rebase --edit-todo\'.'>)}
                                    )
                                )
                              )
                            }
                          spids: [4391]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Simple
                                  words: [
                                    {<git>}
                                    {<rev-parse>}
                                    {<--verify>}
                                    {<-q>}
                                    {(DQ ($ Id.VSub_DollarName '$sha1'))}
                                  ]
                                  redirects: [
                                    (redir
                                      op: <Id.Redir_Great '>'>
                                      loc: (redir_loc.Fd fd:1)
                                      arg: {<'/dev/null'>}
                                    )
                                  ]
                                  do_fork: T
                                )
                              ]
                            )
                          action: [
                            (C {<die_with_patch>} {($ Id.VSub_DollarName '$sha1')} 
                              {(DQ ($ Id.VSub_DollarName '$fixtodo'))}
                            )
                          ]
                          spids: [4403 4421]
                        )
                      ]
                      else_action: [(C {<die>} {(DQ ($ Id.VSub_DollarName '$fixtodo'))})]
                    )
                  ]
                  spids: [4368 4369 4446 -1]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<test>} {<-s>} {(DQ ($ Id.VSub_DollarName '$todo'))})
                (command.ControlFlow token:<Id.ControlFlow_Return return>)
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp]
              children: [
                (C {<comment_for_reflog>} {<finish>})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:newhead)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: (C {<git>} {<rev-parse>} {<HEAD>})
                          )
                        }
                      spids: [4473]
                    )
                  ]
                )
                (command.Case
                  to_match: {($ Id.VSub_DollarName '$head_name')}
                  arms: [
                    (case_arm
                      pat_list: [{<'refs/'> <Id.Lit_Star '*'>}]
                      action: [
                        (command.AndOr
                          ops: [Id.Op_DAmp Id.Op_DAmp]
                          children: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:message)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ ($ Id.VSub_DollarName '$GIT_REFLOG_ACTION') <': '> 
                                        ($ Id.VSub_DollarName '$head_name') <' onto '> ($ Id.VSub_DollarName '$onto')
                                      )
                                    }
                                  spids: [4497]
                                )
                              ]
                            )
                            (C {<git>} {<update-ref>} {<-m>} {(DQ ($ Id.VSub_DollarName '$message'))} 
                              {($ Id.VSub_DollarName '$head_name')} {($ Id.VSub_DollarName '$newhead')} {($ Id.VSub_DollarName '$orig_head')}
                            )
                            (C {<git>} {<symbolic-ref>} {<-m>} 
                              {
                                (DQ ($ Id.VSub_DollarName '$GIT_REFLOG_ACTION') <': returning to '> 
                                  ($ Id.VSub_DollarName '$head_name')
                                )
                              } {<HEAD>} {($ Id.VSub_DollarName '$head_name')}
                            )
                          ]
                        )
                      ]
                      spids: [4492 4494 4549 -1]
                    )
                  ]
                )
                (BraceGroup
                  children: [
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<test>} {<Id.KW_Bang '!'>} {<-f>} 
                          {(DQ ($ Id.VSub_DollarName '$state_dir')) <'/verbose'>}
                        )
                        (C {<git>} {<diff-tree>} {<--stat>} 
                          {($ Id.VSub_DollarName '$orig_head') <..HEAD>}
                        )
                      ]
                    )
                  ]
                )
                (BraceGroup
                  children: [
                    (command.AndOr
                      ops: [Id.Op_DAmp Id.Op_DPipe]
                      children: [
                        (C {<test>} {<-s>} {(DQ ($ Id.VSub_DollarName '$rewritten_list'))})
                        (command.Simple
                          words: [
                            {<git>}
                            {<notes>}
                            {<copy>}
                            {<--for-rewrite> <Id.Lit_Equals '='> <rebase>}
                          ]
                          redirects: [
                            (redir
                              op: <Id.Redir_Less '<'>
                              loc: (redir_loc.Fd fd:0)
                              arg: {(DQ ($ Id.VSub_DollarName '$rewritten_list'))}
                            )
                          ]
                          do_fork: T
                        )
                        (C {<true>})
                      ]
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:hook)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (DQ 
                            (command_sub
                              left_token: <Id.Left_DollarParen '$('>
                              child: (C {<git>} {<rev-parse>} {<--git-path>} {<'hooks/post-rewrite'>})
                            )
                          )
                        }
                      spids: [4632]
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.If
                  arms: [
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (command.Sentence
                              child: 
                                (command.AndOr
                                  ops: [Id.Op_DAmp]
                                  children: [
                                    (C {<test>} {<-x>} {(DQ ($ Id.VSub_DollarName '$hook'))})
                                    (C {<test>} {<-s>} {(DQ ($ Id.VSub_DollarName '$rewritten_list'))})
                                  ]
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                      action: [
                        (command.Simple
                          words: [{(DQ ($ Id.VSub_DollarName '$hook'))} {<rebase>}]
                          redirects: [
                            (redir
                              op: <Id.Redir_Less '<'>
                              loc: (redir_loc.Fd fd:0)
                              arg: {(DQ ($ Id.VSub_DollarName '$rewritten_list'))}
                            )
                          ]
                          do_fork: T
                        )
                        (C {<true>})
                      ]
                      spids: [4646 4667]
                    )
                  ]
                )
                (C {<warn>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (C {<eval_gettext>} 
                            {
                              (DQ <'Successfully rebased and updated '> 
                                (word_part.EscapedLiteral
                                  token: <Id.Lit_EscapedChar '\\$'>
                                ) <head_name.>
                              )
                            }
                          )
                      )
                    )
                  }
                )
              ]
            )
            (command.ControlFlow token:<Id.ControlFlow_Return return> arg_word:{<1>})
          ]
        )
    )
    (command.ShFunction
      name: do_rest
      body: 
        (BraceGroup
          children: [
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: (condition.Shell commands:[(C {<Id.Lit_Colon ':'>})])
              body: 
                (command.DoGroup
                  children: [
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<do_next>})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Break break>
                        )
                      ]
                    )
                  ]
                )
            )
          ]
        )
    )
    (command.ShFunction
      name: skip_unnecessary_picks
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:fd)
                  op: assign_op.Equal
                  rhs: {<3>}
                  spids: [4762]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DAmp Id.Op_DPipe]
              children: [
                (command.WhileUntil
                  keyword: <Id.KW_While while>
                  cond: (condition.Shell commands:[(C {<read>} {<-r>} {<command>} {<rest>})])
                  body: 
                    (command.DoGroup
                      children: [
                        (command.Case
                          to_match: 
                            {
                              (DQ ($ Id.VSub_DollarName '$fd') <','> ($ Id.VSub_DollarName '$command'))
                            }
                          arms: [
                            (case_arm
                              pat_list: [{<3> <Id.Lit_Comma ','> <pick>} {<3> <Id.Lit_Comma ','> <p>}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:sha1)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (braced_var_sub
                                            token: <Id.VSub_Name rest>
                                            suffix_op: 
                                              (suffix_op.Unary
                                                tok: <Id.VOp1_DPercent '%%'>
                                                arg_word: {<' '> <Id.Lit_Other '*'>}
                                              )
                                          )
                                        }
                                      spids: [4809]
                                    )
                                  ]
                                )
                                (command.Case
                                  to_match: 
                                    {
                                      (DQ 
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (C {<git>} {<rev-parse>} {<--verify>} {<--quiet>} 
                                              {(DQ ($ Id.VSub_DollarName '$sha1')) <Id.Lit_Other '^'>}
                                            )
                                        )
                                      )
                                    }
                                  arms: [
                                    (case_arm
                                      pat_list: [
                                        {(DQ ($ Id.VSub_DollarName '$onto')) <Id.Lit_Star '*'>}
                                      ]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:onto)
                                              op: assign_op.Equal
                                              rhs: {($ Id.VSub_DollarName '$sha1')}
                                              spids: [4847]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [4840 4844 4851 -1]
                                    )
                                    (case_arm
                                      pat_list: [{<Id.Lit_Star '*'>}]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:fd)
                                              op: assign_op.Equal
                                              rhs: {<1>}
                                              spids: [4858]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [4854 4855 4862 -1]
                                    )
                                  ]
                                )
                              ]
                              spids: [4795 4802 4868 -1]
                            )
                            (case_arm
                              pat_list: [
                                {<3> <Id.Lit_Comma ','> (DQ ($ Id.VSub_DollarName '$comment_char')) 
                                  <Id.Lit_Star '*'>
                                }
                                {<3> <Id.Lit_Comma ','>}
                              ]
                              spids: [4871 4880 4887 -1]
                            )
                            (case_arm
                              pat_list: [{<Id.Lit_Star '*'>}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:fd)
                                      op: assign_op.Equal
                                      rhs: {<1>}
                                      spids: [4894]
                                    )
                                  ]
                                )
                              ]
                              spids: [4890 4891 4898 -1]
                            )
                          ]
                        )
                        (command.Simple
                          words: [
                            {<printf>}
                            {(SQ <'%s\\n'>)}
                            {
                              (DQ ($ Id.VSub_DollarName '$command') 
                                (braced_var_sub
                                  token: <Id.VSub_Name rest>
                                  suffix_op: 
                                    (suffix_op.Unary
                                      tok: <Id.VTest_ColonPlus ':+'>
                                      arg_word: {<' '>}
                                    )
                                ) ($ Id.VSub_DollarName '$rest')
                              )
                            }
                          ]
                          redirects: [
                            (redir
                              op: <Id.Redir_GreatAnd '>&'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {($ Id.VSub_DollarName '$fd')}
                            )
                          ]
                          do_fork: T
                        )
                      ]
                    )
                  redirects: [
                    (redir
                      op: <Id.Redir_Less '<'>
                      loc: (redir_loc.Fd fd:0)
                      arg: {(DQ ($ Id.VSub_DollarName '$todo'))}
                    )
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {(DQ ($ Id.VSub_DollarName '$todo') <.new>)}
                    )
                    (redir
                      op: <Id.Redir_DGreat '3>>'>
                      loc: (redir_loc.Fd fd:3)
                      arg: {(DQ ($ Id.VSub_DollarName '$done'))}
                    )
                  ]
                )
                (C {<mv>} {<-f>} {(DQ ($ Id.VSub_DollarName '$todo')) <.new>} 
                  {(DQ ($ Id.VSub_DollarName '$todo'))}
                )
                (command.Case
                  to_match: 
                    {
                      (DQ 
                        (command_sub
                          left_token: <Id.Left_DollarParen '$('>
                          child: (C {<peek_next_command>})
                        )
                      )
                    }
                  arms: [
                    (case_arm
                      pat_list: [{<squash>} {<s>} {<fixup>} {<f>}]
                      action: [(C {<record_in_rewritten>} {(DQ ($ Id.VSub_DollarName '$onto'))})]
                      spids: [4972 4979 4989 -1]
                    )
                  ]
                )
                (C {<die>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<gettext>} {(DQ <'Could not skip unnecessary pick commands'>)})
                      )
                    )
                  }
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: transform_todo_ids
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.WhileUntil
                  keyword: <Id.KW_While while>
                  cond: (condition.Shell commands:[(C {<read>} {<-r>} {<command>} {<rest>})])
                  body: 
                    (command.DoGroup
                      children: [
                        (command.Case
                          to_match: {(DQ ($ Id.VSub_DollarName '$command'))}
                          arms: [
                            (case_arm
                              pat_list: [
                                {(DQ ($ Id.VSub_DollarName '$comment_char')) <Id.Lit_Star '*'>}
                                {<exec>}
                              ]
                              spids: [5043 5051 5062 -1]
                            )
                            (case_arm
                              pat_list: [{<Id.Lit_Star '*'>}]
                              action: [
                                (command.AndOr
                                  ops: [Id.Op_DAmp]
                                  children: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:sha1)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Id.Left_DollarParen '$('>
                                                child: 
                                                  (C {<git>} {<rev-parse>} {<--verify>} {<--quiet>} 
                                                    {(DQ ($ Id.VSub_At '$@'))} 
                                                    {
                                                      (braced_var_sub
                                                        token: <Id.VSub_Name rest>
                                                        suffix_op: 
                                                          (suffix_op.Unary
                                                            tok: <Id.VOp1_DPercent '%%'>
                                                            arg_word: {<'[\t ]'> <Id.Lit_Other '*'>}
                                                          )
                                                      )
                                                    }
                                                  )
                                              )
                                            }
                                          spids: [5069]
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:rest)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (DQ ($ Id.VSub_DollarName '$sha1') <' '> 
                                                (braced_var_sub
                                                  token: <Id.VSub_Name rest>
                                                  suffix_op: 
                                                    (suffix_op.Unary
                                                      tok: <Id.VOp1_Pound '#'>
                                                      arg_word: {<Id.Lit_Other '*'> <'[\t ]'>}
                                                    )
                                                )
                                              )
                                            }
                                          spids: [5094]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                              spids: [5065 5066 5107 -1]
                            )
                          ]
                        )
                        (C {<printf>} {(SQ <'%s\\n'>)} 
                          {
                            (DQ ($ Id.VSub_DollarName '$command') 
                              (braced_var_sub
                                token: <Id.VSub_Name rest>
                                suffix_op: 
                                  (suffix_op.Unary
                                    tok: <Id.VTest_ColonPlus ':+'>
                                    arg_word: {<' '>}
                                  )
                              ) ($ Id.VSub_DollarName '$rest')
                            )
                          }
                        )
                      ]
                    )
                  redirects: [
                    (redir
                      op: <Id.Redir_Less '<'>
                      loc: (redir_loc.Fd fd:0)
                      arg: {(DQ ($ Id.VSub_DollarName '$todo'))}
                    )
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {(DQ ($ Id.VSub_DollarName '$todo') <.new>)}
                    )
                  ]
                )
                (C {<mv>} {<-f>} {(DQ ($ Id.VSub_DollarName '$todo') <.new>)} 
                  {(DQ ($ Id.VSub_DollarName '$todo'))}
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: expand_todo_ids
      body: (BraceGroup children:[(C {<transform_todo_ids>})])
    )
    (command.ShFunction
      name: collapse_todo_ids
      body: (BraceGroup children:[(C {<transform_todo_ids>} {<--short>})])
    )
    (command.ShFunction
      name: rearrange_squash
      body: 
        (BraceGroup
          children: [
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: (condition.Shell commands:[(C {<read>} {<-r>} {<pick>} {<sha1>} {<message>})])
              body: 
                (command.DoGroup
                  children: [
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<test>} {<-z>} {(DQ (${ Id.VSub_Name format))})
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:message)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (C {<git>} {<log>} {<-n>} {<1>} 
                                        {<--format> <Id.Lit_Equals '='> (DQ <'%s'>)} {(${ Id.VSub_Name sha1)}
                                      )
                                  )
                                }
                              spids: [5252]
                            )
                          ]
                        )
                      ]
                    )
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_DollarName '$message'))}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(DQ <'squash! '>) <Id.Lit_Star '*'>}
                            {(DQ <'fixup! '>) <Id.Lit_Star '*'>}
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:action)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (braced_var_sub
                                          token: <Id.VSub_Name message>
                                          suffix_op: 
                                            (suffix_op.Unary
                                              tok: <Id.VOp1_DPercent '%%'>
                                              arg_word: {<Id.Lit_Other '!'> <Id.Lit_Other '*'>}
                                            )
                                        )
                                      )
                                    }
                                  spids: [5295]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:rest)
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_DollarName '$message')}
                                  spids: [5306]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:prefix)
                                  op: assign_op.Equal
                                  rhs: (word.Empty)
                                  spids: [5310]
                                )
                              ]
                            )
                            (command.WhileUntil
                              keyword: <Id.KW_While while>
                              cond: (condition.Shell commands:[(C {<Id.Lit_Colon ':'>})])
                              body: 
                                (command.DoGroup
                                  children: [
                                    (command.Case
                                      to_match: {(DQ ($ Id.VSub_DollarName '$rest'))}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(DQ <'squash! '>) <Id.Lit_Star '*'>}
                                            {(DQ <'fixup! '>) <Id.Lit_Star '*'>}
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:prefix)
                                                  op: assign_op.Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ Id.VSub_DollarName '$prefix') 
                                                        (braced_var_sub
                                                          token: <Id.VSub_Name rest>
                                                          suffix_op: 
                                                            (suffix_op.Unary
                                                              tok: <Id.VOp1_DPercent '%%'>
                                                              arg_word: 
                                                                {<Id.Lit_Other '!'> 
                                                                  <Id.Lit_Other '*'>
                                                                }
                                                            )
                                                        ) <','>
                                                      )
                                                    }
                                                  spids: [5346]
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:rest)
                                                  op: assign_op.Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (braced_var_sub
                                                          token: <Id.VSub_Name rest>
                                                          suffix_op: 
                                                            (suffix_op.Unary
                                                              tok: <Id.VOp1_Pound '#'>
                                                              arg_word: 
                                                                {<Id.Lit_Other '*'> 
                                                                  <Id.Lit_Other '!'> <' '>
                                                                }
                                                            )
                                                        )
                                                      )
                                                    }
                                                  spids: [5359]
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [5334 5343 5371 -1]
                                        )
                                        (case_arm
                                          pat_list: [{<Id.Lit_Star '*'>}]
                                          action: [
                                            (command.ControlFlow
                                              token: <Id.ControlFlow_Break break>
                                            )
                                          ]
                                          spids: [5374 5375 5381 -1]
                                        )
                                      ]
                                    )
                                  ]
                                )
                            )
                            (C {<printf>} {(SQ <'%s %s %s %s\\n'>)} {(DQ ($ Id.VSub_DollarName '$sha1'))} 
                              {(DQ ($ Id.VSub_DollarName '$action'))} {(DQ ($ Id.VSub_DollarName '$prefix'))} {(DQ ($ Id.VSub_DollarName '$rest'))}
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<test>} 
                                              {
                                                (DQ 
                                                  (braced_var_sub
                                                    token: <Id.VSub_Name rest>
                                                    suffix_op: 
                                                      (suffix_op.Unary
                                                        tok: <Id.VOp1_Pound '#'>
                                                        arg_word: {<Id.Lit_Other '*'> <' '>}
                                                      )
                                                  )
                                                )
                                              } {<Id.Lit_Equals '='>} {(DQ ($ Id.VSub_DollarName '$rest'))}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:fullsha)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (command_sub
                                                  left_token: <Id.Left_DollarParen '$('>
                                                  child: 
                                                    (command.Simple
                                                      words: [
                                                        {<git>}
                                                        {<rev-parse>}
                                                        {<-q>}
                                                        {<--verify>}
                                                        {(DQ ($ Id.VSub_DollarName '$rest'))}
                                                      ]
                                                      redirects: [
                                                        (redir
                                                          op: <Id.Redir_Great '2>'>
                                                          loc: (redir_loc.Fd fd:2)
                                                          arg: {<'/dev/null'>}
                                                        )
                                                      ]
                                                      do_fork: T
                                                    )
                                                )
                                              )
                                            }
                                          spids: [5448]
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: 
                                            (condition.Shell
                                              commands: [
                                                (command.Sentence
                                                  child: 
                                                    (C {<test>} {<-n>} 
                                                      {(DQ ($ Id.VSub_DollarName '$fullsha'))}
                                                    )
                                                  terminator: <Id.Op_Semi _>
                                                )
                                              ]
                                            )
                                          action: [
                                            (C {<echo>} 
                                              {
                                                (DQ ($ Id.VSub_DollarName '$sha1') <' +'> 
                                                  ($ Id.VSub_DollarName '$action') <' '> ($ Id.VSub_DollarName '$prefix') <' '> ($ Id.VSub_DollarName '$fullsha')
                                                )
                                              }
                                            )
                                          ]
                                          spids: [5469 5480]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [5425 5445]
                                )
                              ]
                            )
                          ]
                          spids: [5283 5292 -1 5510]
                        )
                      ]
                    )
                  ]
                )
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ ($ Id.VSub_Number '$1') <.sq>)}
                )
                (redir
                  op: <Id.Redir_Less '<'>
                  loc: (redir_loc.Fd fd:0)
                  arg: {(DQ ($ Id.VSub_Number '$1'))}
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<test>} {<-s>} {(DQ ($ Id.VSub_Number '$1') <.sq>)})
                (command.ControlFlow token:<Id.ControlFlow_Return return>)
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:used)
                  op: assign_op.Equal
                  rhs: (word.Empty)
                  spids: [5542]
                )
              ]
            )
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: (condition.Shell commands:[(C {<read>} {<-r>} {<pick>} {<sha1>} {<message>})])
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ <' '> ($ Id.VSub_DollarName '$used'))}
                      arms: [
                        (case_arm
                          pat_list: [
                            {<Id.Lit_Star '*'> (DQ <' '> ($ Id.VSub_DollarName '$sha1') <' '>) 
                              <Id.Lit_Star '*'>
                            }
                          ]
                          action: [(command.ControlFlow token:<Id.ControlFlow_Continue continue>)]
                          spids: [5571 5578 5582 -1]
                        )
                      ]
                    )
                    (C {<printf>} {(SQ <'%s\\n'>)} 
                      {
                        (DQ ($ Id.VSub_DollarName '$pick') <' '> ($ Id.VSub_DollarName '$sha1') <' '> 
                          ($ Id.VSub_DollarName '$message')
                        )
                      }
                    )
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<test>} {<-z>} {(DQ (${ Id.VSub_Name format))})
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:message)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (C {<git>} {<log>} {<-n>} {<1>} 
                                        {<--format> <Id.Lit_Equals '='> (DQ <'%s'>)} {(${ Id.VSub_Name sha1)}
                                      )
                                  )
                                }
                              spids: [5615]
                            )
                          ]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:used)
                          op: assign_op.Equal
                          rhs: 
                            {(DQ ($ Id.VSub_DollarName '$used') ($ Id.VSub_DollarName '$sha1') <' '>)}
                          spids: [5637]
                        )
                      ]
                    )
                    (command.WhileUntil
                      keyword: <Id.KW_While while>
                      cond: 
                        (condition.Shell
                          commands: [
                            (C {<read>} {<-r>} {<squash>} {<action>} {<msg_prefix>} {<msg_content>})
                          ]
                        )
                      body: 
                        (command.DoGroup
                          children: [
                            (command.Case
                              to_match: {(DQ <' '> ($ Id.VSub_DollarName '$used'))}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {<Id.Lit_Star '*'> 
                                      (DQ <' '> ($ Id.VSub_DollarName '$squash') <' '>) <Id.Lit_Star '*'>
                                    }
                                  ]
                                  action: [
                                    (command.ControlFlow
                                      token: <Id.ControlFlow_Continue continue>
                                    )
                                  ]
                                  spids: [5673 5680 5684 -1]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:emit)
                                  op: assign_op.Equal
                                  rhs: {<0>}
                                  spids: [5690]
                                )
                              ]
                            )
                            (command.Case
                              to_match: {(DQ ($ Id.VSub_DollarName '$action'))}
                              arms: [
                                (case_arm
                                  pat_list: [{<Id.Lit_Other '+'> <Id.Lit_Star '*'>}]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:action)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (braced_var_sub
                                                  token: <Id.VSub_Name action>
                                                  suffix_op: 
                                                    (suffix_op.Unary
                                                      tok: <Id.VOp1_Pound '#'>
                                                      arg_word: {<Id.Lit_Other '+'>}
                                                    )
                                                )
                                              )
                                            }
                                          spids: [5708]
                                        )
                                      ]
                                    )
                                    (command.Case
                                      to_match: {(DQ ($ Id.VSub_DollarName '$msg_content'))}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$sha1')) <Id.Lit_Star '*'>}
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:emit)
                                                  op: assign_op.Equal
                                                  rhs: {<1>}
                                                  spids: [5736]
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [5730 5734 5738 -1]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [5703 5705 5742 -1]
                                )
                                (case_arm
                                  pat_list: [{<Id.Lit_Star '*'>}]
                                  action: [
                                    (command.Case
                                      to_match: {(DQ ($ Id.VSub_DollarName '$message'))}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ Id.VSub_DollarName '$msg_content')) 
                                              <Id.Lit_Star '*'>
                                            }
                                          ]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:emit)
                                                  op: assign_op.Equal
                                                  rhs: {<1>}
                                                  spids: [5767]
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [5761 5765 5769 -1]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [5745 5746 5773 -1]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (C {<test>} {($ Id.VSub_DollarName '$emit')} 
                                              {<Id.Lit_Equals '='>} {<1>}
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: 
                                            (condition.Shell
                                              commands: [
                                                (C {<test>} {<-n>} {(DQ (${ Id.VSub_Name format))})
                                              ]
                                            )
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:msg_content)
                                                  op: assign_op.Equal
                                                  rhs: 
                                                    {
                                                      (command_sub
                                                        left_token: <Id.Left_DollarParen '$('>
                                                        child: 
                                                          (C {<git>} {<log>} {<-n>} {<1>} 
                                                            {<--format> <Id.Lit_Equals '='> 
                                                              (DQ (${ Id.VSub_Name format))
                                                            } {(${ Id.VSub_Name squash)}
                                                          )
                                                      )
                                                    }
                                                  spids: [5809]
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [5793 5806]
                                        )
                                      ]
                                      else_action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:msg_content)
                                              op: assign_op.Equal
                                              rhs: 
                                                {
                                                  (DQ 
                                                    (command_sub
                                                      left_token: <Id.Left_DollarParen '$('>
                                                      child: 
                                                        (command.Pipeline
                                                          children: [
                                                            (C {<echo>} 
                                                              {
                                                                (DQ 
                                                                  ($ Id.VSub_DollarName '$msg_prefix')
                                                                )
                                                              }
                                                            )
                                                            (C {<sed>} {(DQ <'s/,/! /g'>)})
                                                          ]
                                                          negated: F
                                                        )
                                                    ) ($ Id.VSub_DollarName '$msg_content')
                                                  )
                                                }
                                              spids: [5836]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (C {<printf>} {(SQ <'%s\\n'>)} 
                                      {
                                        (DQ ($ Id.VSub_DollarName '$action') <' '> 
                                          ($ Id.VSub_DollarName '$squash') <' '> ($ Id.VSub_DollarName '$msg_content')
                                        )
                                      }
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:used)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (DQ ($ Id.VSub_DollarName '$used') 
                                                ($ Id.VSub_DollarName '$squash') <' '>
                                              )
                                            }
                                          spids: [5875]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [5779 5790]
                                )
                              ]
                            )
                          ]
                        )
                      redirects: [
                        (redir
                          op: <Id.Redir_Less '<'>
                          loc: (redir_loc.Fd fd:0)
                          arg: {(DQ ($ Id.VSub_Number '$1') <.sq>)}
                        )
                      ]
                    )
                  ]
                )
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ ($ Id.VSub_Number '$1') <.rearranged>)}
                )
                (redir
                  op: <Id.Redir_Less '<'>
                  loc: (redir_loc.Fd fd:0)
                  arg: {(DQ ($ Id.VSub_Number '$1'))}
                )
              ]
            )
            (command.Simple
              words: [{<cat>} {(DQ ($ Id.VSub_Number '$1') <.rearranged>)}]
              redirects: [
                (redir
                  op: <Id.Redir_Great '>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ ($ Id.VSub_Number '$1'))}
                )
              ]
              do_fork: T
            )
            (C {<rm>} {<-f>} {(DQ ($ Id.VSub_Number '$1') <.sq>)} 
              {(DQ ($ Id.VSub_Number '$1') <.rearranged>)}
            )
          ]
        )
    )
    (command.ShFunction
      name: add_exec_commands
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (BraceGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:first)
                          op: assign_op.Equal
                          rhs: {<t>}
                          spids: [5956]
                        )
                      ]
                    )
                    (command.WhileUntil
                      keyword: <Id.KW_While while>
                      cond: (condition.Shell commands:[(C {<read>} {<-r>} {<insn>} {<rest>})])
                      body: 
                        (command.DoGroup
                          children: [
                            (command.Case
                              to_match: {($ Id.VSub_DollarName '$insn')}
                              arms: [
                                (case_arm
                                  pat_list: [{<pick>}]
                                  action: [
                                    (command.AndOr
                                      ops: [Id.Op_DPipe]
                                      children: [
                                        (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$first'))})
                                        (C {<printf>} {(DQ <'%s'>)} {(DQ ($ Id.VSub_DollarName '$cmd'))})
                                      ]
                                    )
                                  ]
                                  spids: [5981 5982 6007 -1]
                                )
                              ]
                            )
                            (C {<printf>} {(DQ <'%s %s'> <Id.Lit_BadBackslash '\\'> <n>)} 
                              {(DQ ($ Id.VSub_DollarName '$insn'))} {(DQ ($ Id.VSub_DollarName '$rest'))}
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:first)
                                  op: assign_op.Equal
                                  rhs: (word.Empty)
                                  spids: [6030]
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (C {<printf>} {(DQ <'%s'>)} {(DQ ($ Id.VSub_DollarName '$cmd'))})
                  ]
                  redirects: [
                    (redir
                      op: <Id.Redir_Less '<'>
                      loc: (redir_loc.Fd fd:0)
                      arg: {(DQ ($ Id.VSub_Number '$1'))}
                    )
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {(DQ ($ Id.VSub_Number '$1') <.new>)}
                    )
                  ]
                )
                (C {<mv>} {(DQ ($ Id.VSub_Number '$1') <.new>)} {(DQ ($ Id.VSub_Number '$1'))})
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: check_commit_sha
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:badsha)
                  op: assign_op.Equal
                  rhs: {<0>}
                  spids: [6100]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [(C {<test>} {<-z>} {(DQ ($ Id.VSub_Number '$1'))})]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:badsha)
                          op: assign_op.Equal
                          rhs: {<1>}
                          spids: [6118]
                        )
                      ]
                    )
                  ]
                  spids: [6104 6115]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:sha1_verif)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (DQ 
                            (command_sub
                              left_token: <Id.Left_DollarParen '$('>
                              child: 
                                (C {<git>} {<rev-parse>} {<--verify>} {<--quiet>} 
                                  {($ Id.VSub_Number '$1') <Id.Lit_Other '^'> <Id.Lit_LBrace '{'> 
                                    <commit> <Id.Lit_RBrace '}'>
                                  }
                                )
                            )
                          )
                        }
                      spids: [6125]
                    )
                  ]
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [(C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$sha1_verif'))})]
                        )
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:badsha)
                              op: assign_op.Equal
                              rhs: {<1>}
                              spids: [6159]
                            )
                          ]
                        )
                      ]
                      spids: [6145 6156]
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [(C {<test>} {($ Id.VSub_DollarName '$badsha')} {<-ne>} {<0>})]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:line)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (command_sub
                                  left_token: <Id.Left_DollarParen '$('>
                                  child: 
                                    (C {<sed>} {<-n>} {<-e>} {(DQ (${ Id.VSub_Number 2) <p>)} 
                                      {(DQ ($ Id.VSub_Number '$3'))}
                                    )
                                )
                              )
                            }
                          spids: [6184]
                        )
                      ]
                    )
                    (C {<warn>} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (C {<eval_gettext>} 
                                {
                                  (DQ 
                                    <
'Warning: the SHA-1 is missing or isn\'t a commit in the following line:\n'
                                    > <' - '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <line>
                                  )
                                }
                              )
                          )
                        )
                      }
                    )
                    (C {<warn>})
                  ]
                  spids: [6170 6181]
                )
              ]
            )
            (command.ControlFlow
              token: <Id.ControlFlow_Return return>
              arg_word: {($ Id.VSub_DollarName '$badsha')}
            )
          ]
        )
    )
    (command.ShFunction
      name: check_bad_cmd_and_sha
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:retval)
                  op: assign_op.Equal
                  rhs: {<0>}
                  spids: [6252]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:lineno)
                  op: assign_op.Equal
                  rhs: {<0>}
                  spids: [6256]
                )
              ]
            )
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: (condition.Shell commands:[(C {<read>} {<-r>} {<command>} {<rest>})])
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:lineno)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (word_part.ArithSub
                                anode: 
                                  (arith_expr.Binary
                                    op_id: Id.Arith_Plus
                                    left: {($ Id.VSub_DollarName '$lineno')}
                                    right: {<Id.Lit_Digits 1>}
                                  )
                              )
                            }
                          spids: [6274]
                        )
                      ]
                    )
                    (command.Case
                      to_match: {($ Id.VSub_DollarName '$command')}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(DQ ($ Id.VSub_DollarName '$comment_char')) <Id.Lit_Star '*'>}
                            {(SQ )}
                            {<noop>}
                            {<x>}
                            {<exec>}
                          ]
                          spids: [6294 6307 6314 -1]
                        )
                        (case_arm
                          pat_list: [{(DQ ($ Id.VSub_DollarName '$cr'))}]
                          spids: [6317 6320 6331 -1]
                        )
                        (case_arm
                          pat_list: [
                            {<pick>}
                            {<p>}
                            {<drop>}
                            {<d>}
                            {<reword>}
                            {<r>}
                            {<edit>}
                            {<e>}
                            {<squash>}
                            {<s>}
                            {<fixup>}
                            {<f>}
                          ]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Pipeline
                                          children: [
                                            (C {<check_commit_sha>} 
                                              {
                                                (DQ 
                                                  (braced_var_sub
                                                    token: <Id.VSub_Name rest>
                                                    suffix_op: 
                                                      (suffix_op.Unary
                                                        tok: <Id.VOp1_DPercent '%%'>
                                                        arg_word: {<'[ \t]'> <Id.Lit_Other '*'>}
                                                      )
                                                  )
                                                )
                                              } {(DQ ($ Id.VSub_DollarName '$lineno'))} {(DQ ($ Id.VSub_Number '$1'))}
                                            )
                                          ]
                                          negated: T
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:retval)
                                          op: assign_op.Equal
                                          rhs: {<1>}
                                          spids: [6387]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [6360 6384]
                                )
                              ]
                            )
                          ]
                          spids: [6334 6357 6394 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:line)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (C {<sed>} {<-n>} {<-e>} {(DQ (${ Id.VSub_Name lineno) <p>)} 
                                              {(DQ ($ Id.VSub_Number '$1'))}
                                            )
                                        )
                                      )
                                    }
                                  spids: [6401]
                                )
                              ]
                            )
                            (C {<warn>} 
                              {
                                (DQ 
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (C {<eval_gettext>} 
                                        {
                                          (DQ 
                                            <
'Warning: the command isn\'t recognized in the following line:\n'
                                            > <' - '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <line>
                                          )
                                        }
                                      )
                                  )
                                )
                              }
                            )
                            (C {<warn>})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:retval)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [6444]
                                )
                              ]
                            )
                          ]
                          spids: [6397 6398 6448 -1]
                        )
                      ]
                    )
                  ]
                )
              redirects: [
                (redir
                  op: <Id.Redir_Less '<'>
                  loc: (redir_loc.Fd fd:0)
                  arg: {(DQ ($ Id.VSub_Number '$1'))}
                )
              ]
            )
            (command.ControlFlow
              token: <Id.ControlFlow_Return return>
              arg_word: {($ Id.VSub_DollarName '$retval')}
            )
          ]
        )
    )
    (command.ShFunction
      name: todo_list_to_sha_list
      body: 
        (BraceGroup
          children: [
            (command.Pipeline
              children: [
                (C {<git>} {<stripspace>} {<--strip-comments>})
                (command.WhileUntil
                  keyword: <Id.KW_While while>
                  cond: 
                    (condition.Shell
                      commands: [(C {<read>} {<-r>} {<command>} {<sha1>} {<rest>})]
                    )
                  body: 
                    (command.DoGroup
                      children: [
                        (command.Case
                          to_match: {($ Id.VSub_DollarName '$command')}
                          arms: [
                            (case_arm
                              pat_list: [
                                {(DQ ($ Id.VSub_DollarName '$comment_char')) <Id.Lit_Star '*'>}
                                {(SQ )}
                                {<noop>}
                                {<x>}
                                {(DQ <exec>)}
                              ]
                              spids: [6515 6530 6533 -1]
                            )
                            (case_arm
                              pat_list: [{<Id.Lit_Star '*'>}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:long_sha)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            child: 
                                              (command.Simple
                                                words: [
                                                  {<git>}
                                                  {<rev-list>}
                                                  {<--no-walk>}
                                                  {(DQ ($ Id.VSub_DollarName '$sha1'))}
                                                ]
                                                redirects: [
                                                  (redir
                                                    op: <Id.Redir_Great '2>'>
                                                    loc: (redir_loc.Fd fd:2)
                                                    arg: {<'/dev/null'>}
                                                  )
                                                ]
                                                do_fork: T
                                              )
                                          )
                                        }
                                      spids: [6540]
                                    )
                                  ]
                                )
                                (C {<printf>} {(DQ <'%s'> <Id.Lit_BadBackslash '\\'> <n>)} 
                                  {(DQ ($ Id.VSub_DollarName '$long_sha'))}
                                )
                              ]
                              spids: [6536 6537 6570 -1]
                            )
                          ]
                        )
                      ]
                    )
                )
              ]
              negated: F
            )
          ]
        )
    )
    (command.ShFunction
      name: warn_lines
      body: 
        (BraceGroup
          children: [
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: (condition.Shell commands:[(C {<read>} {<-r>} {<line>})])
              body: 
                (command.DoGroup
                  children: [(C {<warn>} {(DQ <' - '> ($ Id.VSub_DollarName '$line'))})]
                )
            )
          ]
        )
    )
    (command.ShFunction
      name: checkout_onto
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:GIT_REFLOG_ACTION)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ ($ Id.VSub_DollarName '$GIT_REFLOG_ACTION') <': checkout '> 
                        ($ Id.VSub_DollarName '$onto_name')
                      )
                    }
                  spids: [6628]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<output>} {<git>} {<checkout>} {($ Id.VSub_DollarName '$onto')})
                (C {<die_abort>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<gettext>} {(DQ <'could not detach HEAD'>)})
                      )
                    )
                  }
                )
              ]
            )
            (C {<git>} {<update-ref>} {<ORIG_HEAD>} {($ Id.VSub_DollarName '$orig_head')})
          ]
        )
    )
    (command.ShFunction
      name: get_missing_commit_check_level
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:check_level)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<git>} {<config>} {<--get>} {<rebase.missingCommitsCheck>})
                      )
                    }
                  spids: [6678]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:check_level)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <Id.VSub_Name check_level>
                        suffix_op: 
                          (suffix_op.Unary
                            tok: <Id.VTest_ColonHyphen ':-'>
                            arg_word: {<ignore>}
                          )
                      )
                    }
                  spids: [6690]
                )
              ]
            )
            (command.Pipeline
              children: [
                (C {<printf>} {(SQ <'%s'>)} {(DQ ($ Id.VSub_DollarName '$check_level'))})
                (C {<tr>} {(SQ <A-Z>)} {(SQ <a-z>)})
              ]
              negated: F
            )
          ]
        )
    )
    (command.ShFunction
      name: check_todo_list
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:raise_error)
                  op: assign_op.Equal
                  rhs: {<f>}
                  spids: [6747]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:check_level)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<get_missing_commit_check_level>})
                      )
                    }
                  spids: [6752]
                )
              ]
            )
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName '$check_level'))}
              arms: [
                (case_arm
                  pat_list: [{<warn>} {<error>}]
                  action: [
                    (command.Simple
                      words: [{<todo_list_to_sha_list>}]
                      redirects: [
                        (redir
                          op: <Id.Redir_Less '<'>
                          loc: (redir_loc.Fd fd:0)
                          arg: {(DQ ($ Id.VSub_DollarName '$todo')) <.backup>}
                        )
                        (redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(DQ ($ Id.VSub_DollarName '$todo')) <.oldsha1>}
                        )
                      ]
                      do_fork: T
                    )
                    (command.Simple
                      words: [{<todo_list_to_sha_list>}]
                      redirects: [
                        (redir
                          op: <Id.Redir_Less '<'>
                          loc: (redir_loc.Fd fd:0)
                          arg: {(DQ ($ Id.VSub_DollarName '$todo'))}
                        )
                        (redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(DQ ($ Id.VSub_DollarName '$todo')) <.newsha1>}
                        )
                      ]
                      do_fork: T
                    )
                    (command.Simple
                      words: [{<sort>} {<-u>} {(DQ ($ Id.VSub_DollarName '$todo')) <.oldsha1>}]
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(DQ ($ Id.VSub_DollarName '$todo')) <.oldsha1> <Id.Lit_Other '+'>}
                        )
                      ]
                      do_fork: T
                    )
                    (C {<mv>} {(DQ ($ Id.VSub_DollarName '$todo')) <.oldsha1> <Id.Lit_Other '+'>} 
                      {(DQ ($ Id.VSub_DollarName '$todo')) <.oldsha1>}
                    )
                    (command.Simple
                      words: [{<sort>} {<-u>} {(DQ ($ Id.VSub_DollarName '$todo')) <.newsha1>}]
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(DQ ($ Id.VSub_DollarName '$todo')) <.newsha1> <Id.Lit_Other '+'>}
                        )
                      ]
                      do_fork: T
                    )
                    (C {<mv>} {(DQ ($ Id.VSub_DollarName '$todo')) <.newsha1> <Id.Lit_Other '+'>} 
                      {(DQ ($ Id.VSub_DollarName '$todo')) <.newsha1>}
                    )
                    (command.Simple
                      words: [
                        {<comm>}
                        {<-2>}
                        {<-3>}
                        {(DQ ($ Id.VSub_DollarName '$todo')) <.oldsha1>}
                        {(DQ ($ Id.VSub_DollarName '$todo')) <.newsha1>}
                      ]
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(DQ ($ Id.VSub_DollarName '$todo')) <.miss>}
                        )
                      ]
                      do_fork: T
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (C {<test>} {<-s>} {(DQ ($ Id.VSub_DollarName '$todo')) <.miss>})
                              ]
                            )
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<test>} {(DQ ($ Id.VSub_DollarName '$check_level'))} 
                                  {<Id.Lit_Equals '='>} {<error>}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:raise_error)
                                      op: assign_op.Equal
                                      rhs: {<t>}
                                      spids: [6929]
                                    )
                                  ]
                                )
                              ]
                            )
                            (C {<warn>} 
                              {
                                (DQ 
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (C {<gettext>} 
                                        {
                                          (DQ 
                                            <
'Warning: some commits may have been dropped accidentally.\n'
                                            > <'Dropped commits (newer to older):'>
                                          )
                                        }
                                      )
                                  )
                                )
                              }
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:opt)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        <
'--no-walk=sorted --format=oneline --abbrev-commit --stdin'
                                        >
                                      )
                                    }
                                  spids: [6954]
                                )
                              ]
                            )
                            (command.Pipeline
                              children: [
                                (command.Simple
                                  words: [{<git>} {<rev-list>} {($ Id.VSub_DollarName '$opt')}]
                                  redirects: [
                                    (redir
                                      op: <Id.Redir_Less '<'>
                                      loc: (redir_loc.Fd fd:0)
                                      arg: {(DQ ($ Id.VSub_DollarName '$todo')) <.miss>}
                                    )
                                  ]
                                  do_fork: T
                                )
                                (C {<warn_lines>})
                              ]
                              negated: F
                            )
                            (C {<warn>} 
                              {
                                (DQ 
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (C {<gettext>} 
                                        {
                                          (DQ <'To avoid this message, use '> 
                                            (word_part.EscapedLiteral
                                              token: <Id.Lit_EscapedChar '\\"'>
                                            ) <drop> (word_part.EscapedLiteral token:<Id.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.'>
                                          )
                                        }
                                      )
                                  )
                                )
                              }
                            )
                            (C {<warn>})
                          ]
                          spids: [6902 6914]
                        )
                      ]
                    )
                  ]
                  spids: [6768 6771 7005 -1]
                )
                (case_arm pat_list:[{<ignore>}] spids:[7008 7009 7012 -1])
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (C {<warn>} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (C {<eval_gettext>} 
                                {
                                  (DQ <'Unrecognized setting '> 
                                    (word_part.EscapedLiteral
                                      token: <Id.Lit_EscapedChar '\\$'>
                                    ) <'check_level for option rebase.missingCommitsCheck. Ignoring.'>
                                  )
                                }
                              )
                          )
                        )
                      }
                    )
                  ]
                  spids: [7015 7016 7034 -1]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Pipeline
                          children: [(C {<check_bad_cmd_and_sha>} {(DQ ($ Id.VSub_DollarName '$todo'))})]
                          negated: T
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:raise_error)
                          op: assign_op.Equal
                          rhs: {<t>}
                          spids: [7055]
                        )
                      ]
                    )
                  ]
                  spids: [7041 7052]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (C {<test>} {($ Id.VSub_DollarName '$raise_error')} {<Id.Lit_Equals '='>} {<t>})
                      ]
                    )
                  action: [
                    (C {<checkout_onto>})
                    (C {<warn>} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (C {<gettext>} 
                                {
                                  (DQ 
                                    <
'You can fix this with \'git rebase --edit-todo\' and then run \'git rebase --continue\'.'
                                    >
                                  )
                                }
                              )
                          )
                        )
                      }
                    )
                    (C {<die>} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (C {<gettext>} 
                                {(DQ <'Or you can abort the rebase with \'git rebase --abort\'.'>)}
                              )
                          )
                        )
                      }
                    )
                  ]
                  spids: [7063 7074]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: git_rebase__interactive
      body: 
        (BraceGroup
          children: [
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName '$action'))}
              arms: [
                (case_arm
                  pat_list: [{<Id.ControlFlow_Continue continue>}]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (C {<git>} {<diff-index>} {<--cached>} {<--quiet>} {<HEAD>} {<-->})
                              ]
                            )
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DPipe Id.Op_DPipe]
                              children: [
                                (C {<test>} {<Id.KW_Bang '!'>} {<-f>} 
                                  {(DQ ($ Id.VSub_DollarName '$GIT_DIR')) <'/CHERRY_PICK_HEAD'>}
                                )
                                (C {<rm>} 
                                  {(DQ ($ Id.VSub_DollarName '$GIT_DIR')) <'/CHERRY_PICK_HEAD'>}
                                )
                                (C {<die>} 
                                  {
                                    (DQ 
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (C {<gettext>} {(DQ <'Could not remove CHERRY_PICK_HEAD'>)})
                                      )
                                    )
                                  }
                                )
                              ]
                            )
                          ]
                          spids: [7179 7194]
                        )
                      ]
                      else_action: [
                        (command.If
                          arms: [
                            (if_arm
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.Pipeline
                                      children: [
                                        (C {<test>} {<-f>} {(DQ ($ Id.VSub_DollarName '$author_script'))})
                                      ]
                                      negated: T
                                    )
                                  ]
                                )
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:gpg_sign_opt_quoted)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (braced_var_sub
                                            token: <Id.VSub_Name gpg_sign_opt>
                                            suffix_op: 
                                              (suffix_op.Unary
                                                tok: <Id.VTest_ColonPlus ':+'>
                                                arg_word: 
                                                  {
                                                    (command_sub
                                                      left_token: <Id.Left_DollarParen '$('>
                                                      child: 
                                                        (C {<git>} {<rev-parse>} {<--sq-quote>} 
                                                          {
                                                            (DQ 
                                                              ($ Id.VSub_DollarName '$gpg_sign_opt')
                                                            )
                                                          }
                                                        )
                                                    )
                                                  }
                                              )
                                          )
                                        }
                                      spids: [7258]
                                    )
                                  ]
                                )
                                (C {<die>} 
                                  {
                                    (DQ 
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (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.EscapedLiteral
                                                  token: <Id.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.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'gpg_sign_opt_quoted\n'> <'\n'> 
                                                <
'In both cases, once you\'re done, continue with:\n'
                                                > <'\n'> <'  git rebase --continue\n'>
                                              )
                                            }
                                          )
                                      )
                                    )
                                  }
                                )
                              ]
                              spids: [7242 7255]
                            )
                          ]
                        )
                        (command.AndOr
                          ops: [Id.Op_DPipe]
                          children: [
                            (C {<.>} {(DQ ($ Id.VSub_DollarName '$author_script'))})
                            (C {<die>} 
                              {
                                (DQ 
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (C {<gettext>} 
                                        {
                                          (DQ 
                                            <
'Error trying to find the author identity to amend commit'
                                            >
                                          )
                                        }
                                      )
                                  )
                                )
                              }
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: 
                                (condition.Shell
                                  commands: [(C {<test>} {<-f>} {(DQ ($ Id.VSub_DollarName '$amend'))})]
                                )
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:current_head)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            child: (C {<git>} {<rev-parse>} {<--verify>} {<HEAD>})
                                          )
                                        }
                                      spids: [7345]
                                    )
                                  ]
                                )
                                (command.AndOr
                                  ops: [Id.Op_DPipe]
                                  children: [
                                    (C {<test>} {(DQ ($ Id.VSub_DollarName '$current_head'))} 
                                      {<Id.Lit_Equals '='>} 
                                      {
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: (C {<cat>} {(DQ ($ Id.VSub_DollarName '$amend'))})
                                        )
                                      }
                                    )
                                    (C {<die>} 
                                      {
                                        (DQ 
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            child: 
                                              (C {<gettext>} 
                                                {
                                                  (DQ 
                                                    <
'You have uncommitted changes in your working tree. Please commit them\n'
                                                    > <'first and then run \'git rebase --continue\' again.'>
                                                  )
                                                }
                                              )
                                          )
                                        )
                                      }
                                    )
                                  ]
                                )
                                (command.AndOr
                                  ops: [Id.Op_DPipe]
                                  children: [
                                    (C {<do_with_author>} {<git>} {<commit>} {<--amend>} {<--no-verify>} 
                                      {<-F>} {(DQ ($ Id.VSub_DollarName '$msg'))} {<-e>} 
                                      {
                                        (braced_var_sub
                                          token: <Id.VSub_Name gpg_sign_opt>
                                          suffix_op: 
                                            (suffix_op.Unary
                                              tok: <Id.VTest_ColonPlus ':+'>
                                              arg_word: {(DQ ($ Id.VSub_DollarName '$gpg_sign_opt'))}
                                            )
                                        )
                                      }
                                    )
                                    (C {<die>} 
                                      {
                                        (DQ 
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            child: 
                                              (C {<gettext>} {(DQ <'Could not commit staged changes.'>)})
                                          )
                                        )
                                      }
                                    )
                                  ]
                                )
                              ]
                              spids: [7331 7342]
                            )
                          ]
                          else_action: [
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (C {<do_with_author>} {<git>} {<commit>} {<--no-verify>} {<-F>} 
                                  {(DQ ($ Id.VSub_DollarName '$msg'))} {<-e>} 
                                  {
                                    (braced_var_sub
                                      token: <Id.VSub_Name gpg_sign_opt>
                                      suffix_op: 
                                        (suffix_op.Unary
                                          tok: <Id.VTest_ColonPlus ':+'>
                                          arg_word: {(DQ ($ Id.VSub_DollarName '$gpg_sign_opt'))}
                                        )
                                    )
                                  }
                                )
                                (C {<die>} 
                                  {
                                    (DQ 
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (C {<gettext>} {(DQ <'Could not commit staged changes.'>)})
                                      )
                                    )
                                  }
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (C {<test>} {<-r>} 
                                  {(DQ ($ Id.VSub_DollarName '$state_dir')) <'/stopped-sha'>}
                                )
                              ]
                            )
                          action: [
                            (C {<record_in_rewritten>} 
                              {
                                (DQ 
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (C {<cat>} 
                                        {(DQ ($ Id.VSub_DollarName '$state_dir')) <'/stopped-sha'>}
                                      )
                                  )
                                )
                              }
                            )
                          ]
                          spids: [7487 7499]
                        )
                      ]
                    )
                    (C {<require_clean_work_tree>} {(DQ <rebase>)})
                    (C {<do_rest>})
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [7171 7172 7535 -1]
                )
                (case_arm
                  pat_list: [{<skip>}]
                  action: [
                    (C {<git>} {<rerere>} {<clear>})
                    (C {<do_rest>})
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [7537 7538 7557 -1]
                )
                (case_arm
                  pat_list: [{<edit-todo>}]
                  action: [
                    (command.Simple
                      words: [{<git>} {<stripspace>} {<--strip-comments>}]
                      redirects: [
                        (redir
                          op: <Id.Redir_Less '<'>
                          loc: (redir_loc.Fd fd:0)
                          arg: {(DQ ($ Id.VSub_DollarName '$todo'))}
                        )
                        (redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(DQ ($ Id.VSub_DollarName '$todo')) <.new>}
                        )
                      ]
                      do_fork: T
                    )
                    (C {<mv>} {<-f>} {(DQ ($ Id.VSub_DollarName '$todo')) <.new>} 
                      {(DQ ($ Id.VSub_DollarName '$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.Simple
                          words: [{<git>} {<stripspace>} {<--comment-lines>}]
                          redirects: [
                            (redir
                              op: <Id.Redir_DGreat '>>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {(DQ ($ Id.VSub_DollarName '$todo'))}
                            )
                          ]
                          do_fork: T
                        )
                      ]
                      negated: F
                    )
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<git_sequence_editor>} {(DQ ($ Id.VSub_DollarName '$todo'))})
                        (C {<die>} 
                          {
                            (DQ 
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: (C {<gettext>} {(DQ <'Could not execute editor'>)})
                              )
                            )
                          }
                        )
                      ]
                    )
                    (C {<expand_todo_ids>})
                    (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
                  ]
                  spids: [7559 7560 7655 -1]
                )
              ]
            )
            (C {<comment_for_reflog>} {<start>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (C {<test>} {<Id.KW_Bang '!'>} {<-z>} {(DQ ($ Id.VSub_DollarName '$switch_to'))})
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:GIT_REFLOG_ACTION)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ ($ Id.VSub_DollarName '$GIT_REFLOG_ACTION') <': checkout '> 
                                ($ Id.VSub_DollarName '$switch_to')
                              )
                            }
                          spids: [7680]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<output>} {<git>} {<checkout>} {(DQ ($ Id.VSub_DollarName '$switch_to'))} 
                          {<-->}
                        )
                        (C {<die>} 
                          {
                            (DQ 
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<eval_gettext>} 
                                    {
                                      (DQ <'Could not checkout '> 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\$'>
                                        ) <switch_to>
                                      )
                                    }
                                  )
                              )
                            )
                          }
                        )
                      ]
                    )
                    (C {<comment_for_reflog>} {<start>})
                  ]
                  spids: [7665 7677]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:orig_head)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: (C {<git>} {<rev-parse>} {<--verify>} {<HEAD>})
                          )
                        }
                      spids: [7726]
                    )
                  ]
                )
                (C {<die>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<gettext>} {(DQ <'No HEAD?'>)})
                      )
                    )
                  }
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<mkdir>} {<-p>} {(DQ ($ Id.VSub_DollarName '$state_dir'))})
                (C {<die>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (C {<eval_gettext>} 
                            {
                              (DQ <'Could not create temporary '> 
                                (word_part.EscapedLiteral
                                  token: <Id.Lit_EscapedChar '\\$'>
                                ) <state_dir>
                              )
                            }
                          )
                      )
                    )
                  }
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.Simple
                  words: [{<Id.Lit_Colon ':'>}]
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {(DQ ($ Id.VSub_DollarName '$state_dir')) <'/interactive'>}
                    )
                  ]
                  do_fork: T
                )
                (C {<die>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<gettext>} {(DQ <'Could not mark as interactive'>)})
                      )
                    )
                  }
                )
              ]
            )
            (C {<write_basic_state>})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (C {<test>} {<t>} {<Id.Lit_Equals '='>} 
                          {(DQ ($ Id.VSub_DollarName '$preserve_merges'))}
                        )
                      ]
                    )
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$rebase_root'))})
                              ]
                            )
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<mkdir>} {(DQ ($ Id.VSub_DollarName '$rewritten'))})
                                (command.ForEach
                                  iter_name: c
                                  iter_words: [
                                    {
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (C {<git>} {<merge-base>} {<--all>} 
                                            {($ Id.VSub_DollarName '$orig_head')} {($ Id.VSub_DollarName '$upstream')}
                                          )
                                      )
                                    }
                                  ]
                                  do_arg_iter: F
                                  body: 
                                    (command.DoGroup
                                      children: [
                                        (command.AndOr
                                          ops: [Id.Op_DPipe]
                                          children: [
                                            (command.Simple
                                              words: [{<echo>} {($ Id.VSub_DollarName '$onto')}]
                                              redirects: [
                                                (redir
                                                  op: <Id.Redir_Great '>'>
                                                  loc: (redir_loc.Fd fd:1)
                                                  arg: 
                                                    {(DQ ($ Id.VSub_DollarName '$rewritten')) <'/'> 
                                                      ($ Id.VSub_DollarName '$c')
                                                    }
                                                )
                                              ]
                                              do_fork: T
                                            )
                                            (C {<die>} 
                                              {
                                                (DQ 
                                                  (command_sub
                                                    left_token: <Id.Left_DollarParen '$('>
                                                    child: 
                                                      (C {<gettext>} 
                                                        {(DQ <'Could not init rewritten commits'>)}
                                                      )
                                                  )
                                                )
                                              }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                )
                              ]
                            )
                          ]
                          spids: [7816 7827]
                        )
                      ]
                      else_action: [
                        (command.AndOr
                          ops: [Id.Op_DAmp Id.Op_DPipe]
                          children: [
                            (C {<mkdir>} {(DQ ($ Id.VSub_DollarName '$rewritten'))})
                            (command.Simple
                              words: [{<echo>} {($ Id.VSub_DollarName '$onto')}]
                              redirects: [
                                (redir
                                  op: <Id.Redir_Great '>'>
                                  loc: (redir_loc.Fd fd:1)
                                  arg: {(DQ ($ Id.VSub_DollarName '$rewritten')) <'/root'>}
                                )
                              ]
                              do_fork: T
                            )
                            (C {<die>} 
                              {
                                (DQ 
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: (C {<gettext>} {(DQ <'Could not init rewritten commits'>)})
                                  )
                                )
                              }
                            )
                          ]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:merges_option)
                          op: assign_op.Equal
                          rhs: (word.Empty)
                          spids: [7946]
                        )
                      ]
                    )
                  ]
                  spids: [7801 7813]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:merges_option)
                      op: assign_op.Equal
                      rhs: {(DQ <'--no-merges --cherry-pick'>)}
                      spids: [7951]
                    )
                  ]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shorthead)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (C {<git>} {<rev-parse>} {<--short>} {($ Id.VSub_DollarName '$orig_head')})
                      )
                    }
                  spids: [7959]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:shortonto)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<git>} {<rev-parse>} {<--short>} {($ Id.VSub_DollarName '$onto')})
                      )
                    }
                  spids: [7970]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [(C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$rebase_root'))})]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:shortupstream)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<git>} {<rev-parse>} {<--short>} 
                                    {($ Id.VSub_DollarName '$upstream')}
                                  )
                              )
                            }
                          spids: [7998]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:revisions)
                          op: assign_op.Equal
                          rhs: 
                            {($ Id.VSub_DollarName '$upstream') <Id.Lit_TDot ...> 
                              ($ Id.VSub_DollarName '$orig_head')
                            }
                          spids: [8010]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:shortrevisions)
                          op: assign_op.Equal
                          rhs: 
                            {($ Id.VSub_DollarName '$shortupstream') <..> 
                              ($ Id.VSub_DollarName '$shorthead')
                            }
                          spids: [8016]
                        )
                      ]
                    )
                  ]
                  spids: [7981 7995]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:revisions)
                      op: assign_op.Equal
                      rhs: 
                        {($ Id.VSub_DollarName '$onto') <Id.Lit_TDot ...> 
                          ($ Id.VSub_DollarName '$orig_head')
                        }
                      spids: [8024]
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:shortrevisions)
                      op: assign_op.Equal
                      rhs: {($ Id.VSub_DollarName '$shorthead')}
                      spids: [8030]
                    )
                  ]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:format)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<git>} {<config>} {<--get>} {<rebase.instructionFormat>})
                      )
                    }
                  spids: [8035]
                )
              ]
            )
            (command.Pipeline
              children: [
                (C {<git>} {<rev-list>} {($ Id.VSub_DollarName '$merges_option')} 
                  {<--format> <Id.Lit_Equals '='> 
                    (DQ <'%m%H '> 
                      (braced_var_sub
                        token: <Id.VSub_Name format>
                        suffix_op: 
                          (suffix_op.Unary
                            tok: <Id.VTest_ColonHyphen ':-'>
                            arg_word: {<Id.Lit_Percent '%'> <s>}
                          )
                      )
                    )
                  } {<--reverse>} {<--left-right>} {<--topo-order>} {($ Id.VSub_DollarName '$revisions')} 
                  {
                    (braced_var_sub
                      token: <Id.VSub_Name restrict_revision>
                      suffix_op: 
                        (suffix_op.Unary
                          tok: <Id.VTest_Plus '+'>
                          arg_word: {<'^'> ($ Id.VSub_DollarName '$restrict_revision')}
                        )
                    )
                  }
                )
                (C {<sed>} {<-n>} {(DQ <'s/^>//p'>)})
                (command.WhileUntil
                  keyword: <Id.KW_While while>
                  cond: (condition.Shell commands:[(C {<read>} {<-r>} {<sha1>} {<rest>})])
                  body: 
                    (command.DoGroup
                      children: [
                        (command.If
                          arms: [
                            (if_arm
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.AndOr
                                      ops: [Id.Op_DAmp Id.Op_DAmp]
                                      children: [
                                        (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$keep_empty'))})
                                        (C {<is_empty_commit>} {($ Id.VSub_DollarName '$sha1')})
                                        (command.Pipeline
                                          children: [
                                            (C {<is_merge_commit>} {($ Id.VSub_DollarName '$sha1')})
                                          ]
                                          negated: T
                                        )
                                      ]
                                    )
                                  ]
                                )
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:comment_out)
                                      op: assign_op.Equal
                                      rhs: {(DQ ($ Id.VSub_DollarName '$comment_char') <' '>)}
                                      spids: [8142]
                                    )
                                  ]
                                )
                              ]
                              spids: [8114 8139]
                            )
                          ]
                          else_action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:comment_out)
                                  op: assign_op.Equal
                                  rhs: (word.Empty)
                                  spids: [8152]
                                )
                              ]
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (C {<test>} {<t>} {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} 
                                      {(DQ ($ Id.VSub_DollarName '$preserve_merges'))}
                                    )
                                  ]
                                )
                              action: [
                                (command.Simple
                                  words: [
                                    {<printf>}
                                    {(SQ <'%s\\n'>)}
                                    {
                                      (DQ (${ Id.VSub_Name comment_out) <'pick '> 
                                        ($ Id.VSub_DollarName '$sha1') <' '> ($ Id.VSub_DollarName '$rest')
                                      )
                                    }
                                  ]
                                  redirects: [
                                    (redir
                                      op: <Id.Redir_DGreat '>>'>
                                      loc: (redir_loc.Fd fd:1)
                                      arg: {(DQ ($ Id.VSub_DollarName '$todo'))}
                                    )
                                  ]
                                  do_fork: T
                                )
                              ]
                              spids: [8159 8173]
                            )
                          ]
                          else_action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$rebase_root'))})
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:preserve)
                                          op: assign_op.Equal
                                          rhs: {<t>}
                                          spids: [8215]
                                        )
                                      ]
                                    )
                                    (command.ForEach
                                      iter_name: p
                                      iter_words: [
                                        {
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            child: 
                                              (command.Pipeline
                                                children: [
                                                  (C {<git>} {<rev-list>} {<--parents>} {<-1>} 
                                                    {($ Id.VSub_DollarName '$sha1')}
                                                  )
                                                  (C {<cut>} {<-d> (SQ <' '>)} {<-s>} {<-f2->})
                                                ]
                                                negated: F
                                              )
                                          )
                                        }
                                      ]
                                      do_arg_iter: F
                                      body: 
                                        (command.DoGroup
                                          children: [
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: 
                                                    (condition.Shell
                                                      commands: [
                                                        (C {<test>} {<-f>} 
                                                          {(DQ ($ Id.VSub_DollarName '$rewritten')) 
                                                            <'/'> ($ Id.VSub_DollarName '$p')
                                                          }
                                                        )
                                                      ]
                                                    )
                                                  action: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:preserve)
                                                          op: assign_op.Equal
                                                          rhs: {<f>}
                                                          spids: [8270]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                  spids: [8254 8267]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                    )
                                  ]
                                  spids: [8201 8212]
                                )
                              ]
                              else_action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:preserve)
                                      op: assign_op.Equal
                                      rhs: {<f>}
                                      spids: [8283]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (C {<test>} {<f>} {<Id.Lit_Equals '='>} 
                                          {(DQ ($ Id.VSub_DollarName '$preserve'))}
                                        )
                                      ]
                                    )
                                  action: [
                                    (C {<touch>} 
                                      {(DQ ($ Id.VSub_DollarName '$rewritten')) <'/'> 
                                        ($ Id.VSub_DollarName '$sha1')
                                      }
                                    )
                                    (command.Simple
                                      words: [
                                        {<printf>}
                                        {(SQ <'%s\\n'>)}
                                        {
                                          (DQ (${ Id.VSub_Name comment_out) <'pick '> 
                                            ($ Id.VSub_DollarName '$sha1') <' '> ($ Id.VSub_DollarName '$rest')
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (redir
                                          op: <Id.Redir_DGreat '>>'>
                                          loc: (redir_loc.Fd fd:1)
                                          arg: {(DQ ($ Id.VSub_DollarName '$todo'))}
                                        )
                                      ]
                                      do_fork: T
                                    )
                                  ]
                                  spids: [8290 8303]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                )
              ]
              negated: F
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (C {<test>} {<t>} {<Id.Lit_Equals '='>} 
                          {(DQ ($ Id.VSub_DollarName '$preserve_merges'))}
                        )
                      ]
                    )
                  action: [
                    (C {<mkdir>} {(DQ ($ Id.VSub_DollarName '$dropped'))})
                    (command.Pipeline
                      children: [
                        (C {<git>} {<rev-list>} {($ Id.VSub_DollarName '$revisions')} {<--left-right>} 
                          {<--cherry-pick>}
                        )
                        (command.Simple
                          words: [{<sed>} {<-n>} {(DQ <'s/^>//p'>)}]
                          redirects: [
                            (redir
                              op: <Id.Redir_Great '>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {(DQ ($ Id.VSub_DollarName '$state_dir')) <'/not-cherry-picks'>}
                            )
                          ]
                          do_fork: T
                        )
                      ]
                      negated: F
                    )
                    (command.Pipeline
                      children: [
                        (C {<git>} {<rev-list>} {($ Id.VSub_DollarName '$revisions')})
                        (command.WhileUntil
                          keyword: <Id.KW_While while>
                          cond: (condition.Shell commands:[(C {<read>} {<rev>})])
                          body: 
                            (command.DoGroup
                              children: [
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: 
                                        (condition.Shell
                                          commands: [
                                            (command.AndOr
                                              ops: [Id.Op_DAmp]
                                              children: [
                                                (C {<test>} {<-f>} 
                                                  {(DQ ($ Id.VSub_DollarName '$rewritten')) <'/'> 
                                                    ($ Id.VSub_DollarName '$rev')
                                                  }
                                                )
                                                (command.Pipeline
                                                  children: [
                                                    (command.Simple
                                                      words: [
                                                        {<sane_grep>}
                                                        {(DQ ($ Id.VSub_DollarName '$rev'))}
                                                        {(DQ ($ Id.VSub_DollarName '$state_dir')) 
                                                          <'/not-cherry-picks'>
                                                        }
                                                      ]
                                                      redirects: [
                                                        (redir
                                                          op: <Id.Redir_Great '>'>
                                                          loc: (redir_loc.Fd fd:1)
                                                          arg: {<'/dev/null'>}
                                                        )
                                                      ]
                                                      do_fork: T
                                                    )
                                                  ]
                                                  negated: T
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      action: [
                                        (command.Pipeline
                                          children: [
                                            (C {<git>} {<rev-list>} {<--parents>} {<-1>} 
                                              {($ Id.VSub_DollarName '$rev')}
                                            )
                                            (command.Simple
                                              words: [{<cut>} {<-d> (SQ <' '>)} {<-s>} {<-f2>}]
                                              redirects: [
                                                (redir
                                                  op: <Id.Redir_Great '>'>
                                                  loc: (redir_loc.Fd fd:1)
                                                  arg: 
                                                    {(DQ ($ Id.VSub_DollarName '$dropped')) <'/'> 
                                                      ($ Id.VSub_DollarName '$rev')
                                                    }
                                                )
                                              ]
                                              do_fork: T
                                            )
                                          ]
                                          negated: F
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:sha1)
                                              op: assign_op.Equal
                                              rhs: 
                                                {
                                                  (command_sub
                                                    left_token: <Id.Left_DollarParen '$('>
                                                    child: 
                                                      (C {<git>} {<rev-list>} {<-1>} 
                                                        {($ Id.VSub_DollarName '$rev')}
                                                      )
                                                  )
                                                }
                                              spids: [8514]
                                            )
                                          ]
                                        )
                                        (command.Sentence
                                          child: 
                                            (command.Simple
                                              words: [
                                                {<sane_grep>}
                                                {<-v>}
                                                {
                                                  (DQ <'^[a-z][a-z]* '> ($ Id.VSub_DollarName '$sha1'))
                                                }
                                              ]
                                              redirects: [
                                                (redir
                                                  op: <Id.Redir_Less '<'>
                                                  loc: (redir_loc.Fd fd:0)
                                                  arg: {(DQ ($ Id.VSub_DollarName '$todo'))}
                                                )
                                                (redir
                                                  op: <Id.Redir_Great '>'>
                                                  loc: (redir_loc.Fd fd:1)
                                                  arg: {(DQ (${ Id.VSub_Name todo) <2>)}
                                                )
                                              ]
                                              do_fork: T
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                        (C {<mv>} {(DQ (${ Id.VSub_Name todo) <2>)} 
                                          {(DQ ($ Id.VSub_DollarName '$todo'))}
                                        )
                                        (C {<rm>} 
                                          {(DQ ($ Id.VSub_DollarName '$rewritten')) <'/'> 
                                            ($ Id.VSub_DollarName '$rev')
                                          }
                                        )
                                      ]
                                      spids: [8431 8463]
                                    )
                                  ]
                                )
                              ]
                            )
                        )
                      ]
                      negated: F
                    )
                  ]
                  spids: [8348 8360]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<test>} {<-s>} {(DQ ($ Id.VSub_DollarName '$todo'))})
                (command.Simple
                  words: [{<echo>} {<noop>}]
                  redirects: [
                    (redir
                      op: <Id.Redir_DGreat '>>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {(DQ ($ Id.VSub_DollarName '$todo'))}
                    )
                  ]
                  do_fork: T
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$autosquash'))})
                (C {<rearrange_squash>} {(DQ ($ Id.VSub_DollarName '$todo'))})
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$cmd'))})
                (C {<add_exec_commands>} {(DQ ($ Id.VSub_DollarName '$todo'))})
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:todocount)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (command.Pipeline
                            children: [
                              (command.Simple
                                words: [{<git>} {<stripspace>} {<--strip-comments>}]
                                redirects: [
                                  (redir
                                    op: <Id.Redir_Less '<'>
                                    loc: (redir_loc.Fd fd:0)
                                    arg: {(DQ ($ Id.VSub_DollarName '$todo'))}
                                  )
                                ]
                                do_fork: T
                              )
                              (C {<wc>} {<-l>})
                            ]
                            negated: F
                          )
                      )
                    }
                  spids: [8635]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:todocount)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <Id.VSub_Name todocount>
                        suffix_op: 
                          (suffix_op.Unary
                            tok: <Id.VOp1_DPound '##'>
                            arg_word: {<Id.Lit_Other '*'> <' '>}
                          )
                      )
                    }
                  spids: [8655]
                )
              ]
            )
            (command.Simple
              words: [{<cat>}]
              redirects: [
                (redir
                  op: <Id.Redir_DGreat '>>'>
                  loc: (redir_loc.Fd fd:1)
                  arg: {(DQ ($ Id.VSub_DollarName '$todo'))}
                )
                (redir
                  op: <Id.Redir_DLess '<<'>
                  loc: (redir_loc.Fd fd:0)
                  arg: 
                    (redir_param.HereDoc
                      here_begin: {<EOF>}
                      here_end_span_id: 8712
                      stdin_parts: [
                        <'\n'>
                        ($ Id.VSub_DollarName '$comment_char')
                        <' '>
                        (command_sub
                          left_token: <Id.Left_DollarParen '$('>
                          child: 
                            (C {<eval_ngettext>} 
                              {
                                (DQ <'Rebase '> 
                                  (word_part.EscapedLiteral
                                    token: <Id.Lit_EscapedChar '\\$'>
                                  ) <'shortrevisions onto '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'shortonto ('> 
                                  (word_part.EscapedLiteral
                                    token: <Id.Lit_EscapedChar '\\$'>
                                  ) <'todocount command)'>
                                )
                              } 
                              {
                                (DQ <'Rebase '> 
                                  (word_part.EscapedLiteral
                                    token: <Id.Lit_EscapedChar '\\$'>
                                  ) <'shortrevisions onto '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'shortonto ('> 
                                  (word_part.EscapedLiteral
                                    token: <Id.Lit_EscapedChar '\\$'>
                                  ) <'todocount commands)'>
                                )
                              } {(DQ ($ Id.VSub_DollarName '$todocount'))}
                            )
                        )
                        <'\n'>
                      ]
                    )
                )
              ]
              do_fork: T
            )
            (C {<append_todo_help>})
            (command.Pipeline
              children: [
                (C {<gettext>} 
                  {
                    (DQ <'\n'> <'However, if you remove everything, the rebase will be aborted.\n'> 
                      <'\n'>
                    )
                  }
                )
                (command.Simple
                  words: [{<git>} {<stripspace>} {<--comment-lines>}]
                  redirects: [
                    (redir
                      op: <Id.Redir_DGreat '>>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {(DQ ($ Id.VSub_DollarName '$todo'))}
                    )
                  ]
                  do_fork: T
                )
              ]
              negated: F
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [(C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$keep_empty'))})]
                    )
                  action: [
                    (command.Simple
                      words: [
                        {<printf>}
                        {(SQ <'%s\\n'>)}
                        {
                          (DQ ($ Id.VSub_DollarName '$comment_char') <' '> 
                            (command_sub
                              left_token: <Id.Left_DollarParen '$('>
                              child: 
                                (C {<gettext>} {(DQ <'Note that empty commits are commented out'>)})
                            )
                          )
                        }
                      ]
                      redirects: [
                        (redir
                          op: <Id.Redir_DGreat '>>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(DQ ($ Id.VSub_DollarName '$todo'))}
                        )
                      ]
                      do_fork: T
                    )
                  ]
                  spids: [8737 8747]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<has_action>} {(DQ ($ Id.VSub_DollarName '$todo'))})
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {<2>}
                )
              ]
            )
            (C {<cp>} {(DQ ($ Id.VSub_DollarName '$todo'))} 
              {(DQ ($ Id.VSub_DollarName '$todo')) <.backup>}
            )
            (C {<collapse_todo_ids>})
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<git_sequence_editor>} {(DQ ($ Id.VSub_DollarName '$todo'))})
                (C {<die_abort>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<gettext>} {(DQ <'Could not execute editor'>)})
                      )
                    )
                  }
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<has_action>} {(DQ ($ Id.VSub_DollarName '$todo'))})
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {<2>}
                )
              ]
            )
            (C {<check_todo_list>})
            (C {<expand_todo_ids>})
            (command.AndOr
              ops: [Id.Op_DPipe Id.Op_DPipe]
              children: [
                (C {<test>} {<-d>} {(DQ ($ Id.VSub_DollarName '$rewritten'))})
                (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$force_rebase'))})
                (C {<skip_unnecessary_picks>})
              ]
            )
            (C {<checkout_onto>})
            (C {<do_rest>})
          ]
        )
    )
    (C {<git_rebase__interactive>})
  ]
)