(CommandList
  children: [
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:todo)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$state_dir")) (/git-rebase-todo)}
          spids: [39]
        )
      ]
      spids: [39]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:done)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$state_dir")) (/done)}
          spids: [55]
        )
      ]
      spids: [55]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:msg)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$state_dir")) (/message)}
          spids: [68]
        )
      ]
      spids: [68]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:squash_msg)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$state_dir")) (/message-squash)}
          spids: [114]
        )
      ]
      spids: [114]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:fixup_msg)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$state_dir")) (/message-fixup)}
          spids: [136]
        )
      ]
      spids: [136]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:rewritten)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$state_dir")) (/rewritten)}
          spids: [161]
        )
      ]
      spids: [161]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:dropped)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$state_dir")) (/dropped)}
          spids: [168]
        )
      ]
      spids: [168]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:end)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$state_dir")) (/end)}
          spids: [175]
        )
      ]
      spids: [175]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:msgnum)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$state_dir")) (/msgnum)}
          spids: [181]
        )
      ]
      spids: [181]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:author_script)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$state_dir")) (/author-script)}
          spids: [197]
        )
      ]
      spids: [197]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:amend)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$state_dir")) (/amend)}
          spids: [222]
        )
      ]
      spids: [222]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:rewritten_list)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$state_dir")) (/rewritten-list)}
          spids: [241]
        )
      ]
      spids: [241]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:rewritten_pending)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$state_dir")) (/rewritten-pending)}
          spids: [247]
        )
      ]
      spids: [247]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:cr)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (C {(printf)} {(DQ (EscapedLiteralPart token:<Lit_EscapedChar "\\0">) (15))})
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [261 268]
              )
            }
          spids: [260]
        )
      ]
      spids: [260]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:strategy_args)
          op: Equal
          rhs: 
            {
              (BracedVarSub
                token: <VSub_Name strategy>
                suffix_op: 
                  (StringUnary
                    op_id: VTest_ColonPlus
                    arg_word: {("--strategy=") ($ VSub_Name "$strategy")}
                  )
                spids: [272 277]
              )
            }
          spids: [271]
        )
      ]
      spids: [271]
    )
    (AndOr
      children: [
        (C {(test)} {(-n)} {(DQ ($ VSub_Name "$strategy_opts"))})
        (C {(eval)} 
          {(SQ <"\n"> <"\tfor strategy_opt in ">) (DQ ($ VSub_Name "$strategy_opts")) 
            (SQ <"\n"> <"\tdo\n"> 
              <
"\t\tstrategy_args=\"$strategy_args -X$(git rev-parse --sq-quote \"${strategy_opt#--}\")\"\n"
              > <"\tdone\n">
            )
          }
        )
      ]
      op_id: Op_DAmp
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:GIT_CHERRY_PICK_HELP)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$resolvemsg"))}
          spids: [306]
        )
      ]
      spids: [306]
    )
    (C {(export)} {(GIT_CHERRY_PICK_HELP)})
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:comment_char)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (Pipeline
                        children: [
                          (SimpleCommand
                            words: [{(git)} {(config)} {(--get)} {(core.commentchar)}]
                            redirects: [
                              (Redir
                                op_id: Redir_Great
                                fd: 2
                                arg_word: {(/dev/null)}
                                spids: [326]
                              )
                            ]
                          )
                          (C {(cut)} {(-c1)})
                        ]
                        negated: False
                      )
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [317 334]
              )
            }
          spids: [316]
        )
      ]
      spids: [316]
    )
    (C {(Lit_Other ":")} 
      {
        (BracedVarSub
          token: <VSub_Name comment_char>
          suffix_op: (StringUnary op_id:VTest_ColonEquals arg_word:{(Lit_Pound "#")})
          spids: [338 342]
        )
      }
    )
    (FuncDef
      name: warn
      body: 
        (BraceGroup
          children: [
            (SimpleCommand
              words: [{(printf)} {(SQ <"%s\\n">)} {(DQ ($ VSub_Star "$*"))}]
              redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[363])]
            )
          ]
          spids: [350]
        )
      spids: [345 349]
    )
    (FuncDef
      name: commit_message
      body: 
        (BraceGroup
          children: [
            (Pipeline
              children: [
                (C {(git)} {(cat-file)} {(commit)} {(DQ ($ VSub_Number "$1"))})
                (C {(sed)} {(DQ ("1,/^") (Lit_Other "$") (/d))})
              ]
              negated: False
            )
          ]
          spids: [377]
        )
      spids: [372 376]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:orig_reflog_action)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$GIT_REFLOG_ACTION"))}
          spids: [403]
        )
      ]
      spids: [403]
    )
    (FuncDef
      name: comment_for_reflog
      body: 
        (BraceGroup
          children: [
            (Case
              to_match: {(DQ ($ VSub_Name "$orig_reflog_action"))}
              arms: [
                (case_arm
                  pat_list: [{(SQ )} {(rebase) (Lit_Other "*")}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:GIT_REFLOG_ACTION)
                          op: Equal
                          rhs: {(DQ ("rebase -i (") ($ VSub_Number "$1") (")"))}
                          spids: [434]
                        )
                      ]
                      spids: [434]
                    )
                    (C {(export)} {(GIT_REFLOG_ACTION)})
                  ]
                  spids: [-1 431 447 -1]
                )
              ]
              spids: [417 423 450]
            )
          ]
          spids: [414]
        )
      spids: [409 413]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:last_count) op:Equal rhs:{(SQ )} spids:[455])]
      spids: [455]
    )
    (FuncDef
      name: mark_action_done
      body: 
        (BraceGroup
          children: [
            (SimpleCommand
              words: [{(sed)} {(-e)} {(1q)}]
              redirects: [
                (Redir
                  op_id: Redir_Less
                  fd: -1
                  arg_word: {(DQ ($ VSub_Name "$todo"))}
                  spids: [471]
                )
                (Redir
                  op_id: Redir_DGreat
                  fd: -1
                  arg_word: {(DQ ($ VSub_Name "$done"))}
                  spids: [477]
                )
              ]
            )
            (SimpleCommand
              words: [{(sed)} {(-e)} {(1d)}]
              redirects: [
                (Redir
                  op_id: Redir_Less
                  fd: -1
                  arg_word: {(DQ ($ VSub_Name "$todo"))}
                  spids: [490]
                )
                (Redir
                  op_id: Redir_DGreat
                  fd: -1
                  arg_word: {(DQ ($ VSub_Name "$todo")) (.new)}
                  spids: [496]
                )
              ]
            )
            (C {(mv)} {(-f)} {(DQ ($ VSub_Name "$todo")) (.new)} {(DQ ($ VSub_Name "$todo"))})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:new_count)
                  op: Equal
                  rhs: 
                    {
                      (ArithSubPart
                        anode: 
                          (ArithWord
                            w: 
                              {
                                (CommandSubPart
                                  command_list: 
                                    (CommandList
                                      children: [
                                        (Pipeline
                                          children: [
                                            (SimpleCommand
                                              words: [{(git)} {(stripspace)} {(--strip-comments)}]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_Less
                                                  fd: -1
                                                  arg_word: {(DQ ($ VSub_Name "$done"))}
                                                  spids: [528]
                                                )
                                              ]
                                            )
                                            (C {(wc)} {(-l)})
                                          ]
                                          negated: False
                                        )
                                      ]
                                    )
                                  left_token: <Left_CommandSub "$(">
                                  spids: [521 538]
                                )
                              }
                          )
                        spids: [519 541]
                      )
                    }
                  spids: [518]
                )
              ]
              spids: [518]
            )
            (SimpleCommand
              words: [{(echo)} {($ VSub_Name "$new_count")}]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {(DQ ($ VSub_Name "$msgnum"))}
                  spids: [548]
                )
              ]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:total)
                  op: Equal
                  rhs: 
                    {
                      (ArithSubPart
                        anode: 
                          (ArithBinary
                            op_id: Arith_Plus
                            left: (ArithWord w:{($ VSub_Name "$new_count")})
                            right: 
                              (ArithWord
                                w: 
                                  {
                                    (CommandSubPart
                                      command_list: 
                                        (CommandList
                                          children: [
                                            (Pipeline
                                              children: [
                                                (SimpleCommand
                                                  words: [{(git)} {(stripspace)} {(--strip-comments)}]
                                                  redirects: [
                                                    (Redir
                                                      op_id: Redir_Less
                                                      fd: -1
                                                      arg_word: {(DQ ($ VSub_Name "$todo"))}
                                                      spids: [567]
                                                    )
                                                  ]
                                                )
                                                (C {(wc)} {(-l)})
                                              ]
                                              negated: False
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub "$(">
                                      spids: [560 577]
                                    )
                                  }
                              )
                          )
                        spids: [555 579]
                      )
                    }
                  spids: [554]
                )
              ]
              spids: [554]
            )
            (SimpleCommand
              words: [{(echo)} {($ VSub_Name "$total")}]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {(DQ ($ VSub_Name "$end"))}
                  spids: [586]
                )
              ]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (C {(test)} {(DQ ($ VSub_Name "$last_count"))} {(KW_Bang "!") (Lit_Other "=")} 
                      {(DQ ($ VSub_Name "$new_count"))}
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:last_count)
                          op: Equal
                          rhs: {($ VSub_Name "$new_count")}
                          spids: [611]
                        )
                      ]
                      spids: [611]
                    )
                    (Sentence
                      child: 
                        (C {(eval_gettext)} 
                          {
                            (DQ ("Rebasing (") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) 
                              (new_count/) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("total)")
                            )
                          }
                        )
                      terminator: <Op_Semi ";">
                    )
                    (C {(printf)} {(DQ (EscapedLiteralPart token:<Lit_EscapedChar "\\r">))})
                    (AndOr
                      children: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$verbose"))}) (C {(echo)})]
                      op_id: Op_DPipe
                    )
                  ]
                  spids: [-1 608]
                )
              ]
              spids: [-1 646]
            )
          ]
          spids: [462]
        )
      spids: [457 461]
    )
    (FuncDef
      name: reschedule_last_action
      body: 
        (BraceGroup
          children: [
            (Pipeline
              children: [
                (C {(tail)} {(-n)} {(1)} {(DQ ($ VSub_Name "$done"))})
                (SimpleCommand
                  words: [{(cat)} {(-)} {(DQ ($ VSub_Name "$todo"))}]
                  redirects: [
                    (Redir
                      op_id: Redir_Great
                      fd: -1
                      arg_word: {(DQ ($ VSub_Name "$todo")) (.new)}
                      spids: [688]
                    )
                  ]
                )
              ]
              negated: False
            )
            (SimpleCommand
              words: [{(sed)} {(-e)} {(EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (d)}]
              redirects: [
                (Redir
                  op_id: Redir_Less
                  fd: -1
                  arg_word: {(DQ ($ VSub_Name "$done"))}
                  spids: [702]
                )
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {(DQ ($ VSub_Name "$done")) (.new)}
                  spids: [707]
                )
              ]
            )
            (C {(mv)} {(-f)} {(DQ ($ VSub_Name "$todo")) (.new)} {(DQ ($ VSub_Name "$todo"))})
            (C {(mv)} {(-f)} {(DQ ($ VSub_Name "$done")) (.new)} {(DQ ($ VSub_Name "$done"))})
          ]
          spids: [665]
        )
      spids: [660 664]
    )
    (FuncDef
      name: append_todo_help
      body: 
        (BraceGroup
          children: [
            (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 ") (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (squash) 
                      (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (", but discard this commit's log message\n") 
                      (" x, exec = run command (the rest of the line) using shell\n") (" d, drop = remove commit\n") ("\n") 
                      ("These lines can be re-ordered; they are executed from top to bottom.\n")
                    )
                  }
                )
                (SimpleCommand
                  words: [{(git)} {(stripspace)} {(--comment-lines)}]
                  redirects: [
                    (Redir
                      op_id: Redir_DGreat
                      fd: -1
                      arg_word: {(DQ ($ VSub_Name "$todo"))}
                      spids: [780]
                    )
                  ]
                )
              ]
              negated: False
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (C {(test)} 
                      {
                        (CommandSubPart
                          command_list: 
                            (CommandList
                              children: [(C {(get_missing_commit_check_level)})]
                            )
                          left_token: <Left_CommandSub "$(">
                          spids: [791 793]
                        )
                      } {(Lit_Other "=")} {(error)}
                    )
                  ]
                  action: [
                    (Pipeline
                      children: [
                        (C {(gettext)} 
                          {
                            (DQ ("\n") 
                              (
"Do not remove any line. Use 'drop' explicitly to remove a commit.\n"
                              )
                            )
                          }
                        )
                        (SimpleCommand
                          words: [{(git)} {(stripspace)} {(--comment-lines)}]
                          redirects: [
                            (Redir
                              op_id: Redir_DGreat
                              fd: -1
                              arg_word: {(DQ ($ VSub_Name "$todo"))}
                              spids: [818]
                            )
                          ]
                        )
                      ]
                      negated: False
                    )
                  ]
                  spids: [-1 800]
                )
              ]
              else_action: [
                (Pipeline
                  children: [
                    (C {(gettext)} 
                      {(DQ ("\n") ("If you remove a line here THAT COMMIT WILL BE LOST.\n"))}
                    )
                    (SimpleCommand
                      words: [{(git)} {(stripspace)} {(--comment-lines)}]
                      redirects: [
                        (Redir
                          op_id: Redir_DGreat
                          fd: -1
                          arg_word: {(DQ ($ VSub_Name "$todo"))}
                          spids: [842]
                        )
                      ]
                    )
                  ]
                  negated: False
                )
              ]
              spids: [824 848]
            )
          ]
          spids: [749]
        )
      spids: [744 748]
    )
    (FuncDef
      name: make_patch
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:sha1_and_parents)
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (CommandSubPart
                          command_list: 
                            (CommandList
                              children: [
                                (C {(git)} {(rev-list)} {(--parents)} {(-1)} {(DQ ($ VSub_Number "$1"))})
                              ]
                            )
                          left_token: <Left_CommandSub "$(">
                          spids: [863 875]
                        )
                      )
                    }
                  spids: [861]
                )
              ]
              spids: [861]
            )
            (Case
              to_match: {(DQ ($ VSub_Name "$sha1_and_parents"))}
              arms: [
                (case_arm
                  pat_list: [
                    {(Lit_Other "?") (Lit_Other "*") (SQ <" ">) (Lit_Other "?") (Lit_Other "*") 
                      (SQ <" ">) (Lit_Other "?") (Lit_Other "*")
                    }
                  ]
                  action: [(C {(git)} {(diff)} {(--cc)} {($ VSub_Name "$sha1_and_parents")})]
                  spids: [888 900 912 -1]
                )
                (case_arm
                  pat_list: [
                    {(Lit_Other "?") (Lit_Other "*") (SQ <" ">) (Lit_Other "?") (Lit_Other "*")}
                  ]
                  action: [(C {(git)} {(diff-tree)} {(-p)} {(DQ ($ VSub_Number "$1") ("^!"))})]
                  spids: [915 922 937 -1]
                )
                (case_arm
                  pat_list: [{(Lit_Other "*")}]
                  action: [(C {(echo)} {(DQ ("Root commit"))})]
                  spids: [940 941 951 -1]
                )
              ]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {(DQ ($ VSub_Name "$state_dir")) (/patch)}
                  spids: [956]
                )
              ]
              spids: [879 885 954]
            )
            (AndOr
              children: [
                (C {(test)} {(-f)} {(DQ ($ VSub_Name "$msg"))})
                (SimpleCommand
                  words: [{(commit_message)} {(DQ ($ VSub_Number "$1"))}]
                  redirects: [
                    (Redir
                      op_id: Redir_Great
                      fd: -1
                      arg_word: {(DQ ($ VSub_Name "$msg"))}
                      spids: [981]
                    )
                  ]
                )
              ]
              op_id: Op_DPipe
            )
            (AndOr
              children: [
                (C {(test)} {(-f)} {(DQ ($ VSub_Name "$author_script"))})
                (SimpleCommand
                  words: [{(get_author_ident_from_commit)} {(DQ ($ VSub_Number "$1"))}]
                  redirects: [
                    (Redir
                      op_id: Redir_Great
                      fd: -1
                      arg_word: {(DQ ($ VSub_Name "$author_script"))}
                      spids: [1005]
                    )
                  ]
                )
              ]
              op_id: Op_DPipe
            )
          ]
          spids: [858]
        )
      spids: [853 857]
    )
    (FuncDef
      name: die_with_patch
      body: 
        (BraceGroup
          children: [
            (SimpleCommand
              words: [{(echo)} {(DQ ($ VSub_Number "$1"))}]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {(DQ ($ VSub_Name "$state_dir")) (/stopped-sha)}
                  spids: [1028]
                )
              ]
            )
            (C {(make_patch)} {(DQ ($ VSub_Number "$1"))})
            (C {(die)} {(DQ ($ VSub_Number "$2"))})
          ]
          spids: [1019]
        )
      spids: [1014 1018]
    )
    (FuncDef
      name: exit_with_patch
      body: 
        (BraceGroup
          children: [
            (SimpleCommand
              words: [{(echo)} {(DQ ($ VSub_Number "$1"))}]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {(DQ ($ VSub_Name "$state_dir")) (/stopped-sha)}
                  spids: [1066]
                )
              ]
            )
            (C {(make_patch)} {($ VSub_Number "$1")})
            (SimpleCommand
              words: [{(git)} {(rev-parse)} {(--verify)} {(HEAD)}]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {(DQ ($ VSub_Name "$amend"))}
                  spids: [1087]
                )
              ]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:gpg_sign_opt_quoted)
                  op: Equal
                  rhs: 
                    {
                      (BracedVarSub
                        token: <VSub_Name gpg_sign_opt>
                        suffix_op: 
                          (StringUnary
                            op_id: VTest_ColonPlus
                            arg_word: 
                              {
                                (CommandSubPart
                                  command_list: 
                                    (CommandList
                                      children: [
                                        (C {(git)} {(rev-parse)} {(--sq-quote)} 
                                          {(DQ ($ VSub_Name "$gpg_sign_opt"))}
                                        )
                                      ]
                                    )
                                  left_token: <Left_CommandSub "$(">
                                  spids: [1098 1108]
                                )
                              }
                          )
                        spids: [1095 1109]
                      )
                    }
                  spids: [1094]
                )
              ]
              spids: [1094]
            )
            (C {(warn)} 
              {
                (DQ 
                  (CommandSubPart
                    command_list: 
                      (CommandList
                        children: [
                          (C {(eval_gettext)} 
                            {
                              (DQ ("You can amend the commit now, with\n") ("\n") 
                                ("\tgit commit --amend ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("gpg_sign_opt_quoted\n") ("\n") 
                                ("Once you are satisfied with your changes, run\n") ("\n") ("\tgit rebase --continue")
                              )
                            }
                          )
                        ]
                      )
                    left_token: <Left_CommandSub "$(">
                    spids: [1115 1130]
                  )
                )
              }
            )
            (C {(warn)})
            (C {(exit)} {($ VSub_Number "$2")})
          ]
          spids: [1057]
        )
      spids: [1052 1056]
    )
    (FuncDef
      name: die_abort
      body: 
        (BraceGroup
          children: [
            (C {(apply_autostash)})
            (C {(rm)} {(-rf)} {(DQ ($ VSub_Name "$state_dir"))})
            (C {(die)} {(DQ ($ VSub_Number "$1"))})
          ]
          spids: [1149]
        )
      spids: [1144 1148]
    )
    (FuncDef
      name: has_action
      body: 
        (BraceGroup
          children: [
            (C {(test)} {(-n)} 
              {
                (DQ 
                  (CommandSubPart
                    command_list: 
                      (CommandList
                        children: [
                          (SimpleCommand
                            words: [{(git)} {(stripspace)} {(--strip-comments)}]
                            redirects: [
                              (Redir
                                op_id: Redir_Less
                                fd: -1
                                arg_word: {(DQ ($ VSub_Number "$1"))}
                                spids: [1193]
                              )
                            ]
                          )
                        ]
                      )
                    left_token: <Left_CommandSub "$(">
                    spids: [1186 1197]
                  )
                )
              }
            )
          ]
          spids: [1178]
        )
      spids: [1173 1177]
    )
    (FuncDef
      name: is_empty_commit
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:tree)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (SimpleCommand
                                    words: [
                                      {(git)}
                                      {(rev-parse)}
                                      {(-q)}
                                      {(--verify)}
                                      {(DQ ($ VSub_Number "$1")) (Lit_Other "^") (Lit_LBrace "{") 
                                        (tree) (Lit_RBrace "}")
                                      }
                                    ]
                                    redirects: [
                                      (Redir
                                        op_id: Redir_Great
                                        fd: 2
                                        arg_word: {(/dev/null)}
                                        spids: [1228]
                                      )
                                    ]
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [1211 1230]
                          )
                        }
                      spids: [1210]
                    )
                  ]
                  spids: [1210]
                )
                (BraceGroup
                  children: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:sha1)
                          op: Equal
                          rhs: {($ VSub_Number "$1")}
                          spids: [1237]
                        )
                      ]
                      spids: [1237]
                    )
                    (C {(die)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) 
                                        ("sha1: not a commit that can be picked")
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [1244 1251]
                          )
                        )
                      }
                    )
                  ]
                  spids: [1234]
                )
              ]
              op_id: Op_DPipe
            )
            (AndOr
              children: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:ptree)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (SimpleCommand
                                    words: [
                                      {(git)}
                                      {(rev-parse)}
                                      {(-q)}
                                      {(--verify)}
                                      {(DQ ($ VSub_Number "$1")) (Lit_Other "^") (Lit_Other "^") 
                                        (Lit_LBrace "{") (tree) (Lit_RBrace "}")
                                      }
                                    ]
                                    redirects: [
                                      (Redir
                                        op_id: Redir_Great
                                        fd: 2
                                        arg_word: {(/dev/null)}
                                        spids: [1277]
                                      )
                                    ]
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [1259 1279]
                          )
                        }
                      spids: [1258]
                    )
                  ]
                  spids: [1258]
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:ptree)
                      op: Equal
                      rhs: {(4b825dc642cb6eb9a060e54bf8d69288fbee4904)}
                      spids: [1284]
                    )
                  ]
                  spids: [1284]
                )
              ]
              op_id: Op_DPipe
            )
            (C {(test)} {(DQ ($ VSub_Name "$tree"))} {(Lit_Other "=")} {(DQ ($ VSub_Name "$ptree"))})
          ]
          spids: [1207]
        )
      spids: [1203 1206]
    )
    (FuncDef
      name: is_merge_commit
      body: 
        (BraceGroup
          children: [
            (SimpleCommand
              words: [
                {(git)}
                {(rev-parse)}
                {(--verify)}
                {(--quiet)}
                {(DQ ($ VSub_Number "$1")) (Lit_Other "^") (2)}
              ]
              redirects: [
                (Redir op_id:Redir_Great fd:-1 arg_word:{(/dev/null)} spids:[1324])
                (Redir op_id:Redir_GreatAnd fd:2 arg_word:{(1)} spids:[1327])
              ]
            )
          ]
          spids: [1307]
        )
      spids: [1303 1306]
    )
    (FuncDef
      name: do_with_author
      body: 
        (BraceGroup
          children: [
            (Subshell
              child: 
                (CommandList
                  children: [
                    (C {(export)} {(GIT_AUTHOR_NAME)} {(GIT_AUTHOR_EMAIL)} {(GIT_AUTHOR_DATE)})
                    (C {(DQ ($ VSub_At "$@"))})
                  ]
                )
              spids: [1347 1364]
            )
          ]
          spids: [1344]
        )
      spids: [1339 1343]
    )
    (FuncDef
      name: git_sequence_editor
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$GIT_SEQUENCE_EDITOR"))})]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:GIT_SEQUENCE_EDITOR)
                          op: Equal
                          rhs: 
                            {
                              (DQ 
                                (CommandSubPart
                                  command_list: 
                                    (CommandList
                                      children: [(C {(git)} {(config)} {(sequence.editor)})]
                                    )
                                  left_token: <Left_CommandSub "$(">
                                  spids: [1393 1399]
                                )
                              )
                            }
                          spids: [1391]
                        )
                      ]
                      spids: [1391]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (C {(Lit_Other "[")} {(-z)} {(DQ ($ VSub_Name "$GIT_SEQUENCE_EDITOR"))} 
                              {(Lit_Other "]")}
                            )
                          ]
                          action: [
                            (AndOr
                              children: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:GIT_SEQUENCE_EDITOR)
                                      op: Equal
                                      rhs: 
                                        {
                                          (DQ 
                                            (CommandSubPart
                                              command_list: 
                                                (CommandList
                                                  children: [(C {(git)} {(var)} {(GIT_EDITOR)})]
                                                )
                                              left_token: <Left_CommandSub "$(">
                                              spids: [1421 1427]
                                            )
                                          )
                                        }
                                      spids: [1419]
                                    )
                                  ]
                                  spids: [1419]
                                )
                                (ControlFlow
                                  token: <ControlFlow_Return return>
                                  arg_word: {($ VSub_QMark "$?")}
                                )
                              ]
                              op_id: Op_DPipe
                            )
                          ]
                          spids: [-1 1416]
                        )
                      ]
                      spids: [-1 1437]
                    )
                  ]
                  spids: [-1 1388]
                )
              ]
              spids: [-1 1440]
            )
            (C {(eval)} {(DQ ($ VSub_Name "$GIT_SEQUENCE_EDITOR"))} {(SQ <"\"$@\"">)})
          ]
          spids: [1374]
        )
      spids: [1369 1373]
    )
    (FuncDef
      name: pick_one
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:ff) op:Equal rhs:{(--ff)} spids:[1465])]
              spids: [1465]
            )
            (Case
              to_match: {(DQ ($ VSub_Number "$1"))}
              arms: [
                (case_arm
                  pat_list: [{(-n)}]
                  action: [
                    (Sentence
                      child: 
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:sha1)
                              op: Equal
                              rhs: {($ VSub_Number "$2")}
                              spids: [1481]
                            )
                          ]
                          spids: [1481]
                        )
                      terminator: <Op_Semi ";">
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(LhsName name:ff) op:Equal rhs:{(SQ )} spids:[1485])]
                      spids: [1485]
                    )
                  ]
                  spids: [1478 1479 1487 -1]
                )
                (case_arm
                  pat_list: [{(Lit_Other "*")}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:sha1)
                          op: Equal
                          rhs: {($ VSub_Number "$1")}
                          spids: [1492]
                        )
                      ]
                      spids: [1492]
                    )
                  ]
                  spids: [1489 1490 1495 -1]
                )
              ]
              spids: [1470 1476 1497]
            )
            (Case
              to_match: {(DQ ($ VSub_Name "$force_rebase"))}
              arms: [
                (case_arm pat_list:[{(SQ )}] spids:[-115101512-1])
                (case_arm
                  pat_list: [{(Lit_Other "?") (Lit_Other "*")}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(LhsName name:ff) op:Equal rhs:{(SQ )} spids:[1518])]
                      spids: [1518]
                    )
                  ]
                  spids: [1514 1516 1520 -1]
                )
              ]
              spids: [1500 1506 1522]
            )
            (AndOr
              children: [
                (C {(output)} {(git)} {(rev-parse)} {(--verify)} {($ VSub_Name "$sha1")})
                (C {(die)} 
                  {
                    (DQ 
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(eval_gettext)} 
                                {
                                  (DQ ("Invalid commit name: ") 
                                    (EscapedLiteralPart
                                      token: <Lit_EscapedChar "\\$">
                                    ) (sha1)
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [1540 1548]
                      )
                    )
                  }
                )
              ]
              op_id: Op_DPipe
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(is_empty_commit)} {(DQ ($ VSub_Name "$sha1"))})]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:empty_args)
                          op: Equal
                          rhs: {(DQ (--allow-empty))}
                          spids: [1565]
                        )
                      ]
                      spids: [1565]
                    )
                  ]
                  spids: [-1 1562]
                )
              ]
              spids: [-1 1571]
            )
            (AndOr
              children: [
                (C {(test)} {(-d)} {(DQ ($ VSub_Name "$rewritten"))})
                (AndOr
                  children: [
                    (C {(pick_one_preserving_merges)} {(DQ ($ VSub_At "$@"))})
                    (ControlFlow token:<ControlFlow_Return return>)
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
            (C {(output)} {(eval)} {(git)} {(cherry-pick)} 
              {
                (BracedVarSub
                  token: <VSub_Name gpg_sign_opt>
                  suffix_op: 
                    (StringUnary
                      op_id: VTest_ColonPlus
                      arg_word: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(git)} {(rev-parse)} {(--sq-quote)} 
                                    {(DQ ($ VSub_Name "$gpg_sign_opt"))}
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [1610 1620]
                          )
                        }
                    )
                  spids: [1607 1621]
                )
              } {(DQ ($ VSub_Name "$strategy_args"))} {($ VSub_Name "$empty_args")} {($ VSub_Name "$ff")} 
              {(DQ ($ VSub_At "$@"))}
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:ret)
                  op: Equal
                  rhs: {($ VSub_QMark "$?")}
                  spids: [1647]
                )
              ]
              spids: [1647]
            )
            (Case
              to_match: {(DQ ($ VSub_Name "$ret"))}
              arms: [
                (case_arm
                  pat_list: [{(Lit_Other "[") (01) (Lit_Other "]")}]
                  spids: [1659 1662 1664 -1]
                )
                (case_arm
                  pat_list: [{(Lit_Other "*")}]
                  action: [(C {(reschedule_last_action)})]
                  spids: [1666 1667 1671 -1]
                )
              ]
              spids: [1651 1657 1673]
            )
            (ControlFlow token:<ControlFlow_Return return> arg_word:{($ VSub_Name "$ret")})
          ]
          spids: [1462]
        )
      spids: [1457 1461]
    )
    (FuncDef
      name: pick_one_preserving_merges
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:fast_forward) op:Equal rhs:{(t)} spids:[1691])]
              spids: [1691]
            )
            (Case
              to_match: {(DQ ($ VSub_Number "$1"))}
              arms: [
                (case_arm
                  pat_list: [{(-n)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:fast_forward)
                          op: Equal
                          rhs: {(f)}
                          spids: [1708]
                        )
                      ]
                      spids: [1708]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:sha1)
                          op: Equal
                          rhs: {($ VSub_Number "$2")}
                          spids: [1712]
                        )
                      ]
                      spids: [1712]
                    )
                  ]
                  spids: [1704 1705 1716 -1]
                )
                (case_arm
                  pat_list: [{(Lit_Other "*")}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:sha1)
                          op: Equal
                          rhs: {($ VSub_Number "$1")}
                          spids: [1723]
                        )
                      ]
                      spids: [1723]
                    )
                  ]
                  spids: [1719 1720 1727 -1]
                )
              ]
              spids: [1695 1701 1730]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:sha1)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [(C {(git)} {(rev-parse)} {($ VSub_Name "$sha1")})]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [1734 1740]
                      )
                    }
                  spids: [1733]
                )
              ]
              spids: [1733]
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-f)} {(DQ ($ VSub_Name "$state_dir")) (/current-commit)})]
                  action: [
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (C {(test)} {(DQ ($ VSub_Name "$fast_forward"))} {(Lit_Other "=")} {(t)})
                          ]
                          action: [
                            (While
                              cond: [(C {(read)} {(current_commit)})]
                              body: 
                                (DoGroup
                                  children: [
                                    (SimpleCommand
                                      words: [{(git)} {(rev-parse)} {(HEAD)}]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_Great
                                          fd: -1
                                          arg_word: 
                                            {(DQ ($ VSub_Name "$rewritten")) (/) 
                                              ($ VSub_Name "$current_commit")
                                            }
                                          spids: [1791]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [1782 1800]
                                )
                              redirects: [
                                (Redir
                                  op_id: Redir_Less
                                  fd: -1
                                  arg_word: {(DQ ($ VSub_Name "$state_dir")) (/current-commit)}
                                  spids: [1802]
                                )
                              ]
                            )
                            (AndOr
                              children: [
                                (C {(rm)} {(DQ ($ VSub_Name "$state_dir")) (/current-commit)})
                                (C {(die)} 
                                  {
                                    (DQ 
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (C {(gettext)} 
                                                {
                                                  (DQ 
                                                    (
"Cannot write current commit's replacement sha1"
                                                    )
                                                  )
                                                }
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub "$(">
                                        spids: [1822 1828]
                                      )
                                    )
                                  }
                                )
                              ]
                              op_id: Op_DPipe
                            )
                          ]
                          spids: [-1 1772]
                        )
                      ]
                      spids: [-1 1832]
                    )
                  ]
                  spids: [-1 1756]
                )
              ]
              spids: [-1 1835]
            )
            (SimpleCommand
              words: [{(echo)} {($ VSub_Name "$sha1")}]
              redirects: [
                (Redir
                  op_id: Redir_DGreat
                  fd: -1
                  arg_word: {(DQ ($ VSub_Name "$state_dir")) (/current-commit)}
                  spids: [1843]
                )
              ]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:new_parents) op:Equal rhs:{(SQ )} spids:[1856])]
              spids: [1856]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:pend)
                  op: Equal
                  rhs: 
                    {
                      (DQ (" ") 
                        (CommandSubPart
                          command_list: 
                            (CommandList
                              children: [
                                (Pipeline
                                  children: [
                                    (C {(git)} {(rev-list)} {(--parents)} {(-1)} {($ VSub_Name "$sha1")})
                                    (C {(cut)} {(-d) (SQ <" ">)} {(-s)} {(-f2-)})
                                  ]
                                  negated: False
                                )
                              ]
                            )
                          left_token: <Left_CommandSub "$(">
                          spids: [1862 1885]
                        )
                      )
                    }
                  spids: [1859]
                )
              ]
              spids: [1859]
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(DQ ($ VSub_Name "$pend"))} {(Lit_Other "=")} {(DQ (" "))})]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:pend)
                          op: Equal
                          rhs: {(DQ (" root"))}
                          spids: [1907]
                        )
                      ]
                      spids: [1907]
                    )
                  ]
                  spids: [-1 1904]
                )
              ]
              spids: [-1 1913]
            )
            (While
              cond: [
                (C {(Lit_Other "[")} {(DQ ($ VSub_Name "$pend"))} {(KW_Bang "!") (Lit_Other "=")} {(DQ )} 
                  {(Lit_Other "]")}
                )
              ]
              body: 
                (DoGroup
                  children: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:p)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(expr)} {(DQ ($ VSub_Name "$pend"))} {(Lit_Other ":")} 
                                        {(SQ <" \\([^ ]*\\)">)}
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [1937 1949]
                              )
                            }
                          spids: [1936]
                        )
                      ]
                      spids: [1936]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:pend)
                          op: Equal
                          rhs: 
                            {
                              (DQ 
                                (BracedVarSub
                                  token: <VSub_Name pend>
                                  suffix_op: 
                                    (StringUnary
                                      op_id: VOp1_Pound
                                      arg_word: {(" ") ($ VSub_Name "$p")}
                                    )
                                  spids: [1954 1959]
                                )
                              )
                            }
                          spids: [1952]
                        )
                      ]
                      spids: [1952]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (C {(test)} {(-f)} {(DQ ($ VSub_Name "$rewritten")) (/) ($ VSub_Name "$p")})
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:new_p)
                                  op: Equal
                                  rhs: 
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (C {(cat)} 
                                                {(DQ ($ VSub_Name "$rewritten")) (/) 
                                                  ($ VSub_Name "$p")
                                                }
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub "$(">
                                        spids: [1981 1989]
                                      )
                                    }
                                  spids: [1980]
                                )
                              ]
                              spids: [1980]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$new_p"))})]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:new_p)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [(C {(git)} {(rev-parse)} {(HEAD)})]
                                                  )
                                                left_token: <Left_CommandSub "$(">
                                                spids: [2020 2026]
                                              )
                                            }
                                          spids: [2019]
                                        )
                                      ]
                                      spids: [2019]
                                    )
                                  ]
                                  spids: [-1 2016]
                                )
                              ]
                              spids: [-1 2029]
                            )
                            (AndOr
                              children: [
                                (C {(test)} {($ VSub_Name "$p")} {(KW_Bang "!") (Lit_Other "=")} 
                                  {($ VSub_Name "$new_p")}
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:fast_forward)
                                      op: Equal
                                      rhs: {(f)}
                                      spids: [2044]
                                    )
                                  ]
                                  spids: [2044]
                                )
                              ]
                              op_id: Op_DAmp
                            )
                            (Case
                              to_match: {(DQ ($ VSub_Name "$new_parents"))}
                              arms: [
                                (case_arm
                                  pat_list: [{(Lit_Other "*") ($ VSub_Name "$new_p") (Lit_Other "*")}]
                                  spids: [2057 2060 2063 -1]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Other "*")}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:new_parents)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$new_parents") (" ") 
                                                ($ VSub_Name "$new_p")
                                              )
                                            }
                                          spids: [2073]
                                        )
                                      ]
                                      spids: [2073]
                                    )
                                  ]
                                  spids: [2069 2070 2081 -1]
                                )
                              ]
                              spids: [2048 2054 2084]
                            )
                          ]
                          spids: [-1 1977]
                        )
                      ]
                      else_action: [
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (C {(test)} {(-f)} 
                                  {(DQ ($ VSub_Name "$dropped")) (/) ($ VSub_Name "$p")}
                                )
                              ]
                              action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:fast_forward)
                                      op: Equal
                                      rhs: {(f)}
                                      spids: [2106]
                                    )
                                  ]
                                  spids: [2106]
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:replacement)
                                      op: Equal
                                      rhs: 
                                        {
                                          (DQ 
                                            (CommandSubPart
                                              command_list: 
                                                (CommandList
                                                  children: [
                                                    (C {(cat)} 
                                                      {(DQ ($ VSub_Name "$dropped")) (/) 
                                                        ($ VSub_Name "$p")
                                                      }
                                                    )
                                                  ]
                                                )
                                              left_token: <Left_CommandSub "$(">
                                              spids: [2112 2120]
                                            )
                                          )
                                        }
                                      spids: [2110]
                                    )
                                  ]
                                  spids: [2110]
                                )
                                (AndOr
                                  children: [
                                    (C {(test)} {(-z)} {(DQ ($ VSub_Name "$replacement"))})
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:replacement)
                                          op: Equal
                                          rhs: {(root)}
                                          spids: [2134]
                                        )
                                      ]
                                      spids: [2134]
                                    )
                                  ]
                                  op_id: Op_DAmp
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:pend)
                                      op: Equal
                                      rhs: 
                                        {
                                          (DQ (" ") ($ VSub_Name "$replacement") ($ VSub_Name "$pend"))
                                        }
                                      spids: [2138]
                                    )
                                  ]
                                  spids: [2138]
                                )
                              ]
                              spids: [-1 2103]
                            )
                          ]
                          else_action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:new_parents)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name "$new_parents") (" ") ($ VSub_Name "$p"))}
                                  spids: [2149]
                                )
                              ]
                              spids: [2149]
                            )
                          ]
                          spids: [2146 2157]
                        )
                      ]
                      spids: [2087 2160]
                    )
                  ]
                  spids: [1933 2163]
                )
            )
            (Case
              to_match: {($ VSub_Name "$fast_forward")}
              arms: [
                (case_arm
                  pat_list: [{(t)}]
                  action: [
                    (C {(output)} {(warn)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ ("Fast-forward to ") 
                                        (EscapedLiteralPart
                                          token: <Lit_EscapedChar "\\$">
                                        ) (sha1)
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [2182 2190]
                          )
                        )
                      }
                    )
                    (AndOr
                      children: [
                        (C {(output)} {(git)} {(reset)} {(--hard)} {($ VSub_Name "$sha1")})
                        (C {(die)} 
                          {
                            (DQ 
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(eval_gettext)} 
                                        {
                                          (DQ ("Cannot fast-forward to ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\$">
                                            ) (sha1)
                                          )
                                        }
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [2210 2218]
                              )
                            )
                          }
                        )
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  spids: [2173 2174 2222 -1]
                )
                (case_arm
                  pat_list: [{(f)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:first_parent)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(expr)} {(DQ ($ VSub_Name "$new_parents"))} {(Lit_Other ":")} 
                                        {(SQ <" \\([^ ]*\\)">)}
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [2230 2242]
                              )
                            }
                          spids: [2229]
                        )
                      ]
                      spids: [2229]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (C {(Lit_Other "[")} {(DQ ($ VSub_Number "$1"))} 
                              {(KW_Bang "!") (Lit_Other "=")} {(DQ (-n))} {(Lit_Other "]")}
                            )
                          ]
                          action: [
                            (AndOr
                              children: [
                                (SimpleCommand
                                  words: [{(output)} {(git)} {(checkout)} {($ VSub_Name "$first_parent")}]
                                  redirects: [
                                    (Redir
                                      op_id: Redir_Great
                                      fd: 2
                                      arg_word: {(/dev/null)}
                                      spids: [2279]
                                    )
                                  ]
                                )
                                (C {(die)} 
                                  {
                                    (DQ 
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (C {(eval_gettext)} 
                                                {
                                                  (DQ ("Cannot move HEAD to ") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\$">
                                                    ) (first_parent)
                                                  )
                                                }
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub "$(">
                                        spids: [2289 2297]
                                      )
                                    )
                                  }
                                )
                              ]
                              op_id: Op_DPipe
                            )
                          ]
                          spids: [-1 2264]
                        )
                      ]
                      spids: [-1 2301]
                    )
                    (Case
                      to_match: {(DQ ($ VSub_Name "$new_parents"))}
                      arms: [
                        (case_arm
                          pat_list: [{(SQ <" ">) (Lit_Other "*") (SQ <" ">) (Lit_Other "*")}]
                          action: [
                            (AndOr
                              children: [
                                (C {(test)} {(DQ (a) ($ VSub_Number "$1"))} {(Lit_Other "=")} {(a-n)})
                                (C {(die)} 
                                  {
                                    (DQ 
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (C {(eval_gettext)} 
                                                {
                                                  (DQ ("Refusing to squash a merge: ") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\$">
                                                    ) (sha1)
                                                  )
                                                }
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub "$(">
                                        spids: [2341 2349]
                                      )
                                    )
                                  }
                                )
                              ]
                              op_id: Op_DAmp
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:author_script_content)
                                  op: Equal
                                  rhs: 
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (C {(get_author_ident_from_commit)} 
                                                {($ VSub_Name "$sha1")}
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub "$(">
                                        spids: [2359 2363]
                                      )
                                    }
                                  spids: [2358]
                                )
                              ]
                              spids: [2358]
                            )
                            (C {(eval)} {(DQ ($ VSub_Name "$author_script_content"))})
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:msg_content)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (CommandSubPart
                                          command_list: 
                                            (CommandList
                                              children: [(C {(commit_message)} {($ VSub_Name "$sha1")})]
                                            )
                                          left_token: <Left_CommandSub "$(">
                                          spids: [2375 2379]
                                        )
                                      )
                                    }
                                  spids: [2373]
                                )
                              ]
                              spids: [2373]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:new_parents)
                                  op: Equal
                                  rhs: 
                                    {
                                      (BracedVarSub
                                        token: <VSub_Name new_parents>
                                        suffix_op: 
                                          (StringUnary
                                            op_id: VOp1_Pound
                                            arg_word: {(" ") ($ VSub_Name "$first_parent")}
                                          )
                                        spids: [2388 2393]
                                      )
                                    }
                                  spids: [2387]
                                )
                              ]
                              spids: [2387]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:merge_args)
                                  op: Equal
                                  rhs: {(DQ ("--no-log --no-ff"))}
                                  spids: [2396]
                                )
                              ]
                              spids: [2396]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (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: True
                                    )
                                  ]
                                  action: [
                                    (SimpleCommand
                                      words: [
                                        {(printf)}
                                        {
                                          (DQ ("%s") (EscapedLiteralPart token:<Lit_EscapedChar "\\n">))
                                        }
                                        {(DQ ($ VSub_Name "$msg_content"))}
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_Great
                                          fd: -1
                                          arg_word: {(DQ ($ VSub_Name "$GIT_DIR")) (/MERGE_MSG)}
                                          spids: [2434]
                                        )
                                      ]
                                    )
                                    (C {(die_with_patch)} {($ VSub_Name "$sha1")} 
                                      {
                                        (DQ 
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (C {(eval_gettext)} 
                                                    {
                                                      (DQ ("Error redoing merge ") 
                                                        (EscapedLiteralPart
                                                          token: <Lit_EscapedChar "\\$">
                                                        ) (sha1)
                                                      )
                                                    }
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub "$(">
                                            spids: [2447 2455]
                                          )
                                        )
                                      }
                                    )
                                  ]
                                  spids: [-1 2420]
                                )
                              ]
                              spids: [-1 2459]
                            )
                            (SimpleCommand
                              words: [
                                {(echo)}
                                {
                                  (DQ ($ VSub_Name "$sha1") (" ") 
                                    (CommandSubPart
                                      command_list: 
                                        (CommandList
                                          children: [
                                            (C {(git)} {(rev-parse)} {(HEAD) (Lit_Other "^") (0)})
                                          ]
                                        )
                                      left_token: <Left_CommandSub "$(">
                                      spids: [2467 2475]
                                    )
                                  )
                                }
                              ]
                              redirects: [
                                (Redir
                                  op_id: Redir_DGreat
                                  fd: -1
                                  arg_word: {(DQ ($ VSub_Name "$rewritten_list"))}
                                  spids: [2478]
                                )
                              ]
                            )
                          ]
                          spids: [2315 2322 2485 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [
                            (AndOr
                              children: [
                                (C {(output)} {(eval)} {(git)} {(cherry-pick)} 
                                  {
                                    (BracedVarSub
                                      token: <VSub_Name gpg_sign_opt>
                                      suffix_op: 
                                        (StringUnary
                                          op_id: VTest_ColonPlus
                                          arg_word: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (C {(git)} {(rev-parse)} {(--sq-quote)} 
                                                        {(DQ ($ VSub_Name "$gpg_sign_opt"))}
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_CommandSub "$(">
                                                spids: [2505 2515]
                                              )
                                            }
                                        )
                                      spids: [2502 2516]
                                    )
                                  } {(DQ ($ VSub_Name "$strategy_args"))} {(DQ ($ VSub_At "$@"))}
                                )
                                (C {(die_with_patch)} {($ VSub_Name "$sha1")} 
                                  {
                                    (DQ 
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (C {(eval_gettext)} 
                                                {
                                                  (DQ ("Could not pick ") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\$">
                                                    ) (sha1)
                                                  )
                                                }
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub "$(">
                                        spids: [2536 2544]
                                      )
                                    )
                                  }
                                )
                              ]
                              op_id: Op_DPipe
                            )
                          ]
                          spids: [2488 2489 2548 -1]
                        )
                      ]
                      spids: [2305 2311 2551]
                    )
                  ]
                  spids: [2225 2226 2554 -1]
                )
              ]
              spids: [2166 2170 2557]
            )
          ]
          spids: [1688]
        )
      spids: [1683 1687]
    )
    (FuncDef
      name: this_nth_commit_message
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:n)
                  op: Equal
                  rhs: {($ VSub_Number "$1")}
                  spids: [2570]
                )
              ]
              spids: [2570]
            )
            (C {(eval_gettext)} 
              {
                (DQ ("This is the commit message #") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) 
                  ("{n}:")
                )
              }
            )
          ]
          spids: [2567]
        )
      spids: [2562 2566]
    )
    (FuncDef
      name: skip_nth_commit_message
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:n)
                  op: Equal
                  rhs: {($ VSub_Number "$1")}
                  spids: [2593]
                )
              ]
              spids: [2593]
            )
            (C {(eval_gettext)} 
              {
                (DQ ("The commit message #") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) 
                  ("{n} will be skipped:")
                )
              }
            )
          ]
          spids: [2590]
        )
      spids: [2585 2589]
    )
    (FuncDef
      name: update_squash_messages
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: (C {(test)} {(-f)} {(DQ ($ VSub_Name "$squash_msg"))})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (AndOr
                      children: [
                        (C {(mv)} {(DQ ($ VSub_Name "$squash_msg"))} 
                          {(DQ ($ VSub_Name "$squash_msg")) (.bak)}
                        )
                        (C {(exit)})
                      ]
                      op_id: Op_DPipe
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:count)
                          op: Equal
                          rhs: 
                            {
                              (ArithSubPart
                                anode: 
                                  (ArithBinary
                                    op_id: Arith_Plus
                                    left: 
                                      (ArithWord
                                        w: 
                                          {
                                            (CommandSubPart
                                              command_list: 
                                                (CommandList
                                                  children: [
                                                    (SimpleCommand
                                                      words: [
                                                        {(sed)}
                                                        {(-n)}
                                                        {(-e)}
                                                        {
                                                          (DQ ("1s/^") ($ VSub_Name "$comment_char") 
                                                            (".*") (EscapedLiteralPart token:<Lit_EscapedChar "\\(">) ("[0-9][0-9]*") 
                                                            (EscapedLiteralPart
                                                              token: <Lit_EscapedChar "\\)">
                                                            ) (".*/") (EscapedLiteralPart token:<Lit_EscapedChar "\\1">) (/p)
                                                          )
                                                        }
                                                        {(-e)}
                                                        {(DQ (q))}
                                                      ]
                                                      redirects: [
                                                        (Redir
                                                          op_id: Redir_Less
                                                          fd: -1
                                                          arg_word: 
                                                            {(DQ ($ VSub_Name "$squash_msg")) (.bak)}
                                                          spids: [2677]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              left_token: <Left_CommandSub "$(">
                                              spids: [2648 2683]
                                            )
                                          }
                                      )
                                    right: (ArithWord w:{(Lit_Digits 1)})
                                  )
                                spids: [2647 2687]
                              )
                            }
                          spids: [2646]
                        )
                      ]
                      spids: [2646]
                    )
                    (BraceGroup
                      children: [
                        (C {(printf)} {(SQ <"%s\\n">)} 
                          {
                            (DQ ($ VSub_Name "$comment_char") (" ") 
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(eval_ngettext)} 
                                        {
                                          (DQ ("This is a combination of ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\$">
                                            ) ("count commit.")
                                          )
                                        } 
                                        {
                                          (DQ ("This is a combination of ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\$">
                                            ) ("count commits.")
                                          )
                                        } {($ VSub_Name "$count")}
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [2702 2724]
                              )
                            )
                          }
                        )
                        (SimpleCommand
                          words: [
                            {(sed)}
                            {(-e)}
                            {(1d)}
                            {(-e)}
                            {(SQ <"2,/^./{\n"> <"\t\t\t\t/^$/d\n"> <"\t\t\t}">)}
                          ]
                          redirects: [
                            (Redir
                              op_id: Redir_Less
                              fd: -1
                              arg_word: {(DQ ($ VSub_Name "$squash_msg")) (.bak)}
                              spids: [2742]
                            )
                          ]
                        )
                      ]
                      redirects: [
                        (Redir
                          op_id: Redir_Great
                          fd: -1
                          arg_word: {(DQ ($ VSub_Name "$squash_msg"))}
                          spids: [2751]
                        )
                      ]
                      spids: [2690]
                    )
                  ]
                  spids: [-1 2627]
                )
              ]
              else_action: [
                (AndOr
                  children: [
                    (SimpleCommand
                      words: [{(commit_message)} {(HEAD)}]
                      redirects: [
                        (Redir
                          op_id: Redir_Great
                          fd: -1
                          arg_word: {(DQ ($ VSub_Name "$fixup_msg"))}
                          spids: [2764]
                        )
                      ]
                    )
                    (C {(die)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(gettext)} 
                                    {
                                      (DQ ("Cannot write ") 
                                        (EscapedLiteralPart
                                          token: <Lit_EscapedChar "\\$">
                                        ) (fixup_msg)
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [2775 2783]
                          )
                        )
                      }
                    )
                  ]
                  op_id: Op_DPipe
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [(assign_pair lhs:(LhsName name:count) op:Equal rhs:{(2)} spids:[2787])]
                  spids: [2787]
                )
                (BraceGroup
                  children: [
                    (C {(printf)} {(SQ <"%s\\n">)} 
                      {
                        (DQ ($ VSub_Name "$comment_char") (" ") 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(gettext)} {(DQ ("This is a combination of 2 commits."))})
                                ]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [2803 2809]
                          )
                        )
                      }
                    )
                    (C {(printf)} {(SQ <"%s\\n">)} 
                      {
                        (DQ ($ VSub_Name "$comment_char") (" ") 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [(C {(gettext)} {(DQ ("This is the 1st commit message:"))})]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [2822 2828]
                          )
                        )
                      }
                    )
                    (C {(echo)})
                    (C {(cat)} {(DQ ($ VSub_Name "$fixup_msg"))})
                  ]
                  redirects: [
                    (Redir
                      op_id: Redir_Great
                      fd: -1
                      arg_word: {(DQ ($ VSub_Name "$squash_msg"))}
                      spids: [2844]
                    )
                  ]
                  spids: [2791]
                )
              ]
              spids: [2757 2850]
            )
            (Case
              to_match: {($ VSub_Number "$1")}
              arms: [
                (case_arm
                  pat_list: [{(squash)}]
                  action: [
                    (C {(rm)} {(-f)} {(DQ ($ VSub_Name "$fixup_msg"))})
                    (C {(echo)})
                    (C {(printf)} {(SQ <"%s\\n">)} 
                      {
                        (DQ ($ VSub_Name "$comment_char") (" ") 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [(C {(this_nth_commit_message)} {($ VSub_Name "$count")})]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [2885 2889]
                          )
                        )
                      }
                    )
                    (C {(echo)})
                    (C {(commit_message)} {($ VSub_Number "$2")})
                  ]
                  spids: [2860 2861 2901 -1]
                )
                (case_arm
                  pat_list: [{(fixup)}]
                  action: [
                    (C {(echo)})
                    (C {(printf)} {(SQ <"%s\\n">)} 
                      {
                        (DQ ($ VSub_Name "$comment_char") (" ") 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [(C {(skip_nth_commit_message)} {($ VSub_Name "$count")})]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [2920 2924]
                          )
                        )
                      }
                    )
                    (C {(echo)})
                    (Pipeline
                      children: [
                        (C {(commit_message)} {($ VSub_Number "$2")})
                        (C {(git)} {(stripspace)} {(--comment-lines)})
                        (C {(sed)} {(-e)} {(SQ <"s/ /\t/">)})
                      ]
                      negated: False
                    )
                  ]
                  spids: [2904 2905 2958 -1]
                )
              ]
              redirects: [
                (Redir
                  op_id: Redir_DGreat
                  fd: -1
                  arg_word: {(DQ ($ VSub_Name "$squash_msg"))}
                  spids: [2963]
                )
              ]
              spids: [2853 2857 2961]
            )
          ]
          spids: [2613]
        )
      spids: [2608 2612]
    )
    (FuncDef
      name: peek_next_command
      body: 
        (BraceGroup
          children: [
            (Pipeline
              children: [
                (SimpleCommand
                  words: [{(git)} {(stripspace)} {(--strip-comments)}]
                  redirects: [
                    (Redir
                      op_id: Redir_Less
                      fd: -1
                      arg_word: {(DQ ($ VSub_Name "$todo"))}
                      spids: [2985]
                    )
                  ]
                )
                (C {(sed)} {(-n)} {(-e)} {(SQ <"s/ .*//p">)} {(-e)} {(q)})
              ]
              negated: False
            )
          ]
          spids: [2976]
        )
      spids: [2971 2975]
    )
    (FuncDef
      name: die_failed_squash
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:sha1)
                  op: Equal
                  rhs: {($ VSub_Number "$1")}
                  spids: [3034]
                )
              ]
              spids: [3034]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:rest)
                  op: Equal
                  rhs: {($ VSub_Number "$2")}
                  spids: [3038]
                )
              ]
              spids: [3038]
            )
            (AndOr
              children: [
                (C {(mv)} {(DQ ($ VSub_Name "$squash_msg"))} {(DQ ($ VSub_Name "$msg"))})
                (C {(exit)})
              ]
              op_id: Op_DPipe
            )
            (C {(rm)} {(-f)} {(DQ ($ VSub_Name "$fixup_msg"))})
            (AndOr
              children: [
                (C {(cp)} {(DQ ($ VSub_Name "$msg"))} {(DQ ($ VSub_Name "$GIT_DIR")) (/MERGE_MSG)})
                (C {(exit)})
              ]
              op_id: Op_DPipe
            )
            (C {(warn)})
            (C {(warn)} 
              {
                (DQ 
                  (CommandSubPart
                    command_list: 
                      (CommandList
                        children: [
                          (C {(eval_gettext)} 
                            {
                              (DQ ("Could not apply ") 
                                (EscapedLiteralPart
                                  token: <Lit_EscapedChar "\\$">
                                ) ("sha1... ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (rest)
                              )
                            }
                          )
                        ]
                      )
                    left_token: <Left_CommandSub "$(">
                    spids: [3088 3098]
                  )
                )
              }
            )
            (C {(die_with_patch)} {($ VSub_Name "$sha1")} {(DQ )})
          ]
          spids: [3031]
        )
      spids: [3027 3030]
    )
    (FuncDef
      name: flush_rewritten_pending
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(test)} {(-s)} {(DQ ($ VSub_Name "$rewritten_pending"))})
                (ControlFlow token:<ControlFlow_Return return>)
              ]
              op_id: Op_DPipe
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:newsha1)
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (CommandSubPart
                          command_list: 
                            (CommandList
                              children: [(C {(git)} {(rev-parse)} {(HEAD) (Lit_Other "^") (0)})]
                            )
                          left_token: <Left_CommandSub "$(">
                          spids: [3134 3142]
                        )
                      )
                    }
                  spids: [3132]
                )
              ]
              spids: [3132]
            )
            (SimpleCommand
              words: [{(sed)} {(DQ (s/) (Lit_Other "$") ("/ ") ($ VSub_Name "$newsha1") (/))}]
              redirects: [
                (Redir
                  op_id: Redir_Less
                  fd: -1
                  arg_word: {(DQ ($ VSub_Name "$rewritten_pending"))}
                  spids: [3156]
                )
                (Redir
                  op_id: Redir_DGreat
                  fd: -1
                  arg_word: {(DQ ($ VSub_Name "$rewritten_list"))}
                  spids: [3162]
                )
              ]
            )
            (C {(rm)} {(-f)} {(DQ ($ VSub_Name "$rewritten_pending"))})
          ]
          spids: [3116]
        )
      spids: [3112 3115]
    )
    (FuncDef
      name: record_in_rewritten
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:oldsha1)
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (CommandSubPart
                          command_list: 
                            (CommandList
                              children: [(C {(git)} {(rev-parse)} {($ VSub_Number "$1")})]
                            )
                          left_token: <Left_CommandSub "$(">
                          spids: [3189 3195]
                        )
                      )
                    }
                  spids: [3187]
                )
              ]
              spids: [3187]
            )
            (SimpleCommand
              words: [{(echo)} {(DQ ($ VSub_Name "$oldsha1"))}]
              redirects: [
                (Redir
                  op_id: Redir_DGreat
                  fd: -1
                  arg_word: {(DQ ($ VSub_Name "$rewritten_pending"))}
                  spids: [3205]
                )
              ]
            )
            (Case
              to_match: 
                {
                  (DQ 
                    (CommandSubPart
                      command_list: (CommandList children:[(C {(peek_next_command)})])
                      left_token: <Left_CommandSub "$(">
                      spids: [3216 3218]
                    )
                  )
                }
              arms: [
                (case_arm
                  pat_list: [{(squash)} {(s)} {(fixup)} {(f)}]
                  spids: [3224 3231 3234 -1]
                )
                (case_arm
                  pat_list: [{(Lit_Other "*")}]
                  action: [(C {(flush_rewritten_pending)})]
                  spids: [3237 3238 3244 -1]
                )
              ]
              spids: [3213 3221 3247]
            )
          ]
          spids: [3184]
        )
      spids: [3180 3183]
    )
    (FuncDef
      name: do_pick
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:sha1)
                  op: Equal
                  rhs: {($ VSub_Number "$1")}
                  spids: [3260]
                )
              ]
              spids: [3260]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:rest)
                  op: Equal
                  rhs: {($ VSub_Number "$2")}
                  spids: [3264]
                )
              ]
              spids: [3264]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (C {(test)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: (CommandList children:[(C {(git)} {(rev-parse)} {(HEAD)})])
                            left_token: <Left_CommandSub "$(">
                            spids: [3273 3279]
                          )
                        )
                      } {(Lit_Other "=")} {(DQ ($ VSub_Name "$squash_onto"))}
                    )
                  ]
                  action: [
                    (AndOr
                      children: [
                        (C {(git)} {(commit)} {(--allow-empty)} {(--allow-empty-message)} {(--amend)} 
                          {(--no-post-rewrite)} {(-n)} {(-q)} {(-C)} {($ VSub_Name "$sha1")}
                        )
                        (AndOr
                          children: [
                            (C {(pick_one)} {(-n)} {($ VSub_Name "$sha1")})
                            (AndOr
                              children: [
                                (C {(git)} {(commit)} {(--allow-empty)} {(--allow-empty-message)} 
                                  {(--amend)} {(--no-post-rewrite)} {(-n)} {(-q)} {(-C)} {($ VSub_Name "$sha1")} 
                                  {
                                    (BracedVarSub
                                      token: <VSub_Name gpg_sign_opt>
                                      suffix_op: 
                                        (StringUnary
                                          op_id: VTest_ColonPlus
                                          arg_word: {(DQ ($ VSub_Name "$gpg_sign_opt"))}
                                        )
                                      spids: [3382 3388]
                                    )
                                  }
                                )
                                (C {(die_with_patch)} {($ VSub_Name "$sha1")} 
                                  {
                                    (DQ 
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (C {(eval_gettext)} 
                                                {
                                                  (DQ ("Could not apply ") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\$">
                                                    ) ("sha1... ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (rest)
                                                  )
                                                }
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub "$(">
                                        spids: [3398 3408]
                                      )
                                    )
                                  }
                                )
                              ]
                              op_id: Op_DPipe
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  spids: [-1 3289]
                )
              ]
              else_action: [
                (AndOr
                  children: [
                    (C {(pick_one)} {($ VSub_Name "$sha1")})
                    (C {(die_with_patch)} {($ VSub_Name "$sha1")} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ ("Could not apply ") 
                                        (EscapedLiteralPart
                                          token: <Lit_EscapedChar "\\$">
                                        ) ("sha1... ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (rest)
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [3427 3437]
                          )
                        )
                      }
                    )
                  ]
                  op_id: Op_DPipe
                )
              ]
              spids: [3412 3441]
            )
          ]
          spids: [3257]
        )
      spids: [3252 3256]
    )
    (FuncDef
      name: do_next
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(rm)} {(-f)} {(DQ ($ VSub_Name "$msg"))} {(DQ ($ VSub_Name "$author_script"))} 
                  {(DQ ($ VSub_Name "$amend"))} {(DQ ($ VSub_Name "$state_dir")) (/stopped-sha)}
                )
                (C {(exit)})
              ]
              op_id: Op_DPipe
            )
            (SimpleCommand
              words: [{(read)} {(-r)} {(command)} {(sha1)} {(rest)}]
              redirects: [
                (Redir
                  op_id: Redir_Less
                  fd: -1
                  arg_word: {(DQ ($ VSub_Name "$todo"))}
                  spids: [3490]
                )
              ]
            )
            (Case
              to_match: {(DQ ($ VSub_Name "$command"))}
              arms: [
                (case_arm
                  pat_list: [
                    {(DQ ($ VSub_Name "$comment_char")) (Lit_Other "*")}
                    {(SQ )}
                    {(noop)}
                    {(drop)}
                    {(d)}
                  ]
                  action: [(C {(mark_action_done)})]
                  spids: [3507 3519 3525 -1]
                )
                (case_arm
                  pat_list: [{(DQ ($ VSub_Name "$cr"))}]
                  action: [(C {(mark_action_done)})]
                  spids: [3529 3531 3541 -1]
                )
                (case_arm
                  pat_list: [{(pick)} {(p)}]
                  action: [
                    (C {(comment_for_reflog)} {(pick)})
                    (C {(mark_action_done)})
                    (C {(do_pick)} {($ VSub_Name "$sha1")} {(DQ ($ VSub_Name "$rest"))})
                    (C {(record_in_rewritten)} {($ VSub_Name "$sha1")})
                  ]
                  spids: [3544 3547 3573 -1]
                )
                (case_arm
                  pat_list: [{(reword)} {(r)}]
                  action: [
                    (C {(comment_for_reflog)} {(reword)})
                    (C {(mark_action_done)})
                    (C {(do_pick)} {($ VSub_Name "$sha1")} {(DQ ($ VSub_Name "$rest"))})
                    (AndOr
                      children: [
                        (C {(git)} {(commit)} {(--amend)} {(--no-post-rewrite)} 
                          {
                            (BracedVarSub
                              token: <VSub_Name gpg_sign_opt>
                              suffix_op: 
                                (StringUnary
                                  op_id: VTest_ColonPlus
                                  arg_word: {(DQ ($ VSub_Name "$gpg_sign_opt"))}
                                )
                              spids: [3608 3614]
                            )
                          }
                        )
                        (BraceGroup
                          children: [
                            (C {(warn)} 
                              {
                                (DQ 
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(eval_gettext)} 
                                            {
                                              (DQ 
                                                (
"Could not amend commit after successfully picking "
                                                ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("sha1... ") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\$">
                                                ) ("rest\n") ("This is most likely due to an empty commit message, or the pre-commit hook\n") 
                                                (
"failed. If the pre-commit hook failed, you may need to resolve the issue before\n"
                                                ) ("you are able to reword the commit.")
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [3624 3638]
                                  )
                                )
                              }
                            )
                            (C {(exit_with_patch)} {($ VSub_Name "$sha1")} {(1)})
                          ]
                          spids: [3618]
                        )
                      ]
                      op_id: Op_DPipe
                    )
                    (C {(record_in_rewritten)} {($ VSub_Name "$sha1")})
                  ]
                  spids: [3576 3579 3657 -1]
                )
                (case_arm
                  pat_list: [{(edit)} {(e)}]
                  action: [
                    (C {(comment_for_reflog)} {(edit)})
                    (C {(mark_action_done)})
                    (C {(do_pick)} {($ VSub_Name "$sha1")} {(DQ ($ VSub_Name "$rest"))})
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:sha1_abbrev)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(git)} {(rev-parse)} {(--short)} {($ VSub_Name "$sha1")})
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [3685 3693]
                              )
                            }
                          spids: [3684]
                        )
                      ]
                      spids: [3684]
                    )
                    (C {(warn)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ ("Stopped at ") 
                                        (EscapedLiteralPart
                                          token: <Lit_EscapedChar "\\$">
                                        ) ("sha1_abbrev... ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (rest)
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [3699 3709]
                          )
                        )
                      }
                    )
                    (C {(exit_with_patch)} {($ VSub_Name "$sha1")} {(0)})
                  ]
                  spids: [3660 3663 3720 -1]
                )
                (case_arm
                  pat_list: [{(squash)} {(s)} {(fixup)} {(f)}]
                  action: [
                    (Case
                      to_match: {(DQ ($ VSub_Name "$command"))}
                      arms: [
                        (case_arm
                          pat_list: [{(squash)} {(s)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:squash_style)
                                  op: Equal
                                  rhs: {(squash)}
                                  spids: [3748]
                                )
                              ]
                              spids: [3748]
                            )
                          ]
                          spids: [3742 3745 3752 -1]
                        )
                        (case_arm
                          pat_list: [{(fixup)} {(f)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:squash_style)
                                  op: Equal
                                  rhs: {(fixup)}
                                  spids: [3761]
                                )
                              ]
                              spids: [3761]
                            )
                          ]
                          spids: [3755 3758 3765 -1]
                        )
                      ]
                      spids: [3733 3739 3768]
                    )
                    (C {(comment_for_reflog)} {($ VSub_Name "$squash_style")})
                    (AndOr
                      children: [
                        (C {(test)} {(-f)} {(DQ ($ VSub_Name "$done"))})
                        (AndOr
                          children: [
                            (C {(has_action)} {(DQ ($ VSub_Name "$done"))})
                            (C {(die)} 
                              {
                                (DQ 
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(eval_gettext)} 
                                            {
                                              (DQ ("Cannot '") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\$">
                                                ) ("squash_style' without a previous commit")
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [3799 3807]
                                  )
                                )
                              }
                            )
                          ]
                          op_id: Op_DPipe
                        )
                      ]
                      op_id: Op_DAmp
                    )
                    (C {(mark_action_done)})
                    (C {(update_squash_messages)} {($ VSub_Name "$squash_style")} 
                      {($ VSub_Name "$sha1")}
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:author_script_content)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [(C {(get_author_ident_from_commit)} {(HEAD)})]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [3823 3827]
                              )
                            }
                          spids: [3822]
                        )
                      ]
                      spids: [3822]
                    )
                    (SimpleCommand
                      words: [{(echo)} {(DQ ($ VSub_Name "$author_script_content"))}]
                      redirects: [
                        (Redir
                          op_id: Redir_Great
                          fd: -1
                          arg_word: {(DQ ($ VSub_Name "$author_script"))}
                          spids: [3836]
                        )
                      ]
                    )
                    (C {(eval)} {(DQ ($ VSub_Name "$author_script_content"))})
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Pipeline
                              children: [(C {(pick_one)} {(-n)} {($ VSub_Name "$sha1")})]
                              negated: True
                            )
                          ]
                          action: [
                            (SimpleCommand
                              words: [{(git)} {(rev-parse)} {(--verify)} {(HEAD)}]
                              redirects: [
                                (Redir
                                  op_id: Redir_Great
                                  fd: -1
                                  arg_word: {(DQ ($ VSub_Name "$amend"))}
                                  spids: [3872]
                                )
                              ]
                            )
                            (C {(die_failed_squash)} {($ VSub_Name "$sha1")} {(DQ ($ VSub_Name "$rest"))})
                          ]
                          spids: [-1 3861]
                        )
                      ]
                      spids: [-1 3887]
                    )
                    (Case
                      to_match: 
                        {
                          (DQ 
                            (CommandSubPart
                              command_list: (CommandList children:[(C {(peek_next_command)})])
                              left_token: <Left_CommandSub "$(">
                              spids: [3893 3895]
                            )
                          )
                        }
                      arms: [
                        (case_arm
                          pat_list: [{(squash)} {(s)} {(fixup)} {(f)}]
                          action: [
                            (AndOr
                              children: [
                                (C {(do_with_author)} {(output)} {(git)} {(commit)} {(--amend)} 
                                  {(--no-verify)} {(-F)} {(DQ ($ VSub_Name "$squash_msg"))} 
                                  {
                                    (BracedVarSub
                                      token: <VSub_Name gpg_sign_opt>
                                      suffix_op: 
                                        (StringUnary
                                          op_id: VTest_ColonPlus
                                          arg_word: {(DQ ($ VSub_Name "$gpg_sign_opt"))}
                                        )
                                      spids: [3939 3945]
                                    )
                                  }
                                )
                                (C {(die_failed_squash)} {($ VSub_Name "$sha1")} 
                                  {(DQ ($ VSub_Name "$rest"))}
                                )
                              ]
                              op_id: Op_DPipe
                            )
                          ]
                          spids: [3901 3908 3959 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [(C {(test)} {(-f)} {(DQ ($ VSub_Name "$fixup_msg"))})]
                                  action: [
                                    (AndOr
                                      children: [
                                        (C {(do_with_author)} {(git)} {(commit)} {(--amend)} 
                                          {(--no-verify)} {(-F)} {(DQ ($ VSub_Name "$fixup_msg"))} 
                                          {
                                            (BracedVarSub
                                              token: <VSub_Name gpg_sign_opt>
                                              suffix_op: 
                                                (StringUnary
                                                  op_id: VTest_ColonPlus
                                                  arg_word: {(DQ ($ VSub_Name "$gpg_sign_opt"))}
                                                )
                                              spids: [4002 4008]
                                            )
                                          }
                                        )
                                        (C {(die_failed_squash)} {($ VSub_Name "$sha1")} 
                                          {(DQ ($ VSub_Name "$rest"))}
                                        )
                                      ]
                                      op_id: Op_DPipe
                                    )
                                  ]
                                  spids: [-1 3981]
                                )
                              ]
                              else_action: [
                                (AndOr
                                  children: [
                                    (C {(cp)} {(DQ ($ VSub_Name "$squash_msg"))} 
                                      {(DQ ($ VSub_Name "$GIT_DIR")) (/SQUASH_MSG)}
                                    )
                                    (C {(exit)})
                                  ]
                                  op_id: Op_DPipe
                                )
                                (C {(rm)} {(-f)} {(DQ ($ VSub_Name "$GIT_DIR")) (/MERGE_MSG)})
                                (AndOr
                                  children: [
                                    (C {(do_with_author)} {(git)} {(commit)} {(--amend)} {(--no-verify)} 
                                      {(-F)} {(DQ ($ VSub_Name "$GIT_DIR")) (/SQUASH_MSG)} {(-e)} 
                                      {
                                        (BracedVarSub
                                          token: <VSub_Name gpg_sign_opt>
                                          suffix_op: 
                                            (StringUnary
                                              op_id: VTest_ColonPlus
                                              arg_word: {(DQ ($ VSub_Name "$gpg_sign_opt"))}
                                            )
                                          spids: [4072 4078]
                                        )
                                      }
                                    )
                                    (C {(die_failed_squash)} {($ VSub_Name "$sha1")} 
                                      {(DQ ($ VSub_Name "$rest"))}
                                    )
                                  ]
                                  op_id: Op_DPipe
                                )
                              ]
                              spids: [4022 4092]
                            )
                            (C {(rm)} {(-f)} {(DQ ($ VSub_Name "$squash_msg"))} 
                              {(DQ ($ VSub_Name "$fixup_msg"))}
                            )
                          ]
                          spids: [3962 3963 4108 -1]
                        )
                      ]
                      spids: [3890 3898 4111]
                    )
                    (C {(record_in_rewritten)} {($ VSub_Name "$sha1")})
                  ]
                  spids: [3723 3730 4119 -1]
                )
                (case_arm
                  pat_list: [{(x)} {(DQ (exec))}]
                  action: [
                    (SimpleCommand
                      words: [{(read)} {(-r)} {(command)} {(rest)}]
                      redirects: [
                        (Redir
                          op_id: Redir_Less
                          fd: -1
                          arg_word: {(DQ ($ VSub_Name "$todo"))}
                          spids: [4138]
                        )
                      ]
                    )
                    (C {(mark_action_done)})
                    (C {(eval_gettextln)} 
                      {
                        (DQ ("Executing: ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (rest))
                      }
                    )
                    (C 
                      {
                        (DQ 
                          (BracedVarSub
                            token: <VSub_Name SHELL>
                            suffix_op: 
                              (StringUnary
                                op_id: VTest_ColonHyphen
                                arg_word: {("@SHELL_PATH@")}
                              )
                            spids: [4158 4162]
                          )
                        )
                      } {(-c)} {(DQ ($ VSub_Name "$rest"))}
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:status)
                          op: Equal
                          rhs: {($ VSub_QMark "$?")}
                          spids: [4175]
                        )
                      ]
                      spids: [4175]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(LhsName name:dirty) op:Equal rhs:{(f)} spids:[4183])]
                      spids: [4183]
                    )
                    (AndOr
                      children: [
                        (Subshell
                          child: 
                            (SimpleCommand
                              words: [{(require_clean_work_tree)} {(DQ (rebase))}]
                              redirects: [
                                (Redir
                                  op_id: Redir_Great
                                  fd: 2
                                  arg_word: {(/dev/null)}
                                  spids: [4194]
                                )
                              ]
                            )
                          spids: [4187 4196]
                        )
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:dirty)
                              op: Equal
                              rhs: {(t)}
                              spids: [4200]
                            )
                          ]
                          spids: [4200]
                        )
                      ]
                      op_id: Op_DPipe
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [(C {(test)} {(DQ ($ VSub_Name "$status"))} {(-ne)} {(0)})]
                          action: [
                            (C {(warn)} 
                              {
                                (DQ 
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(eval_gettext)} 
                                            {
                                              (DQ ("Execution failed: ") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\$">
                                                ) (rest)
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [4223 4231]
                                  )
                                )
                              }
                            )
                            (AndOr
                              children: [
                                (C {(test)} {(DQ ($ VSub_Name "$dirty"))} {(Lit_Other "=")} {(f)})
                                (C {(warn)} 
                                  {
                                    (DQ 
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (C {(gettext)} 
                                                {
                                                  (DQ 
                                                    (
"and made changes to the index and/or the working tree"
                                                    )
                                                  )
                                                }
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub "$(">
                                        spids: [4251 4257]
                                      )
                                    )
                                  }
                                )
                              ]
                              op_id: Op_DPipe
                            )
                            (C {(warn)} 
                              {
                                (DQ 
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(gettext)} 
                                            {
                                              (DQ ("You can fix the problem, and then run\n") ("\n") 
                                                ("\tgit rebase --continue")
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [4265 4274]
                                  )
                                )
                              }
                            )
                            (C {(warn)})
                            (If
                              arms: [
                                (if_arm
                                  cond: [(C {(test)} {($ VSub_Name "$status")} {(-eq)} {(127)})]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:status)
                                          op: Equal
                                          rhs: {(1)}
                                          spids: [4298]
                                        )
                                      ]
                                      spids: [4298]
                                    )
                                  ]
                                  spids: [-1 4295]
                                )
                              ]
                              spids: [-1 4302]
                            )
                            (C {(exit)} {(DQ ($ VSub_Name "$status"))})
                          ]
                          spids: [-1 4217]
                        )
                        (if_arm
                          cond: [(C {(test)} {(DQ ($ VSub_Name "$dirty"))} {(Lit_Other "=")} {(t)})]
                          action: [
                            (C {(warn)} 
                              {
                                (DQ 
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(eval_gettext)} 
                                            {
                                              (DQ ("Execution succeeded: ") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\$">
                                                ) ("rest\n") ("but left changes to the index and/or the working tree\n") 
                                                ("Commit or stash your changes, and then run\n") ("\n") ("\tgit rebase --continue")
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [4335 4348]
                                  )
                                )
                              }
                            )
                            (C {(warn)})
                            (C {(exit)} {(1)})
                          ]
                          spids: [4312 4325]
                        )
                      ]
                      spids: [-1 4360]
                    )
                  ]
                  spids: [4122 4127 4363 -1]
                )
                (case_arm
                  pat_list: [{(Lit_Other "*")}]
                  action: [
                    (C {(warn)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ ("Unknown command: ") 
                                        (EscapedLiteralPart
                                          token: <Lit_EscapedChar "\\$">
                                        ) ("command ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("sha1 ") 
                                        (EscapedLiteralPart
                                          token: <Lit_EscapedChar "\\$">
                                        ) (rest)
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [4373 4385]
                          )
                        )
                      }
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:fixtodo)
                          op: Equal
                          rhs: 
                            {
                              (DQ 
                                (CommandSubPart
                                  command_list: 
                                    (CommandList
                                      children: [
                                        (C {(gettext)} 
                                          {(DQ ("Please fix this using 'git rebase --edit-todo'."))}
                                        )
                                      ]
                                    )
                                  left_token: <Left_CommandSub "$(">
                                  spids: [4391 4397]
                                )
                              )
                            }
                          spids: [4389]
                        )
                      ]
                      spids: [4389]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (SimpleCommand
                              words: [
                                {(git)}
                                {(rev-parse)}
                                {(--verify)}
                                {(-q)}
                                {(DQ ($ VSub_Name "$sha1"))}
                              ]
                              redirects: [
                                (Redir
                                  op_id: Redir_Great
                                  fd: -1
                                  arg_word: {(/dev/null)}
                                  spids: [4415]
                                )
                              ]
                            )
                          ]
                          action: [
                            (C {(die_with_patch)} {($ VSub_Name "$sha1")} {(DQ ($ VSub_Name "$fixtodo"))})
                          ]
                          spids: [-1 4419]
                        )
                      ]
                      else_action: [(C {(die)} {(DQ ($ VSub_Name "$fixtodo"))})]
                      spids: [4431 4441]
                    )
                  ]
                  spids: [4366 4367 4444 -1]
                )
              ]
              spids: [3497 3503 4447]
            )
            (AndOr
              children: [
                (C {(test)} {(-s)} {(DQ ($ VSub_Name "$todo"))})
                (ControlFlow token:<ControlFlow_Return return>)
              ]
              op_id: Op_DAmp
            )
            (AndOr
              children: [
                (C {(comment_for_reflog)} {(finish)})
                (AndOr
                  children: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:newhead)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [(C {(git)} {(rev-parse)} {(HEAD)})]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [4472 4478]
                              )
                            }
                          spids: [4471]
                        )
                      ]
                      spids: [4471]
                    )
                    (AndOr
                      children: [
                        (Case
                          to_match: {($ VSub_Name "$head_name")}
                          arms: [
                            (case_arm
                              pat_list: [{(refs/) (Lit_Other "*")}]
                              action: [
                                (AndOr
                                  children: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:message)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$GIT_REFLOG_ACTION") (": ") 
                                                ($ VSub_Name "$head_name") (" onto ") ($ VSub_Name "$onto")
                                              )
                                            }
                                          spids: [4495]
                                        )
                                      ]
                                      spids: [4495]
                                    )
                                    (AndOr
                                      children: [
                                        (C {(git)} {(update-ref)} {(-m)} {(DQ ($ VSub_Name "$message"))} 
                                          {($ VSub_Name "$head_name")} {($ VSub_Name "$newhead")} {($ VSub_Name "$orig_head")}
                                        )
                                        (C {(git)} {(symbolic-ref)} {(-m)} 
                                          {
                                            (DQ ($ VSub_Name "$GIT_REFLOG_ACTION") (": returning to ") 
                                              ($ VSub_Name "$head_name")
                                            )
                                          } {(HEAD)} {($ VSub_Name "$head_name")}
                                        )
                                      ]
                                      op_id: Op_DAmp
                                    )
                                  ]
                                  op_id: Op_DAmp
                                )
                              ]
                              spids: [4490 4492 4547 -1]
                            )
                          ]
                          spids: [4483 4487 4550]
                        )
                        (AndOr
                          children: [
                            (BraceGroup
                              children: [
                                (AndOr
                                  children: [
                                    (C {(test)} {(KW_Bang "!")} {(-f)} 
                                      {(DQ ($ VSub_Name "$state_dir")) (/verbose)}
                                    )
                                    (C {(git)} {(diff-tree)} {(--stat)} 
                                      {($ VSub_Name "$orig_head") (..HEAD)}
                                    )
                                  ]
                                  op_id: Op_DPipe
                                )
                              ]
                              spids: [4554]
                            )
                            (AndOr
                              children: [
                                (BraceGroup
                                  children: [
                                    (AndOr
                                      children: [
                                        (C {(test)} {(-s)} {(DQ ($ VSub_Name "$rewritten_list"))})
                                        (AndOr
                                          children: [
                                            (SimpleCommand
                                              words: [
                                                {(git)}
                                                {(notes)}
                                                {(copy)}
                                                {(--for-rewrite) (Lit_Other "=") (rebase)}
                                              ]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_Less
                                                  fd: -1
                                                  arg_word: {(DQ ($ VSub_Name "$rewritten_list"))}
                                                  spids: [4610]
                                                )
                                              ]
                                            )
                                            (C {(true)})
                                          ]
                                          op_id: Op_DPipe
                                        )
                                      ]
                                      op_id: Op_DAmp
                                    )
                                  ]
                                  spids: [4586]
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:hook)
                                      op: Equal
                                      rhs: 
                                        {
                                          (DQ 
                                            (CommandSubPart
                                              command_list: 
                                                (CommandList
                                                  children: [
                                                    (C {(git)} {(rev-parse)} {(--git-path)} 
                                                      {(hooks/post-rewrite)}
                                                    )
                                                  ]
                                                )
                                              left_token: <Left_CommandSub "$(">
                                              spids: [4632 4640]
                                            )
                                          )
                                        }
                                      spids: [4630]
                                    )
                                  ]
                                  spids: [4630]
                                )
                              ]
                              op_id: Op_DAmp
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
            (AndOr
              children: [
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (Sentence
                          child: 
                            (AndOr
                              children: [
                                (C {(test)} {(-x)} {(DQ ($ VSub_Name "$hook"))})
                                (C {(test)} {(-s)} {(DQ ($ VSub_Name "$rewritten_list"))})
                              ]
                              op_id: Op_DAmp
                            )
                          terminator: <Op_Semi ";">
                        )
                      ]
                      action: [
                        (SimpleCommand
                          words: [{(DQ ($ VSub_Name "$hook"))} {(rebase)}]
                          redirects: [
                            (Redir
                              op_id: Redir_Less
                              fd: -1
                              arg_word: {(DQ ($ VSub_Name "$rewritten_list"))}
                              spids: [4674]
                            )
                          ]
                        )
                        (C {(true)})
                      ]
                      spids: [-1 4665]
                    )
                  ]
                  spids: [-1 4687]
                )
                (C {(warn)} 
                  {
                    (DQ 
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(eval_gettext)} 
                                {
                                  (DQ ("Successfully rebased and updated ") 
                                    (EscapedLiteralPart
                                      token: <Lit_EscapedChar "\\$">
                                    ) (head_name.)
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [4695 4703]
                      )
                    )
                  }
                )
              ]
              op_id: Op_DAmp
            )
            (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
          ]
          spids: [3451]
        )
      spids: [3446 3450]
    )
    (FuncDef
      name: do_rest
      body: 
        (BraceGroup
          children: [
            (While
              cond: [(C {(Lit_Other ":")})]
              body: 
                (DoGroup
                  children: [
                    (AndOr
                      children: [(C {(do_next)}) (ControlFlow token:<ControlFlow_Break break>)]
                      op_id: Op_DPipe
                    )
                  ]
                  spids: [4734 4744]
                )
            )
          ]
          spids: [4726]
        )
      spids: [4721 4725]
    )
    (FuncDef
      name: skip_unnecessary_picks
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:fd) op:Equal rhs:{(3)} spids:[4760])]
              spids: [4760]
            )
            (AndOr
              children: [
                (While
                  cond: [(C {(read)} {(-r)} {(command)} {(rest)})]
                  body: 
                    (DoGroup
                      children: [
                        (Case
                          to_match: {(DQ ($ VSub_Name "$fd") (",") ($ VSub_Name "$command"))}
                          arms: [
                            (case_arm
                              pat_list: [{(3) (Lit_Comma ",") (pick)} {(3) (Lit_Comma ",") (p)}]
                              action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:sha1)
                                      op: Equal
                                      rhs: 
                                        {
                                          (BracedVarSub
                                            token: <VSub_Name rest>
                                            suffix_op: 
                                              (StringUnary
                                                op_id: VOp1_DPercent
                                                arg_word: {(" *")}
                                              )
                                            spids: [4808 4812]
                                          )
                                        }
                                      spids: [4807]
                                    )
                                  ]
                                  spids: [4807]
                                )
                                (Case
                                  to_match: 
                                    {
                                      (DQ 
                                        (CommandSubPart
                                          command_list: 
                                            (CommandList
                                              children: [
                                                (C {(git)} {(rev-parse)} {(--verify)} {(--quiet)} 
                                                  {(DQ ($ VSub_Name "$sha1")) (Lit_Other "^")}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub "$(">
                                          spids: [4818 4831]
                                        )
                                      )
                                    }
                                  arms: [
                                    (case_arm
                                      pat_list: [{(DQ ($ VSub_Name "$onto")) (Lit_Other "*")}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:onto)
                                              op: Equal
                                              rhs: {($ VSub_Name "$sha1")}
                                              spids: [4844]
                                            )
                                          ]
                                          spids: [4844]
                                        )
                                      ]
                                      spids: [4838 4841 4848 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(Lit_Other "*")}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:fd)
                                              op: Equal
                                              rhs: {(1)}
                                              spids: [4855]
                                            )
                                          ]
                                          spids: [4855]
                                        )
                                      ]
                                      spids: [4851 4852 4859 -1]
                                    )
                                  ]
                                  spids: [4815 4834 4862]
                                )
                              ]
                              spids: [4793 4800 4865 -1]
                            )
                            (case_arm
                              pat_list: [
                                {(3) (Lit_Comma ",") (DQ ($ VSub_Name "$comment_char")) 
                                  (Lit_Other "*")
                                }
                                {(3) (Lit_Comma ",")}
                              ]
                              spids: [4868 4877 4884 -1]
                            )
                            (case_arm
                              pat_list: [{(Lit_Other "*")}]
                              action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:fd)
                                      op: Equal
                                      rhs: {(1)}
                                      spids: [4891]
                                    )
                                  ]
                                  spids: [4891]
                                )
                              ]
                              spids: [4887 4888 4895 -1]
                            )
                          ]
                          spids: [4782 4790 4898]
                        )
                        (SimpleCommand
                          words: [
                            {(printf)}
                            {(SQ <"%s\\n">)}
                            {
                              (DQ ($ VSub_Name "$command") 
                                (BracedVarSub
                                  token: <VSub_Name rest>
                                  suffix_op: (StringUnary op_id:VTest_ColonPlus arg_word:{(" ")})
                                  spids: [4909 4913]
                                ) ($ VSub_Name "$rest")
                              )
                            }
                          ]
                          redirects: [
                            (Redir
                              op_id: Redir_GreatAnd
                              fd: -1
                              arg_word: {($ VSub_Name "$fd")}
                              spids: [4917]
                            )
                          ]
                        )
                      ]
                      spids: [4775 4921]
                    )
                  redirects: [
                    (Redir
                      op_id: Redir_Less
                      fd: -1
                      arg_word: {(DQ ($ VSub_Name "$todo"))}
                      spids: [4923]
                    )
                    (Redir
                      op_id: Redir_Great
                      fd: -1
                      arg_word: {(DQ ($ VSub_Name "$todo") (.new))}
                      spids: [4928]
                    )
                    (Redir
                      op_id: Redir_DGreat
                      fd: 3
                      arg_word: {(DQ ($ VSub_Name "$done"))}
                      spids: [4934]
                    )
                  ]
                )
                (AndOr
                  children: [
                    (C {(mv)} {(-f)} {(DQ ($ VSub_Name "$todo")) (.new)} {(DQ ($ VSub_Name "$todo"))})
                    (AndOr
                      children: [
                        (Case
                          to_match: 
                            {
                              (DQ 
                                (CommandSubPart
                                  command_list: (CommandList children:[(C {(peek_next_command)})])
                                  left_token: <Left_CommandSub "$(">
                                  spids: [4961 4963]
                                )
                              )
                            }
                          arms: [
                            (case_arm
                              pat_list: [{(squash)} {(s)} {(fixup)} {(f)}]
                              action: [(C {(record_in_rewritten)} {(DQ ($ VSub_Name "$onto"))})]
                              spids: [4969 4976 4986 -1]
                            )
                          ]
                          spids: [4958 4966 4989]
                        )
                        (C {(die)} 
                          {
                            (DQ 
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(gettext)} {(DQ ("Could not skip unnecessary pick commands"))})
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [4997 5003]
                              )
                            )
                          }
                        )
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [4757]
        )
      spids: [4752 4756]
    )
    (FuncDef
      name: transform_todo_ids
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (While
                  cond: [(C {(read)} {(-r)} {(command)} {(rest)})]
                  body: 
                    (DoGroup
                      children: [
                        (Case
                          to_match: {(DQ ($ VSub_Name "$command"))}
                          arms: [
                            (case_arm
                              pat_list: [{(DQ ($ VSub_Name "$comment_char")) (Lit_Other "*")} {(exec)}]
                              spids: [5041 5048 5059 -1]
                            )
                            (case_arm
                              pat_list: [{(Lit_Other "*")}]
                              action: [
                                (AndOr
                                  children: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:sha1)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (C {(git)} {(rev-parse)} {(--verify)} {(--quiet)} 
                                                        {(DQ ($ VSub_At "$@"))} 
                                                        {
                                                          (BracedVarSub
                                                            token: <VSub_Name rest>
                                                            suffix_op: 
                                                              (StringUnary
                                                                op_id: VOp1_DPercent
                                                                arg_word: {("[\t ]*")}
                                                              )
                                                            spids: [5080 5084]
                                                          )
                                                        }
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_CommandSub "$(">
                                                spids: [5067 5085]
                                              )
                                            }
                                          spids: [5066]
                                        )
                                      ]
                                      spids: [5066]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:rest)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$sha1") (" ") 
                                                (BracedVarSub
                                                  token: <VSub_Name rest>
                                                  suffix_op: 
                                                    (StringUnary
                                                      op_id: VOp1_Pound
                                                      arg_word: {("*[\t ]")}
                                                    )
                                                  spids: [5094 5098]
                                                )
                                              )
                                            }
                                          spids: [5090]
                                        )
                                      ]
                                      spids: [5090]
                                    )
                                  ]
                                  op_id: Op_DAmp
                                )
                              ]
                              spids: [5062 5063 5102 -1]
                            )
                          ]
                          spids: [5031 5037 5105]
                        )
                        (C {(printf)} {(SQ <"%s\\n">)} 
                          {
                            (DQ ($ VSub_Name "$command") 
                              (BracedVarSub
                                token: <VSub_Name rest>
                                suffix_op: (StringUnary op_id:VTest_ColonPlus arg_word:{(" ")})
                                spids: [5116 5120]
                              ) ($ VSub_Name "$rest")
                            )
                          }
                        )
                      ]
                      spids: [5028 5125]
                    )
                  redirects: [
                    (Redir
                      op_id: Redir_Less
                      fd: -1
                      arg_word: {(DQ ($ VSub_Name "$todo"))}
                      spids: [5127]
                    )
                    (Redir
                      op_id: Redir_Great
                      fd: -1
                      arg_word: {(DQ ($ VSub_Name "$todo") (.new))}
                      spids: [5132]
                    )
                  ]
                )
                (C {(mv)} {(-f)} {(DQ ($ VSub_Name "$todo") (.new))} {(DQ ($ VSub_Name "$todo"))})
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [5014]
        )
      spids: [5009 5013]
    )
    (FuncDef
      name: expand_todo_ids
      body: (BraceGroup children:[(C {(transform_todo_ids)})] spids:[5161])
      spids: [5157 5160]
    )
    (FuncDef
      name: collapse_todo_ids
      body: (BraceGroup children:[(C {(transform_todo_ids)} {(--short)})] spids:[5173])
      spids: [5169 5172]
    )
    (FuncDef
      name: rearrange_squash
      body: 
        (BraceGroup
          children: [
            (While
              cond: [(C {(read)} {(-r)} {(pick)} {(sha1)} {(message)})]
              body: 
                (DoGroup
                  children: [
                    (AndOr
                      children: [
                        (C {(test)} {(-z)} {(DQ (${ VSub_Name format))})
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:message)
                              op: Equal
                              rhs: 
                                {
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(git)} {(log)} {(-n)} {(1)} 
                                            {(--format) (Lit_Other "=") (DQ ("%s"))} {(${ VSub_Name sha1)}
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [5248 5266]
                                  )
                                }
                              spids: [5247]
                            )
                          ]
                          spids: [5247]
                        )
                      ]
                      op_id: Op_DPipe
                    )
                    (Case
                      to_match: {(DQ ($ VSub_Name "$message"))}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(DQ ("squash! ")) (Lit_Other "*")}
                            {(DQ ("fixup! ")) (Lit_Other "*")}
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:action)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (BracedVarSub
                                          token: <VSub_Name message>
                                          suffix_op: 
                                            (StringUnary
                                              op_id: VOp1_DPercent
                                              arg_word: {("!*")}
                                            )
                                          spids: [5292 5296]
                                        )
                                      )
                                    }
                                  spids: [5290]
                                )
                              ]
                              spids: [5290]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:rest)
                                  op: Equal
                                  rhs: {($ VSub_Name "$message")}
                                  spids: [5300]
                                )
                              ]
                              spids: [5300]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:prefix)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [5304]
                                )
                              ]
                              spids: [5304]
                            )
                            (While
                              cond: [(C {(Lit_Other ":")})]
                              body: 
                                (DoGroup
                                  children: [
                                    (Case
                                      to_match: {(DQ ($ VSub_Name "$rest"))}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(DQ ("squash! ")) (Lit_Other "*")}
                                            {(DQ ("fixup! ")) (Lit_Other "*")}
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:prefix)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$prefix") 
                                                        (BracedVarSub
                                                          token: <VSub_Name rest>
                                                          suffix_op: 
                                                            (StringUnary
                                                              op_id: VOp1_DPercent
                                                              arg_word: {("!*")}
                                                            )
                                                          spids: [5343 5347]
                                                        ) (",")
                                                      )
                                                    }
                                                  spids: [5340]
                                                )
                                              ]
                                              spids: [5340]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:rest)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (BracedVarSub
                                                          token: <VSub_Name rest>
                                                          suffix_op: 
                                                            (StringUnary
                                                              op_id: VOp1_Pound
                                                              arg_word: {("*! ")}
                                                            )
                                                          spids: [5354 5358]
                                                        )
                                                      )
                                                    }
                                                  spids: [5352]
                                                )
                                              ]
                                              spids: [5352]
                                            )
                                          ]
                                          spids: [5329 5337 5362 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*")}]
                                          action: [(ControlFlow token:<ControlFlow_Break break>)]
                                          spids: [5365 5366 5372 -1]
                                        )
                                      ]
                                      spids: [5319 5325 5375]
                                    )
                                  ]
                                  spids: [5316 5378]
                                )
                            )
                            (C {(printf)} {(SQ <"%s %s %s %s\\n">)} {(DQ ($ VSub_Name "$sha1"))} 
                              {(DQ ($ VSub_Name "$action"))} {(DQ ($ VSub_Name "$prefix"))} {(DQ ($ VSub_Name "$rest"))}
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(test)} 
                                          {
                                            (DQ 
                                              (BracedVarSub
                                                token: <VSub_Name rest>
                                                suffix_op: 
                                                  (StringUnary
                                                    op_id: VOp1_Pound
                                                    arg_word: {("* ")}
                                                  )
                                                spids: [5421 5425]
                                              )
                                            )
                                          } {(Lit_Other "=")} {(DQ ($ VSub_Name "$rest"))}
                                        )
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:fullsha)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (CommandSubPart
                                                  command_list: 
                                                    (CommandList
                                                      children: [
                                                        (SimpleCommand
                                                          words: [
                                                            {(git)}
                                                            {(rev-parse)}
                                                            {(-q)}
                                                            {(--verify)}
                                                            {(DQ ($ VSub_Name "$rest"))}
                                                          ]
                                                          redirects: [
                                                            (Redir
                                                              op_id: Redir_Great
                                                              fd: 2
                                                              arg_word: {(/dev/null)}
                                                              spids: [5453]
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                  left_token: <Left_CommandSub "$(">
                                                  spids: [5440 5455]
                                                )
                                              )
                                            }
                                          spids: [5438]
                                        )
                                      ]
                                      spids: [5438]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Sentence
                                              child: (C {(test)} {(-n)} {(DQ ($ VSub_Name "$fullsha"))})
                                              terminator: <Op_Semi ";">
                                            )
                                          ]
                                          action: [
                                            (C {(echo)} 
                                              {
                                                (DQ ($ VSub_Name "$sha1") (" +") 
                                                  ($ VSub_Name "$action") (" ") ($ VSub_Name "$prefix") (" ") ($ VSub_Name "$fullsha")
                                                )
                                              }
                                            )
                                          ]
                                          spids: [-1 5470]
                                        )
                                      ]
                                      spids: [-1 5494]
                                    )
                                  ]
                                  spids: [-1 5435]
                                )
                              ]
                              spids: [-1 5497]
                            )
                          ]
                          spids: [5279 5287 -1 5500]
                        )
                      ]
                      spids: [5269 5275 5500]
                    )
                  ]
                  spids: [5232 5503]
                )
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {(DQ ($ VSub_Number "$1") (.sq))}
                  spids: [5505]
                )
                (Redir
                  op_id: Redir_Less
                  fd: -1
                  arg_word: {(DQ ($ VSub_Number "$1"))}
                  spids: [5511]
                )
              ]
            )
            (AndOr
              children: [
                (C {(test)} {(-s)} {(DQ ($ VSub_Number "$1") (.sq))})
                (ControlFlow token:<ControlFlow_Return return>)
              ]
              op_id: Op_DPipe
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:used) op:Equal rhs:{(SQ )} spids:[5532])]
              spids: [5532]
            )
            (While
              cond: [(C {(read)} {(-r)} {(pick)} {(sha1)} {(message)})]
              body: 
                (DoGroup
                  children: [
                    (Case
                      to_match: {(DQ (" ") ($ VSub_Name "$used"))}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(Lit_Other "*") (DQ (" ") ($ VSub_Name "$sha1") (" ")) (Lit_Other "*")}
                          ]
                          action: [(ControlFlow token:<ControlFlow_Continue continue>)]
                          spids: [5561 5568 5572 -1]
                        )
                      ]
                      spids: [5551 5558 5575]
                    )
                    (C {(printf)} {(SQ <"%s\\n">)} 
                      {
                        (DQ ($ VSub_Name "$pick") (" ") ($ VSub_Name "$sha1") (" ") 
                          ($ VSub_Name "$message")
                        )
                      }
                    )
                    (AndOr
                      children: [
                        (C {(test)} {(-z)} {(DQ (${ VSub_Name format))})
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:message)
                              op: Equal
                              rhs: 
                                {
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(git)} {(log)} {(-n)} {(1)} 
                                            {(--format) (Lit_Other "=") (DQ ("%s"))} {(${ VSub_Name sha1)}
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [5606 5624]
                                  )
                                }
                              spids: [5605]
                            )
                          ]
                          spids: [5605]
                        )
                      ]
                      op_id: Op_DPipe
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:used)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$used") ($ VSub_Name "$sha1") (" "))}
                          spids: [5627]
                        )
                      ]
                      spids: [5627]
                    )
                    (While
                      cond: [(C {(read)} {(-r)} {(squash)} {(action)} {(msg_prefix)} {(msg_content)})]
                      body: 
                        (DoGroup
                          children: [
                            (Case
                              to_match: {(DQ (" ") ($ VSub_Name "$used"))}
                              arms: [
                                (case_arm
                                  pat_list: [
                                    {(Lit_Other "*") (DQ (" ") ($ VSub_Name "$squash") (" ")) 
                                      (Lit_Other "*")
                                    }
                                  ]
                                  action: [(ControlFlow token:<ControlFlow_Continue continue>)]
                                  spids: [5663 5670 5674 -1]
                                )
                              ]
                              spids: [5653 5660 5677]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:emit)
                                  op: Equal
                                  rhs: {(0)}
                                  spids: [5680]
                                )
                              ]
                              spids: [5680]
                            )
                            (Case
                              to_match: {(DQ ($ VSub_Name "$action"))}
                              arms: [
                                (case_arm
                                  pat_list: [{(Lit_Other "+") (Lit_Other "*")}]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:action)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (BracedVarSub
                                                  token: <VSub_Name action>
                                                  suffix_op: 
                                                    (StringUnary
                                                      op_id: VOp1_Pound
                                                      arg_word: {("+")}
                                                    )
                                                  spids: [5700 5704]
                                                )
                                              )
                                            }
                                          spids: [5698]
                                        )
                                      ]
                                      spids: [5698]
                                    )
                                    (Case
                                      to_match: {(DQ ($ VSub_Name "$msg_content"))}
                                      arms: [
                                        (case_arm
                                          pat_list: [{(DQ ($ VSub_Name "$sha1")) (Lit_Other "*")}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:emit)
                                                  op: Equal
                                                  rhs: {(1)}
                                                  spids: [5726]
                                                )
                                              ]
                                              spids: [5726]
                                            )
                                          ]
                                          spids: [5721 5724 5728 -1]
                                        )
                                      ]
                                      spids: [5712 5718 5730]
                                    )
                                  ]
                                  spids: [5693 5695 5732 -1]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Other "*")}]
                                  action: [
                                    (Case
                                      to_match: {(DQ ($ VSub_Name "$message"))}
                                      arms: [
                                        (case_arm
                                          pat_list: [
                                            {(DQ ($ VSub_Name "$msg_content")) (Lit_Other "*")}
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:emit)
                                                  op: Equal
                                                  rhs: {(1)}
                                                  spids: [5757]
                                                )
                                              ]
                                              spids: [5757]
                                            )
                                          ]
                                          spids: [5752 5755 5759 -1]
                                        )
                                      ]
                                      spids: [5743 5749 5761]
                                    )
                                  ]
                                  spids: [5735 5736 5763 -1]
                                )
                              ]
                              spids: [5684 5690 5766]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Sentence
                                      child: 
                                        (C {(test)} {($ VSub_Name "$emit")} {(Lit_Other "=")} {(1)})
                                      terminator: <Op_Semi ";">
                                    )
                                  ]
                                  action: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [(C {(test)} {(-n)} {(DQ (${ VSub_Name format))})]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:msg_content)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (CommandSubPart
                                                        command_list: 
                                                          (CommandList
                                                            children: [
                                                              (C {(git)} {(log)} {(-n)} {(1)} 
                                                                {(--format) (Lit_Other "=") 
                                                                  (DQ (${ VSub_Name format))
                                                                } {(${ VSub_Name squash)}
                                                              )
                                                            ]
                                                          )
                                                        left_token: <Left_CommandSub "$(">
                                                        spids: [5800 5820]
                                                      )
                                                    }
                                                  spids: [5799]
                                                )
                                              ]
                                              spids: [5799]
                                            )
                                          ]
                                          spids: [-1 5796]
                                        )
                                      ]
                                      else_action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:msg_content)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ 
                                                    (CommandSubPart
                                                      command_list: 
                                                        (CommandList
                                                          children: [
                                                            (Pipeline
                                                              children: [
                                                                (C {(echo)} 
                                                                  {(DQ ($ VSub_Name "$msg_prefix"))}
                                                                )
                                                                (C {(sed)} {(DQ ("s/,/! /g"))})
                                                              ]
                                                              negated: False
                                                            )
                                                          ]
                                                        )
                                                      left_token: <Left_CommandSub "$(">
                                                      spids: [5828 5842]
                                                    ) ($ VSub_Name "$msg_content")
                                                  )
                                                }
                                              spids: [5826]
                                            )
                                          ]
                                          spids: [5826]
                                        )
                                      ]
                                      spids: [5823 5847]
                                    )
                                    (C {(printf)} {(SQ <"%s\\n">)} 
                                      {
                                        (DQ ($ VSub_Name "$action") (" ") ($ VSub_Name "$squash") (" ") 
                                          ($ VSub_Name "$msg_content")
                                        )
                                      }
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:used)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ ($ VSub_Name "$used") ($ VSub_Name "$squash") (" "))
                                            }
                                          spids: [5865]
                                        )
                                      ]
                                      spids: [5865]
                                    )
                                  ]
                                  spids: [-1 5780]
                                )
                              ]
                              spids: [-1 5873]
                            )
                          ]
                          spids: [5650 5876]
                        )
                      redirects: [
                        (Redir
                          op_id: Redir_Less
                          fd: -1
                          arg_word: {(DQ ($ VSub_Number "$1") (.sq))}
                          spids: [5878]
                        )
                      ]
                    )
                  ]
                  spids: [5548 5885]
                )
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {(DQ ($ VSub_Number "$1") (.rearranged))}
                  spids: [5887]
                )
                (Redir
                  op_id: Redir_Less
                  fd: -1
                  arg_word: {(DQ ($ VSub_Number "$1"))}
                  spids: [5893]
                )
              ]
            )
            (SimpleCommand
              words: [{(cat)} {(DQ ($ VSub_Number "$1") (.rearranged))}]
              redirects: [
                (Redir
                  op_id: Redir_Great
                  fd: -1
                  arg_word: {(DQ ($ VSub_Number "$1"))}
                  spids: [5906]
                )
              ]
            )
            (C {(rm)} {(-f)} {(DQ ($ VSub_Number "$1") (.sq))} {(DQ ($ VSub_Number "$1") (.rearranged))})
          ]
          spids: [5212]
        )
      spids: [5207 5211]
    )
    (FuncDef
      name: add_exec_commands
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (BraceGroup
                  children: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(LhsName name:first) op:Equal rhs:{(t)} spids:[5946])]
                      spids: [5946]
                    )
                    (While
                      cond: [(C {(read)} {(-r)} {(insn)} {(rest)})]
                      body: 
                        (DoGroup
                          children: [
                            (Case
                              to_match: {($ VSub_Name "$insn")}
                              arms: [
                                (case_arm
                                  pat_list: [{(pick)}]
                                  action: [
                                    (AndOr
                                      children: [
                                        (C {(test)} {(-n)} {(DQ ($ VSub_Name "$first"))})
                                        (C {(printf)} {(DQ ("%s"))} {(DQ ($ VSub_Name "$cmd"))})
                                      ]
                                      op_id: Op_DPipe
                                    )
                                  ]
                                  spids: [5971 5972 5997 -1]
                                )
                              ]
                              spids: [5964 5968 6000]
                            )
                            (C {(printf)} 
                              {(DQ ("%s %s") (EscapedLiteralPart token:<Lit_EscapedChar "\\n">))} {(DQ ($ VSub_Name "$insn"))} {(DQ ($ VSub_Name "$rest"))}
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:first)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [6019]
                                )
                              ]
                              spids: [6019]
                            )
                          ]
                          spids: [5961 6022]
                        )
                    )
                    (C {(printf)} {(DQ ("%s"))} {(DQ ($ VSub_Name "$cmd"))})
                  ]
                  redirects: [
                    (Redir
                      op_id: Redir_Less
                      fd: -1
                      arg_word: {(DQ ($ VSub_Number "$1"))}
                      spids: [6038]
                    )
                    (Redir
                      op_id: Redir_Great
                      fd: -1
                      arg_word: {(DQ ($ VSub_Number "$1") (.new))}
                      spids: [6043]
                    )
                  ]
                  spids: [5943]
                )
                (C {(mv)} {(DQ ($ VSub_Number "$1") (.new))} {(DQ ($ VSub_Number "$1"))})
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [5940]
        )
      spids: [5935 5939]
    )
    (FuncDef
      name: check_commit_sha
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:badsha) op:Equal rhs:{(0)} spids:[6089])]
              spids: [6089]
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Number "$1"))})]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(LhsName name:badsha) op:Equal rhs:{(1)} spids:[6107])]
                      spids: [6107]
                    )
                  ]
                  spids: [-1 6104]
                )
              ]
              else_action: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:sha1_verif)
                      op: Equal
                      rhs: 
                        {
                          (DQ 
                            (CommandSubPart
                              command_list: 
                                (CommandList
                                  children: [
                                    (C {(git)} {(rev-parse)} {(--verify)} {(--quiet)} 
                                      {($ VSub_Number "$1") (Lit_Other "^") (Lit_LBrace "{") (commit) 
                                        (Lit_RBrace "}")
                                      }
                                    )
                                  ]
                                )
                              left_token: <Left_CommandSub "$(">
                              spids: [6116 6130]
                            )
                          )
                        }
                      spids: [6114]
                    )
                  ]
                  spids: [6114]
                )
                (If
                  arms: [
                    (if_arm
                      cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$sha1_verif"))})]
                      action: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:badsha)
                              op: Equal
                              rhs: {(1)}
                              spids: [6148]
                            )
                          ]
                          spids: [6148]
                        )
                      ]
                      spids: [-1 6145]
                    )
                  ]
                  spids: [-1 6152]
                )
              ]
              spids: [6111 6155]
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {($ VSub_Name "$badsha")} {(-ne)} {(0)})]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:line)
                          op: Equal
                          rhs: 
                            {
                              (DQ 
                                (CommandSubPart
                                  command_list: 
                                    (CommandList
                                      children: [
                                        (C {(sed)} {(-n)} {(-e)} {(DQ (${ VSub_Number 2) (p))} 
                                          {(DQ ($ VSub_Number "$3"))}
                                        )
                                      ]
                                    )
                                  left_token: <Left_CommandSub "$(">
                                  spids: [6175 6192]
                                )
                              )
                            }
                          spids: [6173]
                        )
                      ]
                      spids: [6173]
                    )
                    (C {(warn)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ 
                                        (
"Warning: the SHA-1 is missing or isn't a commit in the following line:\n"
                                        ) (" - ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (line)
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [6199 6209]
                          )
                        )
                      }
                    )
                    (C {(warn)})
                  ]
                  spids: [-1 6170]
                )
              ]
              spids: [-1 6216]
            )
            (ControlFlow
              token: <ControlFlow_Return return>
              arg_word: {($ VSub_Name "$badsha")}
            )
          ]
          spids: [6086]
        )
      spids: [6081 6085]
    )
    (FuncDef
      name: check_bad_cmd_and_sha
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:retval) op:Equal rhs:{(0)} spids:[6241])]
              spids: [6241]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:lineno) op:Equal rhs:{(0)} spids:[6245])]
              spids: [6245]
            )
            (While
              cond: [(C {(read)} {(-r)} {(command)} {(rest)})]
              body: 
                (DoGroup
                  children: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:lineno)
                          op: Equal
                          rhs: 
                            {
                              (ArithSubPart
                                anode: 
                                  (ArithBinary
                                    op_id: Arith_Plus
                                    left: (ArithWord w:{($ VSub_Name "$lineno")})
                                    right: (ArithWord w:{(Lit_Digits 1)})
                                  )
                                spids: [6264 6273]
                              )
                            }
                          spids: [6263]
                        )
                      ]
                      spids: [6263]
                    )
                    (Case
                      to_match: {($ VSub_Name "$command")}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(DQ ($ VSub_Name "$comment_char")) (Lit_Other "*")}
                            {(SQ )}
                            {(noop)}
                            {(x)}
                            {(exec)}
                          ]
                          spids: [6284 6296 6303 -1]
                        )
                        (case_arm
                          pat_list: [{(DQ ($ VSub_Name "$cr"))}]
                          spids: [6307 6309 6320 -1]
                        )
                        (case_arm
                          pat_list: [
                            {(pick)}
                            {(p)}
                            {(drop)}
                            {(d)}
                            {(reword)}
                            {(r)}
                            {(edit)}
                            {(e)}
                            {(squash)}
                            {(s)}
                            {(fixup)}
                            {(f)}
                          ]
                          action: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Pipeline
                                      children: [
                                        (C {(check_commit_sha)} 
                                          {
                                            (DQ 
                                              (BracedVarSub
                                                token: <VSub_Name rest>
                                                suffix_op: 
                                                  (StringUnary
                                                    op_id: VOp1_DPercent
                                                    arg_word: {("[ \t]*")}
                                                  )
                                                spids: [6356 6360]
                                              )
                                            )
                                          } {(DQ ($ VSub_Name "$lineno"))} {(DQ ($ VSub_Number "$1"))}
                                        )
                                      ]
                                      negated: True
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:retval)
                                          op: Equal
                                          rhs: {(1)}
                                          spids: [6375]
                                        )
                                      ]
                                      spids: [6375]
                                    )
                                  ]
                                  spids: [-1 6372]
                                )
                              ]
                              spids: [-1 6379]
                            )
                          ]
                          spids: [6323 6346 6382 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:line)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (CommandSubPart
                                          command_list: 
                                            (CommandList
                                              children: [
                                                (C {(sed)} {(-n)} {(-e)} {(DQ (${ VSub_Name lineno) (p))} 
                                                  {(DQ ($ VSub_Number "$1"))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub "$(">
                                          spids: [6391 6408]
                                        )
                                      )
                                    }
                                  spids: [6389]
                                )
                              ]
                              spids: [6389]
                            )
                            (C {(warn)} 
                              {
                                (DQ 
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(eval_gettext)} 
                                            {
                                              (DQ 
                                                (
"Warning: the command isn't recognized in the following line:\n"
                                                ) (" - ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (line)
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [6415 6425]
                                  )
                                )
                              }
                            )
                            (C {(warn)})
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:retval)
                                  op: Equal
                                  rhs: {(1)}
                                  spids: [6432]
                                )
                              ]
                              spids: [6432]
                            )
                          ]
                          spids: [6385 6386 6436 -1]
                        )
                      ]
                      spids: [6276 6280 6439]
                    )
                  ]
                  spids: [6260 6442]
                )
              redirects: [
                (Redir
                  op_id: Redir_Less
                  fd: -1
                  arg_word: {(DQ ($ VSub_Number "$1"))}
                  spids: [6444]
                )
              ]
            )
            (ControlFlow
              token: <ControlFlow_Return return>
              arg_word: {($ VSub_Name "$retval")}
            )
          ]
          spids: [6238]
        )
      spids: [6233 6237]
    )
    (FuncDef
      name: todo_list_to_sha_list
      body: 
        (BraceGroup
          children: [
            (Pipeline
              children: [
                (C {(git)} {(stripspace)} {(--strip-comments)})
                (While
                  cond: [(C {(read)} {(-r)} {(command)} {(sha1)} {(rest)})]
                  body: 
                    (DoGroup
                      children: [
                        (Case
                          to_match: {($ VSub_Name "$command")}
                          arms: [
                            (case_arm
                              pat_list: [
                                {(DQ ($ VSub_Name "$comment_char")) (Lit_Other "*")}
                                {(SQ )}
                                {(noop)}
                                {(x)}
                                {(DQ (exec))}
                              ]
                              spids: [6504 6518 6521 -1]
                            )
                            (case_arm
                              pat_list: [{(Lit_Other "*")}]
                              action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:long_sha)
                                      op: Equal
                                      rhs: 
                                        {
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (SimpleCommand
                                                    words: [
                                                      {(git)}
                                                      {(rev-list)}
                                                      {(--no-walk)}
                                                      {(DQ ($ VSub_Name "$sha1"))}
                                                    ]
                                                    redirects: [
                                                      (Redir
                                                        op_id: Redir_Great
                                                        fd: 2
                                                        arg_word: {(/dev/null)}
                                                        spids: [6540]
                                                      )
                                                    ]
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub "$(">
                                            spids: [6529 6542]
                                          )
                                        }
                                      spids: [6528]
                                    )
                                  ]
                                  spids: [6528]
                                )
                                (C {(printf)} 
                                  {(DQ ("%s") (EscapedLiteralPart token:<Lit_EscapedChar "\\n">))} {(DQ ($ VSub_Name "$long_sha"))}
                                )
                              ]
                              spids: [6524 6525 6557 -1]
                            )
                          ]
                          spids: [6496 6500 6560]
                        )
                      ]
                      spids: [6493 6563]
                    )
                )
              ]
              negated: False
            )
          ]
          spids: [6468]
        )
      spids: [6463 6467]
    )
    (FuncDef
      name: warn_lines
      body: 
        (BraceGroup
          children: [
            (While
              cond: [(C {(read)} {(-r)} {(line)})]
              body: 
                (DoGroup
                  children: [(C {(warn)} {(DQ (" - ") ($ VSub_Name "$line"))})]
                  spids: [6588 6599]
                )
            )
          ]
          spids: [6576]
        )
      spids: [6571 6575]
    )
    (FuncDef
      name: checkout_onto
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:GIT_REFLOG_ACTION)
                  op: Equal
                  rhs: 
                    {
                      (DQ ($ VSub_Name "$GIT_REFLOG_ACTION") (": checkout ") ($ VSub_Name "$onto_name"))
                    }
                  spids: [6615]
                )
              ]
              spids: [6615]
            )
            (AndOr
              children: [
                (C {(output)} {(git)} {(checkout)} {($ VSub_Name "$onto")})
                (C {(die_abort)} 
                  {
                    (DQ 
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [(C {(gettext)} {(DQ ("could not detach HEAD"))})]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [6636 6642]
                      )
                    )
                  }
                )
              ]
              op_id: Op_DPipe
            )
            (C {(git)} {(update-ref)} {(ORIG_HEAD)} {($ VSub_Name "$orig_head")})
          ]
          spids: [6612]
        )
      spids: [6607 6611]
    )
    (FuncDef
      name: get_missing_commit_check_level
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:check_level)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [(C {(git)} {(config)} {(--get)} {(rebase.missingCommitsCheck)})]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [6666 6674]
                      )
                    }
                  spids: [6665]
                )
              ]
              spids: [6665]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:check_level)
                  op: Equal
                  rhs: 
                    {
                      (BracedVarSub
                        token: <VSub_Name check_level>
                        suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{(ignore)})
                        spids: [6678 6682]
                      )
                    }
                  spids: [6677]
                )
              ]
              spids: [6677]
            )
            (Pipeline
              children: [
                (C {(printf)} {(SQ <"%s">)} {(DQ ($ VSub_Name "$check_level"))})
                (C {(tr)} {(SQ <A-Z>)} {(SQ <a-z>)})
              ]
              negated: False
            )
          ]
          spids: [6662]
        )
      spids: [6657 6661]
    )
    (FuncDef
      name: check_todo_list
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:raise_error) op:Equal rhs:{(f)} spids:[6734])]
              spids: [6734]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:check_level)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: (CommandList children:[(C {(get_missing_commit_check_level)})])
                        left_token: <Left_CommandSub "$(">
                        spids: [6740 6742]
                      )
                    }
                  spids: [6739]
                )
              ]
              spids: [6739]
            )
            (Case
              to_match: {(DQ ($ VSub_Name "$check_level"))}
              arms: [
                (case_arm
                  pat_list: [{(warn)} {(error)}]
                  action: [
                    (SimpleCommand
                      words: [{(todo_list_to_sha_list)}]
                      redirects: [
                        (Redir
                          op_id: Redir_Less
                          fd: -1
                          arg_word: {(DQ ($ VSub_Name "$todo")) (.backup)}
                          spids: [6767]
                        )
                        (Redir
                          op_id: Redir_Great
                          fd: -1
                          arg_word: {(DQ ($ VSub_Name "$todo")) (.oldsha1)}
                          spids: [6773]
                        )
                      ]
                    )
                    (SimpleCommand
                      words: [{(todo_list_to_sha_list)}]
                      redirects: [
                        (Redir
                          op_id: Redir_Less
                          fd: -1
                          arg_word: {(DQ ($ VSub_Name "$todo"))}
                          spids: [6782]
                        )
                        (Redir
                          op_id: Redir_Great
                          fd: -1
                          arg_word: {(DQ ($ VSub_Name "$todo")) (.newsha1)}
                          spids: [6787]
                        )
                      ]
                    )
                    (SimpleCommand
                      words: [{(sort)} {(-u)} {(DQ ($ VSub_Name "$todo")) (.oldsha1)}]
                      redirects: [
                        (Redir
                          op_id: Redir_Great
                          fd: -1
                          arg_word: {(DQ ($ VSub_Name "$todo")) (.oldsha1) (Lit_Other "+")}
                          spids: [6808]
                        )
                      ]
                    )
                    (C {(mv)} {(DQ ($ VSub_Name "$todo")) (.oldsha1) (Lit_Other "+")} 
                      {(DQ ($ VSub_Name "$todo")) (.oldsha1)}
                    )
                    (SimpleCommand
                      words: [{(sort)} {(-u)} {(DQ ($ VSub_Name "$todo")) (.newsha1)}]
                      redirects: [
                        (Redir
                          op_id: Redir_Great
                          fd: -1
                          arg_word: {(DQ ($ VSub_Name "$todo")) (.newsha1) (Lit_Other "+")}
                          spids: [6839]
                        )
                      ]
                    )
                    (C {(mv)} {(DQ ($ VSub_Name "$todo")) (.newsha1) (Lit_Other "+")} 
                      {(DQ ($ VSub_Name "$todo")) (.newsha1)}
                    )
                    (SimpleCommand
                      words: [
                        {(comm)}
                        {(-2)}
                        {(-3)}
                        {(DQ ($ VSub_Name "$todo")) (.oldsha1)}
                        {(DQ ($ VSub_Name "$todo")) (.newsha1)}
                      ]
                      redirects: [
                        (Redir
                          op_id: Redir_Great
                          fd: -1
                          arg_word: {(DQ ($ VSub_Name "$todo")) (.miss)}
                          spids: [6877]
                        )
                      ]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [(C {(test)} {(-s)} {(DQ ($ VSub_Name "$todo")) (.miss)})]
                          action: [
                            (AndOr
                              children: [
                                (C {(test)} {(DQ ($ VSub_Name "$check_level"))} {(Lit_Other "=")} 
                                  {(error)}
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:raise_error)
                                      op: Equal
                                      rhs: {(t)}
                                      spids: [6916]
                                    )
                                  ]
                                  spids: [6916]
                                )
                              ]
                              op_id: Op_DAmp
                            )
                            (C {(warn)} 
                              {
                                (DQ 
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(gettext)} 
                                            {
                                              (DQ 
                                                (
"Warning: some commits may have been dropped accidentally.\n"
                                                ) ("Dropped commits (newer to older):")
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [6924 6932]
                                  )
                                )
                              }
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:opt)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (
"--no-walk=sorted --format=oneline --abbrev-commit --stdin"
                                        )
                                      )
                                    }
                                  spids: [6941]
                                )
                              ]
                              spids: [6941]
                            )
                            (Pipeline
                              children: [
                                (SimpleCommand
                                  words: [{(git)} {(rev-list)} {($ VSub_Name "$opt")}]
                                  redirects: [
                                    (Redir
                                      op_id: Redir_Less
                                      fd: -1
                                      arg_word: {(DQ ($ VSub_Name "$todo")) (.miss)}
                                      spids: [6953]
                                    )
                                  ]
                                )
                                (C {(warn_lines)})
                              ]
                              negated: False
                            )
                            (C {(warn)} 
                              {
                                (DQ 
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(gettext)} 
                                            {
                                              (DQ ("To avoid this message, use ") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\\"">
                                                ) (drop) (EscapedLiteralPart token:<Lit_EscapedChar "\\\"">) (" to explicitly remove a commit.\n") ("\n") 
                                                (
"Use 'git config rebase.missingCommitsCheck' to change the level of warnings.\n"
                                                ) ("The possible behaviours are: ignore, warn, error.")
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [6968 6982]
                                  )
                                )
                              }
                            )
                            (C {(warn)})
                          ]
                          spids: [-1 6901]
                        )
                      ]
                      spids: [-1 6989]
                    )
                  ]
                  spids: [6755 6758 6992 -1]
                )
                (case_arm pat_list:[{(ignore)}] spids:[699569966999-1])
                (case_arm
                  pat_list: [{(Lit_Other "*")}]
                  action: [
                    (C {(warn)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ ("Unrecognized setting ") 
                                        (EscapedLiteralPart
                                          token: <Lit_EscapedChar "\\$">
                                        ) ("check_level for option rebase.missingCommitsCheck. Ignoring.")
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [7009 7017]
                          )
                        )
                      }
                    )
                  ]
                  spids: [7002 7003 7021 -1]
                )
              ]
              spids: [6746 6752 7024]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Pipeline
                      children: [(C {(check_bad_cmd_and_sha)} {(DQ ($ VSub_Name "$todo"))})]
                      negated: True
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:raise_error)
                          op: Equal
                          rhs: {(t)}
                          spids: [7042]
                        )
                      ]
                      spids: [7042]
                    )
                  ]
                  spids: [-1 7039]
                )
              ]
              spids: [-1 7046]
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {($ VSub_Name "$raise_error")} {(Lit_Other "=")} {(t)})]
                  action: [
                    (C {(checkout_onto)})
                    (C {(warn)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(gettext)} 
                                    {
                                      (DQ 
                                        (
"You can fix this with 'git rebase --edit-todo' and then run 'git rebase --continue'."
                                        )
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [7087 7093]
                          )
                        )
                      }
                    )
                    (C {(die)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(gettext)} 
                                    {(DQ ("Or you can abort the rebase with 'git rebase --abort'."))}
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [7100 7106]
                          )
                        )
                      }
                    )
                  ]
                  spids: [-1 7061]
                )
              ]
              spids: [-1 7110]
            )
          ]
          spids: [6731]
        )
      spids: [6726 6730]
    )
    (FuncDef
      name: git_rebase__interactive
      body: 
        (BraceGroup
          children: [
            (Case
              to_match: {(DQ ($ VSub_Name "$action"))}
              arms: [
                (case_arm
                  pat_list: [{(ControlFlow_Continue continue)}]
                  action: [
                    (If
                      arms: [
                        (if_arm
                          cond: [(C {(git)} {(diff-index)} {(--cached)} {(--quiet)} {(HEAD)} {(--)})]
                          action: [
                            (AndOr
                              children: [
                                (C {(test)} {(KW_Bang "!")} {(-f)} 
                                  {(DQ ($ VSub_Name "$GIT_DIR")) (/CHERRY_PICK_HEAD)}
                                )
                                (AndOr
                                  children: [
                                    (C {(rm)} {(DQ ($ VSub_Name "$GIT_DIR")) (/CHERRY_PICK_HEAD)})
                                    (C {(die)} 
                                      {
                                        (DQ 
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (C {(gettext)} 
                                                    {(DQ ("Could not remove CHERRY_PICK_HEAD"))}
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub "$(">
                                            spids: [7216 7222]
                                          )
                                        )
                                      }
                                    )
                                  ]
                                  op_id: Op_DPipe
                                )
                              ]
                              op_id: Op_DPipe
                            )
                          ]
                          spids: [-1 7181]
                        )
                      ]
                      else_action: [
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (Pipeline
                                  children: [(C {(test)} {(-f)} {(DQ ($ VSub_Name "$author_script"))})]
                                  negated: True
                                )
                              ]
                              action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:gpg_sign_opt_quoted)
                                      op: Equal
                                      rhs: 
                                        {
                                          (BracedVarSub
                                            token: <VSub_Name gpg_sign_opt>
                                            suffix_op: 
                                              (StringUnary
                                                op_id: VTest_ColonPlus
                                                arg_word: 
                                                  {
                                                    (CommandSubPart
                                                      command_list: 
                                                        (CommandList
                                                          children: [
                                                            (C {(git)} {(rev-parse)} {(--sq-quote)} 
                                                              {(DQ ($ VSub_Name "$gpg_sign_opt"))}
                                                            )
                                                          ]
                                                        )
                                                      left_token: <Left_CommandSub "$(">
                                                      spids: [7249 7259]
                                                    )
                                                  }
                                              )
                                            spids: [7246 7260]
                                          )
                                        }
                                      spids: [7245]
                                    )
                                  ]
                                  spids: [7245]
                                )
                                (C {(die)} 
                                  {
                                    (DQ 
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (C {(eval_gettext)} 
                                                {
                                                  (DQ 
                                                    (
"You have staged changes in your working tree.\n"
                                                    ) ("If these changes are meant to be\n") ("squashed into the previous commit, run:\n") ("\n") 
                                                    ("  git commit --amend ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("gpg_sign_opt_quoted\n") ("\n") 
                                                    (
"If they are meant to go into a new commit, run:\n"
                                                    ) ("\n") ("  git commit ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("gpg_sign_opt_quoted\n") 
                                                    ("\n") ("In both cases, once you're done, continue with:\n") ("\n") ("  git rebase --continue\n")
                                                  )
                                                }
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub "$(">
                                        spids: [7266 7289]
                                      )
                                    )
                                  }
                                )
                              ]
                              spids: [-1 7242]
                            )
                          ]
                          spids: [-1 7293]
                        )
                        (AndOr
                          children: [
                            (C {(.)} {(DQ ($ VSub_Name "$author_script"))})
                            (C {(die)} 
                              {
                                (DQ 
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(gettext)} 
                                            {
                                              (DQ 
                                                (
"Error trying to find the author identity to amend commit"
                                                )
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [7308 7314]
                                  )
                                )
                              }
                            )
                          ]
                          op_id: Op_DPipe
                        )
                        (If
                          arms: [
                            (if_arm
                              cond: [(C {(test)} {(-f)} {(DQ ($ VSub_Name "$amend"))})]
                              action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:current_head)
                                      op: Equal
                                      rhs: 
                                        {
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (C {(git)} {(rev-parse)} {(--verify)} {(HEAD)})
                                                ]
                                              )
                                            left_token: <Left_CommandSub "$(">
                                            spids: [7333 7341]
                                          )
                                        }
                                      spids: [7332]
                                    )
                                  ]
                                  spids: [7332]
                                )
                                (AndOr
                                  children: [
                                    (C {(test)} {(DQ ($ VSub_Name "$current_head"))} {(Lit_Other "=")} 
                                      {
                                        (CommandSubPart
                                          command_list: 
                                            (CommandList
                                              children: [(C {(cat)} {(DQ ($ VSub_Name "$amend"))})]
                                            )
                                          left_token: <Left_CommandSub "$(">
                                          spids: [7352 7358]
                                        )
                                      }
                                    )
                                    (C {(die)} 
                                      {
                                        (DQ 
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (C {(gettext)} 
                                                    {
                                                      (DQ 
                                                        (
"You have uncommitted changes in your working tree. Please commit them\n"
                                                        ) ("first and then run 'git rebase --continue' again.")
                                                      )
                                                    }
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub "$(">
                                            spids: [7366 7374]
                                          )
                                        )
                                      }
                                    )
                                  ]
                                  op_id: Op_DPipe
                                )
                                (AndOr
                                  children: [
                                    (C {(do_with_author)} {(git)} {(commit)} {(--amend)} {(--no-verify)} 
                                      {(-F)} {(DQ ($ VSub_Name "$msg"))} {(-e)} 
                                      {
                                        (BracedVarSub
                                          token: <VSub_Name gpg_sign_opt>
                                          suffix_op: 
                                            (StringUnary
                                              op_id: VTest_ColonPlus
                                              arg_word: {(DQ ($ VSub_Name "$gpg_sign_opt"))}
                                            )
                                          spids: [7398 7404]
                                        )
                                      }
                                    )
                                    (C {(die)} 
                                      {
                                        (DQ 
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (C {(gettext)} 
                                                    {(DQ ("Could not commit staged changes."))}
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub "$(">
                                            spids: [7412 7418]
                                          )
                                        )
                                      }
                                    )
                                  ]
                                  op_id: Op_DPipe
                                )
                              ]
                              spids: [-1 7329]
                            )
                          ]
                          else_action: [
                            (AndOr
                              children: [
                                (C {(do_with_author)} {(git)} {(commit)} {(--no-verify)} {(-F)} 
                                  {(DQ ($ VSub_Name "$msg"))} {(-e)} 
                                  {
                                    (BracedVarSub
                                      token: <VSub_Name gpg_sign_opt>
                                      suffix_op: 
                                        (StringUnary
                                          op_id: VTest_ColonPlus
                                          arg_word: {(DQ ($ VSub_Name "$gpg_sign_opt"))}
                                        )
                                      spids: [7443 7449]
                                    )
                                  }
                                )
                                (C {(die)} 
                                  {
                                    (DQ 
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (C {(gettext)} {(DQ ("Could not commit staged changes."))})
                                            ]
                                          )
                                        left_token: <Left_CommandSub "$(">
                                        spids: [7457 7463]
                                      )
                                    )
                                  }
                                )
                              ]
                              op_id: Op_DPipe
                            )
                          ]
                          spids: [7422 7467]
                        )
                      ]
                      spids: [7226 7470]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [(C {(test)} {(-r)} {(DQ ($ VSub_Name "$state_dir")) (/stopped-sha)})]
                          action: [
                            (C {(record_in_rewritten)} 
                              {
                                (DQ 
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(cat)} {(DQ ($ VSub_Name "$state_dir")) (/stopped-sha)})
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [7492 7499]
                                  )
                                )
                              }
                            )
                          ]
                          spids: [-1 7486]
                        )
                      ]
                      spids: [-1 7503]
                    )
                    (C {(require_clean_work_tree)} {(DQ (rebase))})
                    (C {(do_rest)})
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [7158 7159 7522 -1]
                )
                (case_arm
                  pat_list: [{(skip)}]
                  action: [
                    (C {(git)} {(rerere)} {(clear)})
                    (C {(do_rest)})
                    (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
                  ]
                  spids: [7524 7525 7544 -1]
                )
                (case_arm
                  pat_list: [{(edit-todo)}]
                  action: [
                    (SimpleCommand
                      words: [{(git)} {(stripspace)} {(--strip-comments)}]
                      redirects: [
                        (Redir
                          op_id: Redir_Less
                          fd: -1
                          arg_word: {(DQ ($ VSub_Name "$todo"))}
                          spids: [7556]
                        )
                        (Redir
                          op_id: Redir_Great
                          fd: -1
                          arg_word: {(DQ ($ VSub_Name "$todo")) (.new)}
                          spids: [7561]
                        )
                      ]
                    )
                    (C {(mv)} {(-f)} {(DQ ($ VSub_Name "$todo")) (.new)} {(DQ ($ VSub_Name "$todo"))})
                    (C {(collapse_todo_ids)})
                    (C {(append_todo_help)})
                    (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")
                            )
                          }
                        )
                        (SimpleCommand
                          words: [{(git)} {(stripspace)} {(--comment-lines)}]
                          redirects: [
                            (Redir
                              op_id: Redir_DGreat
                              fd: -1
                              arg_word: {(DQ ($ VSub_Name "$todo"))}
                              spids: [7606]
                            )
                          ]
                        )
                      ]
                      negated: False
                    )
                    (AndOr
                      children: [
                        (C {(git_sequence_editor)} {(DQ ($ VSub_Name "$todo"))})
                        (C {(die)} 
                          {
                            (DQ 
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [(C {(gettext)} {(DQ ("Could not execute editor"))})]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [7625 7631]
                              )
                            )
                          }
                        )
                      ]
                      op_id: Op_DPipe
                    )
                    (C {(expand_todo_ids)})
                    (C {(exit)})
                  ]
                  spids: [7546 7547 7642 -1]
                )
              ]
              spids: [7150 7156 7644]
            )
            (C {(comment_for_reflog)} {(start)})
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(KW_Bang "!")} {(-z)} {(DQ ($ VSub_Name "$switch_to"))})]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:GIT_REFLOG_ACTION)
                          op: Equal
                          rhs: 
                            {
                              (DQ ($ VSub_Name "$GIT_REFLOG_ACTION") (": checkout ") 
                                ($ VSub_Name "$switch_to")
                              )
                            }
                          spids: [7667]
                        )
                      ]
                      spids: [7667]
                    )
                    (AndOr
                      children: [
                        (C {(output)} {(git)} {(checkout)} {(DQ ($ VSub_Name "$switch_to"))} {(--)})
                        (C {(die)} 
                          {
                            (DQ 
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(eval_gettext)} 
                                        {
                                          (DQ ("Could not checkout ") 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar "\\$">
                                            ) (switch_to)
                                          )
                                        }
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [7693 7701]
                              )
                            )
                          }
                        )
                      ]
                      op_id: Op_DPipe
                    )
                    (C {(comment_for_reflog)} {(start)})
                  ]
                  spids: [-1 7664]
                )
              ]
              spids: [-1 7710]
            )
            (AndOr
              children: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:orig_head)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [(C {(git)} {(rev-parse)} {(--verify)} {(HEAD)})]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [7714 7722]
                          )
                        }
                      spids: [7713]
                    )
                  ]
                  spids: [7713]
                )
                (C {(die)} 
                  {
                    (DQ 
                      (CommandSubPart
                        command_list: (CommandList children:[(C {(gettext)} {(DQ ("No HEAD?"))})])
                        left_token: <Left_CommandSub "$(">
                        spids: [7729 7735]
                      )
                    )
                  }
                )
              ]
              op_id: Op_DPipe
            )
            (AndOr
              children: [
                (C {(mkdir)} {(-p)} {(DQ ($ VSub_Name "$state_dir"))})
                (C {(die)} 
                  {
                    (DQ 
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(eval_gettext)} 
                                {
                                  (DQ ("Could not create temporary ") 
                                    (EscapedLiteralPart
                                      token: <Lit_EscapedChar "\\$">
                                    ) (state_dir)
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [7751 7759]
                      )
                    )
                  }
                )
              ]
              op_id: Op_DPipe
            )
            (AndOr
              children: [
                (SimpleCommand
                  words: [{(Lit_Other ":")}]
                  redirects: [
                    (Redir
                      op_id: Redir_Great
                      fd: -1
                      arg_word: {(DQ ($ VSub_Name "$state_dir")) (/interactive)}
                      spids: [7765]
                    )
                  ]
                )
                (C {(die)} 
                  {
                    (DQ 
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [(C {(gettext)} {(DQ ("Could not mark as interactive"))})]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [7777 7783]
                      )
                    )
                  }
                )
              ]
              op_id: Op_DPipe
            )
            (C {(write_basic_state)})
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(t)} {(Lit_Other "=")} {(DQ ($ VSub_Name "$preserve_merges"))})]
                  action: [
                    (If
                      arms: [
                        (if_arm
                          cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$rebase_root"))})]
                          action: [
                            (AndOr
                              children: [
                                (C {(mkdir)} {(DQ ($ VSub_Name "$rewritten"))})
                                (ForEach
                                  iter_name: c
                                  iter_words: [
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (C {(git)} {(merge-base)} {(--all)} 
                                                {($ VSub_Name "$orig_head")} {($ VSub_Name "$upstream")}
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub "$(">
                                        spids: [7832 7842]
                                      )
                                    }
                                  ]
                                  do_arg_iter: False
                                  body: 
                                    (DoGroup
                                      children: [
                                        (AndOr
                                          children: [
                                            (SimpleCommand
                                              words: [{(echo)} {($ VSub_Name "$onto")}]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_Great
                                                  fd: -1
                                                  arg_word: 
                                                    {(DQ ($ VSub_Name "$rewritten")) (/) 
                                                      ($ VSub_Name "$c")
                                                    }
                                                  spids: [7852]
                                                )
                                              ]
                                            )
                                            (C {(die)} 
                                              {
                                                (DQ 
                                                  (CommandSubPart
                                                    command_list: 
                                                      (CommandList
                                                        children: [
                                                          (C {(gettext)} 
                                                            {
                                                              (DQ 
                                                                (
"Could not init rewritten commits"
                                                                )
                                                              )
                                                            }
                                                          )
                                                        ]
                                                      )
                                                    left_token: <Left_CommandSub "$(">
                                                    spids: [7866 7872]
                                                  )
                                                )
                                              }
                                            )
                                          ]
                                          op_id: Op_DPipe
                                        )
                                      ]
                                      spids: [7845 7876]
                                    )
                                  spids: [7831 -1]
                                )
                              ]
                              op_id: Op_DAmp
                            )
                          ]
                          spids: [-1 7814]
                        )
                      ]
                      else_action: [
                        (AndOr
                          children: [
                            (C {(mkdir)} {(DQ ($ VSub_Name "$rewritten"))})
                            (AndOr
                              children: [
                                (SimpleCommand
                                  words: [{(echo)} {($ VSub_Name "$onto")}]
                                  redirects: [
                                    (Redir
                                      op_id: Redir_Great
                                      fd: -1
                                      arg_word: {(DQ ($ VSub_Name "$rewritten")) (/root)}
                                      spids: [7895]
                                    )
                                  ]
                                )
                                (C {(die)} 
                                  {
                                    (DQ 
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (C {(gettext)} {(DQ ("Could not init rewritten commits"))})
                                            ]
                                          )
                                        left_token: <Left_CommandSub "$(">
                                        spids: [7908 7914]
                                      )
                                    )
                                  }
                                )
                              ]
                              op_id: Op_DPipe
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      spids: [7879 7918]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:merges_option)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [7933]
                        )
                      ]
                      spids: [7933]
                    )
                  ]
                  spids: [-1 7800]
                )
              ]
              else_action: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:merges_option)
                      op: Equal
                      rhs: {(DQ ("--no-merges --cherry-pick"))}
                      spids: [7938]
                    )
                  ]
                  spids: [7938]
                )
              ]
              spids: [7935 7943]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:shorthead)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(git)} {(rev-parse)} {(--short)} {($ VSub_Name "$orig_head")})
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [7947 7955]
                      )
                    }
                  spids: [7946]
                )
              ]
              spids: [7946]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:shortonto)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [(C {(git)} {(rev-parse)} {(--short)} {($ VSub_Name "$onto")})]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [7958 7966]
                      )
                    }
                  spids: [7957]
                )
              ]
              spids: [7957]
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$rebase_root"))})]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:shortupstream)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(git)} {(rev-parse)} {(--short)} {($ VSub_Name "$upstream")})
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [7986 7994]
                              )
                            }
                          spids: [7985]
                        )
                      ]
                      spids: [7985]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:revisions)
                          op: Equal
                          rhs: {($ VSub_Name "$upstream") (...) ($ VSub_Name "$orig_head")}
                          spids: [7997]
                        )
                      ]
                      spids: [7997]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:shortrevisions)
                          op: Equal
                          rhs: {($ VSub_Name "$shortupstream") (..) ($ VSub_Name "$shorthead")}
                          spids: [8003]
                        )
                      ]
                      spids: [8003]
                    )
                  ]
                  spids: [-1 7982]
                )
              ]
              else_action: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:revisions)
                      op: Equal
                      rhs: {($ VSub_Name "$onto") (...) ($ VSub_Name "$orig_head")}
                      spids: [8011]
                    )
                  ]
                  spids: [8011]
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:shortrevisions)
                      op: Equal
                      rhs: {($ VSub_Name "$shorthead")}
                      spids: [8017]
                    )
                  ]
                  spids: [8017]
                )
              ]
              spids: [8008 8020]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:format)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [(C {(git)} {(config)} {(--get)} {(rebase.instructionFormat)})]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [8023 8031]
                      )
                    }
                  spids: [8022]
                )
              ]
              spids: [8022]
            )
            (Pipeline
              children: [
                (C {(git)} {(rev-list)} {($ VSub_Name "$merges_option")} 
                  {(--format) (Lit_Other "=") 
                    (DQ ("%m%H ") 
                      (BracedVarSub
                        token: <VSub_Name format>
                        suffix_op: 
                          (StringUnary
                            op_id: VTest_ColonHyphen
                            arg_word: {(Lit_Percent "%") (s)}
                          )
                        spids: [8046 8051]
                      )
                    )
                  } {(--reverse)} {(--left-right)} {(--topo-order)} {($ VSub_Name "$revisions")} 
                  {
                    (BracedVarSub
                      token: <VSub_Name restrict_revision>
                      suffix_op: 
                        (StringUnary
                          op_id: VTest_Plus
                          arg_word: {("^") ($ VSub_Name "$restrict_revision")}
                        )
                      spids: [8066 8071]
                    )
                  }
                )
                (C {(sed)} {(-n)} {(DQ ("s/^>//p"))})
                (While
                  cond: [(C {(read)} {(-r)} {(sha1)} {(rest)})]
                  body: 
                    (DoGroup
                      children: [
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (AndOr
                                  children: [
                                    (C {(test)} {(-z)} {(DQ ($ VSub_Name "$keep_empty"))})
                                    (AndOr
                                      children: [
                                        (C {(is_empty_commit)} {($ VSub_Name "$sha1")})
                                        (Pipeline
                                          children: [(C {(is_merge_commit)} {($ VSub_Name "$sha1")})]
                                          negated: True
                                        )
                                      ]
                                      op_id: Op_DAmp
                                    )
                                  ]
                                  op_id: Op_DAmp
                                )
                              ]
                              action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:comment_out)
                                      op: Equal
                                      rhs: {(DQ ($ VSub_Name "$comment_char") (" "))}
                                      spids: [8129]
                                    )
                                  ]
                                  spids: [8129]
                                )
                              ]
                              spids: [-1 8126]
                            )
                          ]
                          else_action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:comment_out)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [8139]
                                )
                              ]
                              spids: [8139]
                            )
                          ]
                          spids: [8136 8142]
                        )
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (C {(test)} {(t)} {(KW_Bang "!") (Lit_Other "=")} 
                                  {(DQ ($ VSub_Name "$preserve_merges"))}
                                )
                              ]
                              action: [
                                (SimpleCommand
                                  words: [
                                    {(printf)}
                                    {(SQ <"%s\\n">)}
                                    {
                                      (DQ (${ VSub_Name comment_out) ("pick ") ($ VSub_Name "$sha1") 
                                        (" ") ($ VSub_Name "$rest")
                                      )
                                    }
                                  ]
                                  redirects: [
                                    (Redir
                                      op_id: Redir_DGreat
                                      fd: -1
                                      arg_word: {(DQ ($ VSub_Name "$todo"))}
                                      spids: [8179]
                                    )
                                  ]
                                )
                              ]
                              spids: [-1 8160]
                            )
                          ]
                          else_action: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$rebase_root"))})]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:preserve)
                                          op: Equal
                                          rhs: {(t)}
                                          spids: [8202]
                                        )
                                      ]
                                      spids: [8202]
                                    )
                                    (ForEach
                                      iter_name: p
                                      iter_words: [
                                        {
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (Pipeline
                                                    children: [
                                                      (C {(git)} {(rev-list)} {(--parents)} {(-1)} 
                                                        {($ VSub_Name "$sha1")}
                                                      )
                                                      (C {(cut)} {(-d) (SQ <" ">)} {(-s)} {(-f2-)})
                                                    ]
                                                    negated: False
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub "$(">
                                            spids: [8212 8235]
                                          )
                                        }
                                      ]
                                      do_arg_iter: False
                                      body: 
                                        (DoGroup
                                          children: [
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (C {(test)} {(-f)} 
                                                      {(DQ ($ VSub_Name "$rewritten")) (/) 
                                                        ($ VSub_Name "$p")
                                                      }
                                                    )
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:preserve)
                                                          op: Equal
                                                          rhs: {(f)}
                                                          spids: [8257]
                                                        )
                                                      ]
                                                      spids: [8257]
                                                    )
                                                  ]
                                                  spids: [-1 8254]
                                                )
                                              ]
                                              spids: [-1 8261]
                                            )
                                          ]
                                          spids: [8238 8264]
                                        )
                                      spids: [8211 -1]
                                    )
                                  ]
                                  spids: [-1 8199]
                                )
                              ]
                              else_action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:preserve)
                                      op: Equal
                                      rhs: {(f)}
                                      spids: [8270]
                                    )
                                  ]
                                  spids: [8270]
                                )
                              ]
                              spids: [8267 8274]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (C {(test)} {(f)} {(Lit_Other "=")} {(DQ ($ VSub_Name "$preserve"))})
                                  ]
                                  action: [
                                    (C {(touch)} 
                                      {(DQ ($ VSub_Name "$rewritten")) (/) ($ VSub_Name "$sha1")}
                                    )
                                    (SimpleCommand
                                      words: [
                                        {(printf)}
                                        {(SQ <"%s\\n">)}
                                        {
                                          (DQ (${ VSub_Name comment_out) ("pick ") 
                                            ($ VSub_Name "$sha1") (" ") ($ VSub_Name "$rest")
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_DGreat
                                          fd: -1
                                          arg_word: {(DQ ($ VSub_Name "$todo"))}
                                          spids: [8318]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [-1 8290]
                                )
                              ]
                              spids: [-1 8324]
                            )
                          ]
                          spids: [8185 8327]
                        )
                      ]
                      spids: [8097 8329]
                    )
                )
              ]
              negated: False
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(t)} {(Lit_Other "=")} {(DQ ($ VSub_Name "$preserve_merges"))})]
                  action: [
                    (C {(mkdir)} {(DQ ($ VSub_Name "$dropped"))})
                    (Pipeline
                      children: [
                        (C {(git)} {(rev-list)} {($ VSub_Name "$revisions")} {(--left-right)} 
                          {(--cherry-pick)}
                        )
                        (SimpleCommand
                          words: [{(sed)} {(-n)} {(DQ ("s/^>//p"))}]
                          redirects: [
                            (Redir
                              op_id: Redir_Great
                              fd: -1
                              arg_word: {(DQ ($ VSub_Name "$state_dir")) (/not-cherry-picks)}
                              spids: [8383]
                            )
                          ]
                        )
                      ]
                      negated: False
                    )
                    (Pipeline
                      children: [
                        (C {(git)} {(rev-list)} {($ VSub_Name "$revisions")})
                        (While
                          cond: [(C {(read)} {(rev)})]
                          body: 
                            (DoGroup
                              children: [
                                (If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (AndOr
                                          children: [
                                            (C {(test)} {(-f)} 
                                              {(DQ ($ VSub_Name "$rewritten")) (/) 
                                                ($ VSub_Name "$rev")
                                              }
                                            )
                                            (Pipeline
                                              children: [
                                                (SimpleCommand
                                                  words: [
                                                    {(sane_grep)}
                                                    {(DQ ($ VSub_Name "$rev"))}
                                                    {(DQ ($ VSub_Name "$state_dir")) 
                                                      (/not-cherry-picks)
                                                    }
                                                  ]
                                                  redirects: [
                                                    (Redir
                                                      op_id: Redir_Great
                                                      fd: -1
                                                      arg_word: {(/dev/null)}
                                                      spids: [8446]
                                                    )
                                                  ]
                                                )
                                              ]
                                              negated: True
                                            )
                                          ]
                                          op_id: Op_DAmp
                                        )
                                      ]
                                      action: [
                                        (Pipeline
                                          children: [
                                            (C {(git)} {(rev-list)} {(--parents)} {(-1)} 
                                              {($ VSub_Name "$rev")}
                                            )
                                            (SimpleCommand
                                              words: [{(cut)} {(-d) (SQ <" ">)} {(-s)} {(-f2)}]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_Great
                                                  fd: -1
                                                  arg_word: 
                                                    {(DQ ($ VSub_Name "$dropped")) (/) 
                                                      ($ VSub_Name "$rev")
                                                    }
                                                  spids: [8492]
                                                )
                                              ]
                                            )
                                          ]
                                          negated: False
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:sha1)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (CommandSubPart
                                                    command_list: 
                                                      (CommandList
                                                        children: [
                                                          (C {(git)} {(rev-list)} {(-1)} 
                                                            {($ VSub_Name "$rev")}
                                                          )
                                                        ]
                                                      )
                                                    left_token: <Left_CommandSub "$(">
                                                    spids: [8502 8510]
                                                  )
                                                }
                                              spids: [8501]
                                            )
                                          ]
                                          spids: [8501]
                                        )
                                        (Sentence
                                          child: 
                                            (SimpleCommand
                                              words: [
                                                {(sane_grep)}
                                                {(-v)}
                                                {(DQ ("^[a-z][a-z]* ") ($ VSub_Name "$sha1"))}
                                              ]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_Less
                                                  fd: -1
                                                  arg_word: {(DQ ($ VSub_Name "$todo"))}
                                                  spids: [8522]
                                                )
                                                (Redir
                                                  op_id: Redir_Great
                                                  fd: -1
                                                  arg_word: {(DQ (${ VSub_Name todo) (2))}
                                                  spids: [8527]
                                                )
                                              ]
                                            )
                                          terminator: <Op_Semi ";">
                                        )
                                        (C {(mv)} {(DQ (${ VSub_Name todo) (2))} 
                                          {(DQ ($ VSub_Name "$todo"))}
                                        )
                                        (C {(rm)} 
                                          {(DQ ($ VSub_Name "$rewritten")) (/) ($ VSub_Name "$rev")}
                                        )
                                      ]
                                      spids: [-1 8450]
                                    )
                                  ]
                                  spids: [-1 8561]
                                )
                              ]
                              spids: [8415 8564]
                            )
                        )
                      ]
                      negated: False
                    )
                  ]
                  spids: [-1 8347]
                )
              ]
              spids: [-1 8566]
            )
            (AndOr
              children: [
                (C {(test)} {(-s)} {(DQ ($ VSub_Name "$todo"))})
                (SimpleCommand
                  words: [{(echo)} {(noop)}]
                  redirects: [
                    (Redir
                      op_id: Redir_DGreat
                      fd: -1
                      arg_word: {(DQ ($ VSub_Name "$todo"))}
                      spids: [8583]
                    )
                  ]
                )
              ]
              op_id: Op_DPipe
            )
            (AndOr
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$autosquash"))})
                (C {(rearrange_squash)} {(DQ ($ VSub_Name "$todo"))})
              ]
              op_id: Op_DAmp
            )
            (AndOr
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$cmd"))})
                (C {(add_exec_commands)} {(DQ ($ VSub_Name "$todo"))})
              ]
              op_id: Op_DAmp
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:todocount)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (Pipeline
                                children: [
                                  (SimpleCommand
                                    words: [{(git)} {(stripspace)} {(--strip-comments)}]
                                    redirects: [
                                      (Redir
                                        op_id: Redir_Less
                                        fd: -1
                                        arg_word: {(DQ ($ VSub_Name "$todo"))}
                                        spids: [8630]
                                      )
                                    ]
                                  )
                                  (C {(wc)} {(-l)})
                                ]
                                negated: False
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [8623 8640]
                      )
                    }
                  spids: [8622]
                )
              ]
              spids: [8622]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:todocount)
                  op: Equal
                  rhs: 
                    {
                      (BracedVarSub
                        token: <VSub_Name todocount>
                        suffix_op: (StringUnary op_id:VOp1_DPound arg_word:{("* ")})
                        spids: [8643 8647]
                      )
                    }
                  spids: [8642]
                )
              ]
              spids: [8642]
            )
            (SimpleCommand
              words: [{(cat)}]
              redirects: [
                (Redir
                  op_id: Redir_DGreat
                  fd: -1
                  arg_word: {(DQ ($ VSub_Name "$todo"))}
                  spids: [8652]
                )
                (HereDoc
                  op_id: Redir_DLess
                  fd: -1
                  body: 
                    {
                      (DQ ("\n") ($ VSub_Name "$comment_char") (" ") 
                        (CommandSubPart
                          command_list: 
                            (CommandList
                              children: [
                                (C {(eval_ngettext)} 
                                  {
                                    (DQ ("Rebase ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) 
                                      ("shortrevisions onto ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("shortonto (") 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\$">
                                      ) ("todocount command)")
                                    )
                                  } 
                                  {
                                    (DQ ("Rebase ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) 
                                      ("shortrevisions onto ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("shortonto (") 
                                      (EscapedLiteralPart
                                        token: <Lit_EscapedChar "\\$">
                                      ) ("todocount commands)")
                                    )
                                  } {(DQ ($ VSub_Name "$todocount"))}
                                )
                              ]
                            )
                          left_token: <Left_CommandSub "$(">
                          spids: [8663 8695]
                        ) ("\n")
                      )
                    }
                  do_expansion: True
                  here_end: EOF
                  was_filled: True
                  spids: [8657]
                )
              ]
            )
            (C {(append_todo_help)})
            (Pipeline
              children: [
                (C {(gettext)} 
                  {
                    (DQ ("\n") ("However, if you remove everything, the rebase will be aborted.\n") 
                      ("\n")
                    )
                  }
                )
                (SimpleCommand
                  words: [{(git)} {(stripspace)} {(--comment-lines)}]
                  redirects: [
                    (Redir
                      op_id: Redir_DGreat
                      fd: -1
                      arg_word: {(DQ ($ VSub_Name "$todo"))}
                      spids: [8715]
                    )
                  ]
                )
              ]
              negated: False
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$keep_empty"))})]
                  action: [
                    (SimpleCommand
                      words: [
                        {(printf)}
                        {(SQ <"%s\\n">)}
                        {
                          (DQ ($ VSub_Name "$comment_char") (" ") 
                            (CommandSubPart
                              command_list: 
                                (CommandList
                                  children: [
                                    (C {(gettext)} {(DQ ("Note that empty commits are commented out"))})
                                  ]
                                )
                              left_token: <Left_CommandSub "$(">
                              spids: [8743 8749]
                            )
                          )
                        }
                      ]
                      redirects: [
                        (Redir
                          op_id: Redir_DGreat
                          fd: -1
                          arg_word: {(DQ ($ VSub_Name "$todo"))}
                          spids: [8752]
                        )
                      ]
                    )
                  ]
                  spids: [-1 8731]
                )
              ]
              spids: [-1 8757]
            )
            (AndOr
              children: [
                (C {(has_action)} {(DQ ($ VSub_Name "$todo"))})
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(2)})
              ]
              op_id: Op_DPipe
            )
            (C {(cp)} {(DQ ($ VSub_Name "$todo"))} {(DQ ($ VSub_Name "$todo")) (.backup)})
            (C {(collapse_todo_ids)})
            (AndOr
              children: [
                (C {(git_sequence_editor)} {(DQ ($ VSub_Name "$todo"))})
                (C {(die_abort)} 
                  {
                    (DQ 
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [(C {(gettext)} {(DQ ("Could not execute editor"))})]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [8800 8806]
                      )
                    )
                  }
                )
              ]
              op_id: Op_DPipe
            )
            (AndOr
              children: [
                (C {(has_action)} {(DQ ($ VSub_Name "$todo"))})
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(2)})
              ]
              op_id: Op_DPipe
            )
            (C {(check_todo_list)})
            (C {(expand_todo_ids)})
            (AndOr
              children: [
                (C {(test)} {(-d)} {(DQ ($ VSub_Name "$rewritten"))})
                (AndOr
                  children: [
                    (C {(test)} {(-n)} {(DQ ($ VSub_Name "$force_rebase"))})
                    (C {(skip_unnecessary_picks)})
                  ]
                  op_id: Op_DPipe
                )
              ]
              op_id: Op_DPipe
            )
            (C {(checkout_onto)})
            (C {(do_rest)})
          ]
          spids: [7147]
        )
      spids: [7142 7146]
    )
    (C {(git_rebase__interactive)})
  ]
)