(command.CommandList
  children: [
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'dashless='> name:dashless)
          op: assign_op.Equal
          rhs: 
            {
              (command_sub
                left_token: <Id.Left_DollarParen '$('>
                child: 
                  (command.Pipeline
                    children: [
                      (C {<basename>} {(DQ ($ Id.VSub_Number 0))})
                      (C {<sed>} {<-e>} {(SQ <'s/-/ /'>)})
                    ]
                    negated: F
                    stderr_indices: []
                  )
                right: <Id.Eof_RParen _>
              )
            }
          spids: [7]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'USAGE='> name:USAGE)
          op: assign_op.Equal
          rhs: 
            {
              (DQ <'list [<options>]\n'> <'   or: '> ($ Id.VSub_DollarName dashless) 
                <' show [<stash>]\n'> <'   or: '> ($ Id.VSub_DollarName dashless) <' drop [-q|--quiet] [<stash>]\n'> <'   or: '> 
                ($ Id.VSub_DollarName dashless) <' ( pop | apply ) [--index] [-q|--quiet] [<stash>]\n'> <'   or: '> ($ Id.VSub_DollarName dashless) 
                <' branch <branchname> [<stash>]\n'> <'   or: '> ($ Id.VSub_DollarName dashless) <' [save [--patch] [-k|--[no-]keep-index] [-q|--quiet]\n'> 
                <'\t\t       [-u|--include-untracked] [-a|--all] [<message>]]\n'> <'   or: '> ($ Id.VSub_DollarName dashless) <' clear'>
              )
            }
          spids: [26]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'SUBDIRECTORY_OK='> name:SUBDIRECTORY_OK)
          op: assign_op.Equal
          rhs: {<Yes>}
          spids: [51]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'OPTIONS_SPEC='> name:OPTIONS_SPEC)
          op: assign_op.Equal
          rhs: (rhs_word.Empty)
          spids: [54]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'START_DIR='> name:START_DIR)
          op: assign_op.Equal
          rhs: 
            {
              (command_sub
                left_token: <Id.Left_DollarParen '$('>
                child: (C {<pwd>})
                right: <Id.Eof_RParen _>
              )
            }
          spids: [56]
        )
      ]
      redirects: []
    )
    (C {<.>} {<git-sh-setup>})
    (C {<require_work_tree>})
    (C {<cd_to_toplevel>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'TMP='> name:TMP)
          op: assign_op.Equal
          rhs: {(DQ ($ Id.VSub_DollarName GIT_DIR) <'/.git-stash.'> ($ Id.VSub_Dollar '$'))}
          spids: [70]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'TMPindex='> name:TMPindex)
          op: assign_op.Equal
          rhs: 
            {
              (braced_var_sub
                left: <Id.Left_DollarBrace '${'>
                token: <Id.VSub_Name GIT_INDEX_FILE>
                var_name: GIT_INDEX_FILE
                suffix_op: 
                  (suffix_op.Unary
                    op: <Id.VTest_Hyphen _>
                    arg_word: 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: (C {<git>} {<rev-parse>} {<--git-path>} {<index>})
                            right: <Id.Eof_RParen _>
                          )
                        )
                      }
                  )
                right: <Id.Right_DollarBrace '}'>
              ) <.stash.> ($ Id.VSub_Dollar '$')
            }
          spids: [77]
        )
      ]
      redirects: []
    )
    (C {<trap>} {(SQ <'rm -f "$TMP-"* "$TMPindex"'>)} {<0>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'ref_stash='> name:ref_stash)
          op: assign_op.Equal
          rhs: {<'refs/stash'>}
          spids: [105]
        )
      ]
      redirects: []
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: (C {<git>} {<config>} {<--get-colorbool>} {<color.interactive>})
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'help_color='> name:help_color)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ 
                        (command_sub
                          left_token: <Id.Left_DollarParen '$('>
                          child: 
                            (C {<git>} {<config>} {<--get-color>} {<color.interactive.help>} 
                              {(SQ <'red bold'>)}
                            )
                          right: <Id.Eof_RParen _>
                        )
                      )
                    }
                  spids: [123]
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'reset_color='> name:reset_color)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ 
                        (command_sub
                          left_token: <Id.Left_DollarParen '$('>
                          child: (C {<git>} {<config>} {<--get-color>} {(SQ )} {<reset>})
                          right: <Id.Eof_RParen _>
                        )
                      )
                    }
                  spids: [141]
                )
              ]
              redirects: []
            )
          ]
          spids: [109 120]
        )
      ]
      else_action: [
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'help_color='> name:help_color)
              op: assign_op.Equal
              rhs: (rhs_word.Empty)
              spids: [160]
            )
          ]
          redirects: []
        )
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'reset_color='> name:reset_color)
              op: assign_op.Equal
              rhs: (rhs_word.Empty)
              spids: [163]
            )
          ]
          redirects: []
        )
      ]
      redirects: []
    )
    (command.ShFunction
      name: no_changes
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DAmp]
              children: [
                (C {<git>} {<diff-index>} {<--quiet>} {<--cached>} {<HEAD>} {<--ignore-submodules>} {<-->})
                (C {<git>} {<diff-files>} {<--quiet>} {<--ignore-submodules>})
                (command.Subshell
                  child: 
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName untracked))})
                        (C {<test>} {<-z>} 
                          {
                            (DQ 
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: (C {<untracked_files>})
                                right: <Id.Eof_RParen _>
                              )
                            )
                          }
                        )
                      ]
                    )
                  redirects: []
                )
              ]
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: untracked_files
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'excl_opt='> name:excl_opt)
                  op: assign_op.Equal
                  rhs: {<--exclude-standard>}
                  spids: [237]
                )
              ]
              redirects: []
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<test>} {(DQ ($ Id.VSub_DollarName untracked))} {<Id.Lit_Equals '='>} {(DQ <all>)})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'excl_opt='> name:excl_opt)
                      op: assign_op.Equal
                      rhs: (rhs_word.Empty)
                      spids: [255]
                    )
                  ]
                  redirects: []
                )
              ]
            )
            (C {<git>} {<ls-files>} {<-o>} {<-z>} {($ Id.VSub_DollarName excl_opt)})
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: clear_stash
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (C {<test>} {($ Id.VSub_Pound '#')} {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<0>})
                      ]
                    )
                  action: [
                    (C {<die>} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (C {<gettext>} {(DQ <'git stash clear with parameters is unimplemented'>)})
                            right: <Id.Eof_RParen _>
                          )
                        )
                      }
                    )
                  ]
                  spids: [279 291]
                )
              ]
              else_action: []
              redirects: []
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'current='> name:current)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (C {<git>} {<rev-parse>} {<--verify>} {<--quiet>} 
                                        {($ Id.VSub_DollarName ref_stash)}
                                      )
                                    right: <Id.Eof_RParen _>
                                  )
                                }
                              spids: [312]
                            )
                          ]
                          redirects: []
                        )
                      ]
                    )
                  action: [
                    (C {<git>} {<update-ref>} {<-d>} {($ Id.VSub_DollarName ref_stash)} 
                      {($ Id.VSub_DollarName current)}
                    )
                  ]
                  spids: [310 326]
                )
              ]
              else_action: []
              redirects: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: create_stash
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'stash_msg='> name:stash_msg)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_Number 1))}
                  spids: [353]
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'untracked='> name:untracked)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_Number 2))}
                  spids: [359]
                )
              ]
              redirects: []
            )
            (C {<git>} {<update-index>} {<-q>} {<--refresh>})
            (command.If
              arms: [
                (if_arm
                  cond: (condition.Shell commands:[(C {<no_changes>})])
                  action: [(command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<0>})]
                  spids: [375 380]
                )
              ]
              else_action: []
              redirects: []
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'b_commit='> name:b_commit)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: (C {<git>} {<rev-parse>} {<--verify>} {<HEAD>})
                                    right: <Id.Eof_RParen _>
                                  )
                                }
                              spids: [398]
                            )
                          ]
                          redirects: []
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'head='> name:head)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<git>} {<rev-list>} {<--oneline>} {<-n>} {<1>} {<HEAD>} {<-->})
                                right: <Id.Eof_RParen _>
                              )
                            }
                          spids: [413]
                        )
                      ]
                      redirects: []
                    )
                  ]
                  spids: [396 410]
                )
              ]
              else_action: [
                (C {<die>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<gettext>} {(DQ <'You do not have the initial commit yet'>)})
                        right: <Id.Eof_RParen _>
                      )
                    )
                  }
                )
              ]
              redirects: []
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'branch='> name:branch)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: (C {<git>} {<symbolic-ref>} {<-q>} {<HEAD>})
                                    right: <Id.Eof_RParen _>
                                  )
                                }
                              spids: [453]
                            )
                          ]
                          redirects: []
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'branch='> name:branch)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (braced_var_sub
                                left: <Id.Left_DollarBrace '${'>
                                token: <Id.VSub_Name branch>
                                var_name: branch
                                suffix_op: 
                                  (suffix_op.Unary
                                    op: <Id.VOp1_Pound '#'>
                                    arg_word: {<refs> <Id.Lit_Slash '/'> <heads> <Id.Lit_Slash '/'>}
                                  )
                                right: <Id.Right_DollarBrace '}'>
                              )
                            }
                          spids: [468]
                        )
                      ]
                      redirects: []
                    )
                  ]
                  spids: [451 465]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'branch='> name:branch)
                      op: assign_op.Equal
                      rhs: {(SQ <'(no branch)'>)}
                      spids: [482]
                    )
                  ]
                  redirects: []
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'msg='> name:msg)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (C {<printf>} {(SQ <'%s: %s'>)} {(DQ ($ Id.VSub_DollarName branch))} 
                            {(DQ ($ Id.VSub_DollarName head))}
                          )
                        right: <Id.Eof_RParen _>
                      )
                    }
                  spids: [491]
                )
              ]
              redirects: []
            )
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DPipe]
              children: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'i_tree='> name:i_tree)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: (C {<git>} {<write-tree>})
                            right: <Id.Eof_RParen _>
                          )
                        }
                      spids: [514]
                    )
                  ]
                  redirects: []
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'i_commit='> name:i_commit)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (command.Pipeline
                                children: [
                                  (C {<printf>} {(SQ <'index on %s\\n'>)} 
                                    {(DQ ($ Id.VSub_DollarName msg))}
                                  )
                                  (C {<git>} {<commit-tree>} {($ Id.VSub_DollarName i_tree)} {<-p>} 
                                    {($ Id.VSub_DollarName b_commit)}
                                  )
                                ]
                                negated: F
                                stderr_indices: []
                              )
                            right: <Id.Eof_RParen _>
                          )
                        }
                      spids: [524]
                    )
                  ]
                  redirects: []
                )
                (C {<die>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<gettext>} {(DQ <'Cannot save the current index state'>)})
                        right: <Id.Eof_RParen _>
                      )
                    )
                  }
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [(C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName untracked))})]
                    )
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'u_commit='> name:u_commit)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (command.Pipeline
                                        children: [
                                          (C {<untracked_files>})
                                          (command.Subshell
                                            child: 
                                              (command.AndOr
                                                ops: [
Id.Op_DAmp
Id.Op_DAmp
Id.Op_DAmp
Id.Op_DAmp
Id.Op_DAmp
Id.Op_DAmp
                                                ]
                                                children: [
                                                  (command.ShAssignment
                                                    pairs: [
                                                      (assign_pair
                                                        lhs: 
                                                          (sh_lhs_expr.Name
                                                            left: <Id.Lit_VarLike 'GIT_INDEX_FILE='>
                                                            name: GIT_INDEX_FILE
                                                          )
                                                        op: assign_op.Equal
                                                        rhs: {(DQ ($ Id.VSub_DollarName TMPindex))}
                                                        spids: [600]
                                                      )
                                                    ]
                                                    redirects: []
                                                  )
                                                  (C {<export>} {<GIT_INDEX_FILE>})
                                                  (C {<rm>} {<-f>} {(DQ ($ Id.VSub_DollarName TMPindex))})
                                                  (C {<git>} {<update-index>} {<-z>} {<--add>} 
                                                    {<--remove>} {<--stdin>}
                                                  )
                                                  (command.ShAssignment
                                                    pairs: [
                                                      (assign_pair
                                                        lhs: 
                                                          (sh_lhs_expr.Name
                                                            left: <Id.Lit_VarLike 'u_tree='>
                                                            name: u_tree
                                                          )
                                                        op: assign_op.Equal
                                                        rhs: 
                                                          {
                                                            (command_sub
                                                              left_token: <Id.Left_DollarParen '$('>
                                                              child: (C {<git>} {<write-tree>})
                                                              right: <Id.Eof_RParen _>
                                                            )
                                                          }
                                                        spids: [641]
                                                      )
                                                    ]
                                                    redirects: []
                                                  )
                                                  (command.Pipeline
                                                    children: [
                                                      (C {<printf>} {(SQ <'untracked files on %s\\n'>)} 
                                                        {(DQ ($ Id.VSub_DollarName msg))}
                                                      )
                                                      (C {<git>} {<commit-tree>} 
                                                        {($ Id.VSub_DollarName u_tree)}
                                                      )
                                                    ]
                                                    negated: F
                                                    stderr_indices: []
                                                  )
                                                  (C {<rm>} {<-f>} {(DQ ($ Id.VSub_DollarName TMPindex))})
                                                ]
                                              )
                                            redirects: []
                                          )
                                        ]
                                        negated: F
                                        stderr_indices: []
                                      )
                                    right: <Id.Eof_RParen _>
                                  )
                                }
                              spids: [589]
                            )
                          ]
                          redirects: []
                        )
                        (C {<die>} 
                          {
                            (DQ 
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: (C {<gettext>} {(DQ <'Cannot save the untracked files'>)})
                                right: <Id.Eof_RParen _>
                              )
                            )
                          }
                        )
                      ]
                    )
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: 
                                (sh_lhs_expr.Name
                                  left: <Id.Lit_VarLike 'untracked_commit_option='>
                                  name: untracked_commit_option
                                )
                              op: assign_op.Equal
                              rhs: {(DQ <'-p '> ($ Id.VSub_DollarName u_commit))}
                              spids: [701]
                            )
                          ]
                          redirects: []
                        )
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                  spids: [567 578]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: 
                        (sh_lhs_expr.Name
                          left: <Id.Lit_VarLike 'untracked_commit_option='>
                          name: untracked_commit_option
                        )
                      op: assign_op.Equal
                      rhs: (rhs_word.Empty)
                      spids: [712]
                    )
                  ]
                  redirects: []
                )
              ]
              redirects: []
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [(C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName patch_mode))})]
                    )
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'w_tree='> name:w_tree)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (command.Subshell
                                        child: 
                                          (command.AndOr
                                            ops: [
Id.Op_DAmp
Id.Op_DAmp
Id.Op_DAmp
Id.Op_DAmp
Id.Op_DAmp
Id.Op_DAmp
                                            ]
                                            children: [
                                              (C {<git>} {<read-tree>} 
                                                {<--index-output> <Id.Lit_Equals '='> 
                                                  (DQ ($ Id.VSub_DollarName TMPindex))
                                                } {<-m>} {($ Id.VSub_DollarName i_tree)}
                                              )
                                              (command.ShAssignment
                                                pairs: [
                                                  (assign_pair
                                                    lhs: 
                                                      (sh_lhs_expr.Name
                                                        left: <Id.Lit_VarLike 'GIT_INDEX_FILE='>
                                                        name: GIT_INDEX_FILE
                                                      )
                                                    op: assign_op.Equal
                                                    rhs: {(DQ ($ Id.VSub_DollarName TMPindex))}
                                                    spids: [761]
                                                  )
                                                ]
                                                redirects: []
                                              )
                                              (C {<export>} {<GIT_INDEX_FILE>})
                                              (command.Simple
                                                words: [
                                                  {<git>}
                                                  {<diff>}
                                                  {<--name-only>}
                                                  {<-z>}
                                                  {<HEAD>}
                                                  {<-->}
                                                ]
                                                redirects: [
                                                  (redir
                                                    op: <Id.Redir_Great '>'>
                                                    loc: (redir_loc.Fd fd:1)
                                                    arg: 
                                                      {(DQ ($ Id.VSub_DollarName TMP) <-stagenames>)}
                                                  )
                                                ]
                                                more_env: []
                                                do_fork: T
                                              )
                                              (command.Simple
                                                words: [
                                                  {<git>}
                                                  {<update-index>}
                                                  {<-z>}
                                                  {<--add>}
                                                  {<--remove>}
                                                  {<--stdin>}
                                                ]
                                                redirects: [
                                                  (redir
                                                    op: <Id.Redir_Less '<'>
                                                    loc: (redir_loc.Fd fd:0)
                                                    arg: 
                                                      {(DQ ($ Id.VSub_DollarName TMP) <-stagenames>)}
                                                  )
                                                ]
                                                more_env: []
                                                do_fork: T
                                              )
                                              (C {<git>} {<write-tree>})
                                              (C {<rm>} {<-f>} {(DQ ($ Id.VSub_DollarName TMPindex))})
                                            ]
                                          )
                                        redirects: []
                                      )
                                    right: <Id.Eof_RParen _>
                                  )
                                }
                              spids: [738]
                            )
                          ]
                          redirects: []
                        )
                        (C {<die>} 
                          {
                            (DQ 
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: (C {<gettext>} {(DQ <'Cannot save the current worktree state'>)})
                                right: <Id.Eof_RParen _>
                              )
                            )
                          }
                        )
                      ]
                    )
                  ]
                  spids: [719 730]
                )
              ]
              else_action: [
                (command.AndOr
                  ops: [Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp Id.Op_DPipe]
                  children: [
                    (C {<rm>} {<-f>} {(DQ ($ Id.VSub_DollarName TMP) <-index>)})
                    (command.Simple
                      words: [{<git>} {<read-tree>} {<HEAD>}]
                      redirects: []
                      more_env: [
                        (env_pair
                          name: GIT_INDEX_FILE
                          val: {(DQ ($ Id.VSub_DollarName TMP) <-index>)}
                          spids: [871]
                        )
                      ]
                      do_fork: T
                    )
                    (command.Simple
                      words: [{<git>} {<add--interactive>} {<--patch> <Id.Lit_Equals '='> <stash>} {<-->}]
                      redirects: []
                      more_env: [
                        (env_pair
                          name: GIT_INDEX_FILE
                          val: {(DQ ($ Id.VSub_DollarName TMP) <-index>)}
                          spids: [891]
                        )
                      ]
                      do_fork: T
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'w_tree='> name:w_tree)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (command.Simple
                                    words: [{<git>} {<write-tree>}]
                                    redirects: []
                                    more_env: [
                                      (env_pair
                                        name: GIT_INDEX_FILE
                                        val: {(DQ ($ Id.VSub_DollarName TMP) <-index>)}
                                        spids: [919]
                                      )
                                    ]
                                    do_fork: T
                                  )
                                right: <Id.Eof_RParen _>
                              )
                            }
                          spids: [917]
                        )
                      ]
                      redirects: []
                    )
                    (C {<die>} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: (C {<gettext>} {(DQ <'Cannot save the current worktree state'>)})
                            right: <Id.Eof_RParen _>
                          )
                        )
                      }
                    )
                  ]
                )
                (command.AndOr
                  ops: [Id.Op_DAmp Id.Op_DPipe]
                  children: [
                    (command.Simple
                      words: [{<git>} {<diff-tree>} {<-p>} {<HEAD>} {($ Id.VSub_DollarName w_tree)} {<-->}]
                      redirects: [
                        (redir
                          op: <Id.Redir_Great '>'>
                          loc: (redir_loc.Fd fd:1)
                          arg: {(DQ ($ Id.VSub_DollarName TMP) <-patch>)}
                        )
                      ]
                      more_env: []
                      do_fork: T
                    )
                    (C {<test>} {<-s>} {(DQ ($ Id.VSub_DollarName TMP) <-patch>)})
                    (C {<die>} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: (C {<gettext>} {(DQ <'No changes selected'>)})
                            right: <Id.Eof_RParen _>
                          )
                        )
                      }
                    )
                  ]
                )
                (command.AndOr
                  ops: [Id.Op_DPipe]
                  children: [
                    (C {<rm>} {<-f>} {(DQ ($ Id.VSub_DollarName TMP) <-index>)})
                    (C {<die>} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (C {<gettext>} {(DQ <'Cannot remove temporary index (can\'t happen)'>)})
                            right: <Id.Eof_RParen _>
                          )
                        )
                      }
                    )
                  ]
                )
              ]
              redirects: []
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [(C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName stash_msg))})]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'stash_msg='> name:stash_msg)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<printf>} {(SQ <'WIP on %s'>)} {(DQ ($ Id.VSub_DollarName msg))})
                                right: <Id.Eof_RParen _>
                              )
                            }
                          spids: [1042]
                        )
                      ]
                      redirects: []
                    )
                  ]
                  spids: [1028 1039]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'stash_msg='> name:stash_msg)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (C {<printf>} {(SQ <'On %s: %s'>)} {(DQ ($ Id.VSub_DollarName branch))} 
                                {(DQ ($ Id.VSub_DollarName stash_msg))}
                              )
                            right: <Id.Eof_RParen _>
                          )
                        }
                      spids: [1059]
                    )
                  ]
                  redirects: []
                )
              ]
              redirects: []
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'w_commit='> name:w_commit)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (command.Pipeline
                                children: [
                                  (C {<printf>} {(SQ <'%s\\n'>)} {(DQ ($ Id.VSub_DollarName stash_msg))})
                                  (C {<git>} {<commit-tree>} {($ Id.VSub_DollarName w_tree)} {<-p>} 
                                    {($ Id.VSub_DollarName b_commit)} {<-p>} {($ Id.VSub_DollarName i_commit)} {($ Id.VSub_DollarName untracked_commit_option)}
                                  )
                                ]
                                negated: F
                                stderr_indices: []
                              )
                            right: <Id.Eof_RParen _>
                          )
                        }
                      spids: [1080]
                    )
                  ]
                  redirects: []
                )
                (C {<die>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<gettext>} {(DQ <'Cannot record working tree state'>)})
                        right: <Id.Eof_RParen _>
                      )
                    )
                  }
                )
              ]
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: store_stash
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (C {<test>} {($ Id.VSub_Pound '#')} {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<0>})
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_Number 1))}
                      arms: [
                        (case_arm
                          pat_list: [{<-m>} {<--message>}]
                          action: [
                            (C {<shift>})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.Name
                                      left: <Id.Lit_VarLike 'stash_msg='>
                                      name: stash_msg
                                    )
                                  op: assign_op.Equal
                                  rhs: {(DQ ($ Id.VSub_Number 1))}
                                  spids: [1171]
                                )
                              ]
                              redirects: []
                            )
                          ]
                          spids: [1162 1165 1177 -1]
                        )
                        (case_arm
                          pat_list: [{<-q>} {<--quiet>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'quiet='> name:quiet)
                                  op: assign_op.Equal
                                  rhs: {<t>}
                                  spids: [1186]
                                )
                              ]
                              redirects: []
                            )
                          ]
                          spids: [1180 1183 1190 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [(command.ControlFlow token:<Id.ControlFlow_Break break>)]
                          spids: [1193 1194 1200 -1]
                        )
                      ]
                      redirects: []
                    )
                    (C {<shift>})
                  ]
                )
              redirects: []
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<test>} {($ Id.VSub_Pound '#')} {<Id.Lit_Equals '='>} {<1>})
                (C {<die>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (C {<eval_gettext>} 
                            {
                              (DQ (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'> ch:'"') 
                                ($ Id.VSub_DollarName dashless) <' store'> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'> ch:'"') 
                                <' requires one <commit> argument'>
                              )
                            }
                          )
                        right: <Id.Eof_RParen _>
                      )
                    )
                  }
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'w_commit='> name:w_commit)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_Number 1))}
                  spids: [1241]
                )
              ]
              redirects: []
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [(C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName stash_msg))})]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'stash_msg='> name:stash_msg)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ <'Created via '> 
                                (word_part.EscapedLiteral
                                  token: <Id.Lit_EscapedChar '\\"'>
                                  ch: '"'
                                ) <'git stash store'> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'> ch:'"') <.>
                              )
                            }
                          spids: [1261]
                        )
                      ]
                      redirects: []
                    )
                  ]
                  spids: [1247 1258]
                )
              ]
              else_action: []
              redirects: []
            )
            (C {<git>} {<update-ref>} {<--create-reflog>} {<-m>} {(DQ ($ Id.VSub_DollarName stash_msg))} 
              {($ Id.VSub_DollarName ref_stash)} {($ Id.VSub_DollarName w_commit)}
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'ret='> name:ret)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_QMark '?')}
                  spids: [1292]
                )
              ]
              redirects: []
            )
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DAmp]
              children: [
                (C {<test>} {($ Id.VSub_DollarName ret)} {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<0>})
                (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName quiet))})
                (C {<die>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (C {<eval_gettext>} 
                            {
                              (DQ <'Cannot update '> 
                                (word_part.EscapedLiteral
                                  token: <Id.Lit_EscapedChar '\\$'>
                                  ch: '$'
                                ) <'ref_stash with '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'> ch:'$') <w_commit>
                              )
                            }
                          )
                        right: <Id.Eof_RParen _>
                      )
                    )
                  }
                )
              ]
            )
            (command.ControlFlow
              token: <Id.ControlFlow_Return return>
              arg_word: {($ Id.VSub_DollarName ret)}
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: save_stash
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'keep_index='> name:keep_index)
                  op: assign_op.Equal
                  rhs: (rhs_word.Empty)
                  spids: [1350]
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'patch_mode='> name:patch_mode)
                  op: assign_op.Equal
                  rhs: (rhs_word.Empty)
                  spids: [1353]
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'untracked='> name:untracked)
                  op: assign_op.Equal
                  rhs: (rhs_word.Empty)
                  spids: [1356]
                )
              ]
              redirects: []
            )
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (C {<test>} {($ Id.VSub_Pound '#')} {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<0>})
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_Number 1))}
                      arms: [
                        (case_arm
                          pat_list: [{<-k>} {<--keep-index>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.Name
                                      left: <Id.Lit_VarLike 'keep_index='>
                                      name: keep_index
                                    )
                                  op: assign_op.Equal
                                  rhs: {<t>}
                                  spids: [1389]
                                )
                              ]
                              redirects: []
                            )
                          ]
                          spids: [1383 1386 1393 -1]
                        )
                        (case_arm
                          pat_list: [{<--no-keep-index>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.Name
                                      left: <Id.Lit_VarLike 'keep_index='>
                                      name: keep_index
                                    )
                                  op: assign_op.Equal
                                  rhs: {<n>}
                                  spids: [1400]
                                )
                              ]
                              redirects: []
                            )
                          ]
                          spids: [1396 1397 1404 -1]
                        )
                        (case_arm
                          pat_list: [{<-p>} {<--patch>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.Name
                                      left: <Id.Lit_VarLike 'patch_mode='>
                                      name: patch_mode
                                    )
                                  op: assign_op.Equal
                                  rhs: {<t>}
                                  spids: [1413]
                                )
                              ]
                              redirects: []
                            )
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName keep_index))})
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: 
                                        (sh_lhs_expr.Name
                                          left: <Id.Lit_VarLike 'keep_index='>
                                          name: keep_index
                                        )
                                      op: assign_op.Equal
                                      rhs: {<t>}
                                      spids: [1431]
                                    )
                                  ]
                                  redirects: []
                                )
                              ]
                            )
                          ]
                          spids: [1407 1410 1435 -1]
                        )
                        (case_arm
                          pat_list: [{<-q>} {<--quiet>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.Name
                                      left: <Id.Lit_VarLike 'GIT_QUIET='>
                                      name: GIT_QUIET
                                    )
                                  op: assign_op.Equal
                                  rhs: {<t>}
                                  spids: [1444]
                                )
                              ]
                              redirects: []
                            )
                          ]
                          spids: [1438 1441 1448 -1]
                        )
                        (case_arm
                          pat_list: [{<-u>} {<--include-untracked>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.Name
                                      left: <Id.Lit_VarLike 'untracked='>
                                      name: untracked
                                    )
                                  op: assign_op.Equal
                                  rhs: {<untracked>}
                                  spids: [1457]
                                )
                              ]
                              redirects: []
                            )
                          ]
                          spids: [1451 1454 1461 -1]
                        )
                        (case_arm
                          pat_list: [{<-a>} {<--all>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.Name
                                      left: <Id.Lit_VarLike 'untracked='>
                                      name: untracked
                                    )
                                  op: assign_op.Equal
                                  rhs: {<all>}
                                  spids: [1470]
                                )
                              ]
                              redirects: []
                            )
                          ]
                          spids: [1464 1467 1474 -1]
                        )
                        (case_arm
                          pat_list: [{<--help>}]
                          action: [(C {<show_help>})]
                          spids: [1477 1478 1484 -1]
                        )
                        (case_arm
                          pat_list: [{<-->}]
                          action: [
                            (C {<shift>})
                            (command.ControlFlow
                              token: <Id.ControlFlow_Break break>
                            )
                          ]
                          spids: [1487 1488 1497 -1]
                        )
                        (case_arm
                          pat_list: [{<-> <Id.Lit_Star '*'>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'option='> name:option)
                                  op: assign_op.Equal
                                  rhs: {(DQ ($ Id.VSub_Number 1))}
                                  spids: [1505]
                                )
                              ]
                              redirects: []
                            )
                            (C {<eval_gettextln>} 
                              {
                                (DQ <'error: unknown option for \'stash save\': '> 
                                  (word_part.EscapedLiteral
                                    token: <Id.Lit_EscapedChar '\\$'>
                                    ch: '$'
                                  ) <'option\n'> <'       To provide a message, use git stash save -- \''> 
                                  (word_part.EscapedLiteral
                                    token: <Id.Lit_EscapedChar '\\$'>
                                    ch: '$'
                                  ) <'option\''>
                                )
                              }
                            )
                            (C {<usage>})
                          ]
                          spids: [1500 1502 1566 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [(command.ControlFlow token:<Id.ControlFlow_Break break>)]
                          spids: [1569 1570 1576 -1]
                        )
                      ]
                      redirects: []
                    )
                    (C {<shift>})
                  ]
                )
              redirects: []
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.AndOr
                          ops: [Id.Op_DAmp]
                          children: [
                            (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName patch_mode))})
                            (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName untracked))})
                          ]
                        )
                      ]
                    )
                  action: [
                    (C {<die>} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (C {<gettext>} 
                                {
                                  (DQ 
                                    <
'Can\'t use --patch and --include-untracked or --all at the same time'
                                    >
                                  )
                                }
                              )
                            right: <Id.Eof_RParen _>
                          )
                        )
                      }
                    )
                  ]
                  spids: [1589 1610]
                )
              ]
              else_action: []
              redirects: []
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'stash_msg='> name:stash_msg)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_Star '*'))}
                  spids: [1630]
                )
              ]
              redirects: []
            )
            (C {<git>} {<update-index>} {<-q>} {<--refresh>})
            (command.If
              arms: [
                (if_arm
                  cond: (condition.Shell commands:[(C {<no_changes>})])
                  action: [
                    (C {<say>} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: (C {<gettext>} {(DQ <'No local changes to save'>)})
                            right: <Id.Eof_RParen _>
                          )
                        )
                      }
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Exit exit>
                      arg_word: {<0>}
                    )
                  ]
                  spids: [1646 1651]
                )
              ]
              else_action: []
              redirects: []
            )
            (command.AndOr
              ops: [Id.Op_DPipe Id.Op_DPipe]
              children: [
                (C {<git>} {<reflog>} {<exists>} {($ Id.VSub_DollarName ref_stash)})
                (C {<clear_stash>})
                (C {<die>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<gettext>} {(DQ <'Cannot initialize stash'>)})
                        right: <Id.Eof_RParen _>
                      )
                    )
                  }
                )
              ]
            )
            (C {<create_stash>} {(DQ ($ Id.VSub_DollarName stash_msg))} 
              {($ Id.VSub_DollarName untracked)}
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<store_stash>} {<-m>} {(DQ ($ Id.VSub_DollarName stash_msg))} {<-q>} 
                  {($ Id.VSub_DollarName w_commit)}
                )
                (C {<die>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<gettext>} {(DQ <'Cannot save the current status'>)})
                        right: <Id.Eof_RParen _>
                      )
                    )
                  }
                )
              ]
            )
            (C {<say>} 
              {
                (DQ 
                  (command_sub
                    left_token: <Id.Left_DollarParen '$('>
                    child: 
                      (C {<eval_gettext>} 
                        {
                          (DQ <'Saved working directory and index state '> 
                            (word_part.EscapedLiteral
                              token: <Id.Lit_EscapedChar '\\$'>
                              ch: '$'
                            ) <stash_msg>
                          )
                        }
                      )
                    right: <Id.Eof_RParen _>
                  )
                )
              }
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [(C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName patch_mode))})]
                    )
                  action: [
                    (C {<git>} {<reset>} {<--hard>} 
                      {
                        (braced_var_sub
                          left: <Id.Left_DollarBrace '${'>
                          token: <Id.VSub_Name GIT_QUIET>
                          var_name: GIT_QUIET
                          suffix_op: (suffix_op.Unary op:<Id.VTest_ColonPlus _> arg_word:{<-q>})
                          right: <Id.Right_DollarBrace '}'>
                        )
                      }
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp Id.Op_DPipe]
                      children: [
                        (C {<test>} {(DQ ($ Id.VSub_DollarName untracked))} {<Id.Lit_Equals '='>} 
                          {(DQ <all>)}
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: 
                                (sh_lhs_expr.Name
                                  left: <Id.Lit_VarLike 'CLEAN_X_OPTION='>
                                  name: CLEAN_X_OPTION
                                )
                              op: assign_op.Equal
                              rhs: {<-x>}
                              spids: [1798]
                            )
                          ]
                          redirects: []
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: 
                                (sh_lhs_expr.Name
                                  left: <Id.Lit_VarLike 'CLEAN_X_OPTION='>
                                  name: CLEAN_X_OPTION
                                )
                              op: assign_op.Equal
                              rhs: (rhs_word.Empty)
                              spids: [1803]
                            )
                          ]
                          redirects: []
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [(C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName untracked))})]
                            )
                          action: [
                            (C {<git>} {<clean>} {<--force>} {<--quiet>} {<-d>} 
                              {($ Id.VSub_DollarName CLEAN_X_OPTION)}
                            )
                          ]
                          spids: [1806 1817]
                        )
                      ]
                      else_action: []
                      redirects: []
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.AndOr
                                  ops: [Id.Op_DAmp]
                                  children: [
                                    (C {<test>} {(DQ ($ Id.VSub_DollarName keep_index))} 
                                      {<Id.Lit_Equals '='>} {(DQ <t>)}
                                    )
                                    (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName i_tree))})
                                  ]
                                )
                              ]
                            )
                          action: [
                            (C {<git>} {<read-tree>} {<--reset>} {<-u>} {($ Id.VSub_DollarName i_tree)})
                          ]
                          spids: [1837 1862]
                        )
                      ]
                      else_action: []
                      redirects: []
                    )
                  ]
                  spids: [1757 1768]
                )
              ]
              else_action: [
                (command.AndOr
                  ops: [Id.Op_DPipe]
                  children: [
                    (command.Simple
                      words: [{<git>} {<apply>} {<-R>}]
                      redirects: [
                        (redir
                          op: <Id.Redir_Less '<'>
                          loc: (redir_loc.Fd fd:0)
                          arg: {(DQ ($ Id.VSub_DollarName TMP) <-patch>)}
                        )
                      ]
                      more_env: []
                      do_fork: T
                    )
                    (C {<die>} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: (C {<gettext>} {(DQ <'Cannot remove worktree changes'>)})
                            right: <Id.Eof_RParen _>
                          )
                        )
                      }
                    )
                  ]
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (C {<test>} {(DQ ($ Id.VSub_DollarName keep_index))} 
                              {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ <t>)}
                            )
                          ]
                        )
                      action: [(C {<git>} {<reset>})]
                      spids: [1912 1928]
                    )
                  ]
                  else_action: []
                  redirects: []
                )
              ]
              redirects: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: have_stash
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.Simple
              words: [{<git>} {<rev-parse>} {<--verify>} {<--quiet>} {($ Id.VSub_DollarName ref_stash)}]
              redirects: [(redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<'/dev/null'>})]
              more_env: []
              do_fork: T
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: list_stash
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<have_stash>})
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {<0>}
                )
              ]
            )
            (C {<git>} {<log>} {<--format> <Id.Lit_Equals '='> (DQ <'%gd: %gs'>)} {<-g>} 
              {<--first-parent>} {<-m>} {(DQ ($ Id.VSub_At '@'))} {($ Id.VSub_DollarName ref_stash)} {<-->}
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: show_stash
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: 
                    (sh_lhs_expr.Name
                      left: <Id.Lit_VarLike 'ALLOW_UNKNOWN_FLAGS='>
                      name: ALLOW_UNKNOWN_FLAGS
                    )
                  op: assign_op.Equal
                  rhs: {<t>}
                  spids: [2020]
                )
              ]
              redirects: []
            )
            (C {<assert_stash_like>} {(DQ ($ Id.VSub_At '@'))})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [(C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName FLAGS))})]
                    )
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (C {<test>} 
                                  {
                                    (DQ 
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (command.AndOr
                                            ops: [Id.Op_DPipe]
                                            children: [
                                              (C {<git>} {<config>} {<--bool>} {<stash.showStat>})
                                              (C {<echo>} {<true>})
                                            ]
                                          )
                                        right: <Id.Eof_RParen _>
                                      )
                                    )
                                  } {<Id.Lit_Equals '='>} {(DQ <true>)}
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'FLAGS='> name:FLAGS)
                                  op: assign_op.Equal
                                  rhs: {<--stat>}
                                  spids: [2078]
                                )
                              ]
                              redirects: []
                            )
                          ]
                          spids: [2046 2075]
                        )
                      ]
                      else_action: []
                      redirects: []
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (C {<test>} 
                                  {
                                    (DQ 
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (command.AndOr
                                            ops: [Id.Op_DPipe]
                                            children: [
                                              (C {<git>} {<config>} {<--bool>} {<stash.showPatch>})
                                              (C {<echo>} {<false>})
                                            ]
                                          )
                                        right: <Id.Eof_RParen _>
                                      )
                                    )
                                  } {<Id.Lit_Equals '='>} {(DQ <true>)}
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'FLAGS='> name:FLAGS)
                                  op: assign_op.Equal
                                  rhs: 
                                    {(${ Id.VSub_Name FLAGS) 
                                      (braced_var_sub
                                        left: <Id.Left_DollarBrace '${'>
                                        token: <Id.VSub_Name FLAGS>
                                        var_name: FLAGS
                                        suffix_op: 
                                          (suffix_op.Unary
                                            op: <Id.VTest_ColonPlus _>
                                            arg_word: {<' '>}
                                          )
                                        right: <Id.Right_DollarBrace '}'>
                                      ) <-p>
                                    }
                                  spids: [2118]
                                )
                              ]
                              redirects: []
                            )
                          ]
                          spids: [2086 2115]
                        )
                      ]
                      else_action: []
                      redirects: []
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [(C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName FLAGS))})]
                            )
                          action: [
                            (command.ControlFlow
                              token: <Id.ControlFlow_Return return>
                              arg_word: {<0>}
                            )
                          ]
                          spids: [2134 2145]
                        )
                      ]
                      else_action: []
                      redirects: []
                    )
                  ]
                  spids: [2032 2043]
                )
              ]
              else_action: []
              redirects: []
            )
            (C {<git>} {<diff>} {(${ Id.VSub_Name FLAGS)} {($ Id.VSub_DollarName b_commit)} 
              {($ Id.VSub_DollarName w_commit)}
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: show_help
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (C {<exec>} {<git>} {<help>} {<stash>})
            (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: parse_flags_and_rev
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<test>} {(DQ ($ Id.VSub_DollarName PARSE_CACHE))} {<Id.Lit_Equals '='>} 
                  {(DQ ($ Id.VSub_Star '*'))}
                )
                (command.ControlFlow
                  token: <Id.ControlFlow_Return return>
                  arg_word: {<0>}
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'PARSE_CACHE='> name:PARSE_CACHE)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_Star '*'))}
                  spids: [2334]
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'IS_STASH_LIKE='> name:IS_STASH_LIKE)
                  op: assign_op.Equal
                  rhs: (rhs_word.Empty)
                  spids: [2341]
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'IS_STASH_REF='> name:IS_STASH_REF)
                  op: assign_op.Equal
                  rhs: (rhs_word.Empty)
                  spids: [2344]
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'INDEX_OPTION='> name:INDEX_OPTION)
                  op: assign_op.Equal
                  rhs: (rhs_word.Empty)
                  spids: [2347]
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 's='> name:s)
                  op: assign_op.Equal
                  rhs: (rhs_word.Empty)
                  spids: [2350]
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'w_commit='> name:w_commit)
                  op: assign_op.Equal
                  rhs: (rhs_word.Empty)
                  spids: [2353]
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'b_commit='> name:b_commit)
                  op: assign_op.Equal
                  rhs: (rhs_word.Empty)
                  spids: [2356]
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'i_commit='> name:i_commit)
                  op: assign_op.Equal
                  rhs: (rhs_word.Empty)
                  spids: [2359]
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'u_commit='> name:u_commit)
                  op: assign_op.Equal
                  rhs: (rhs_word.Empty)
                  spids: [2362]
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'w_tree='> name:w_tree)
                  op: assign_op.Equal
                  rhs: (rhs_word.Empty)
                  spids: [2365]
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'b_tree='> name:b_tree)
                  op: assign_op.Equal
                  rhs: (rhs_word.Empty)
                  spids: [2368]
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'i_tree='> name:i_tree)
                  op: assign_op.Equal
                  rhs: (rhs_word.Empty)
                  spids: [2371]
                )
              ]
              redirects: []
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'u_tree='> name:u_tree)
                  op: assign_op.Equal
                  rhs: (rhs_word.Empty)
                  spids: [2374]
                )
              ]
              redirects: []
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'REV='> name:REV)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (C {<git>} {<rev-parse>} {<--no-flags>} {<--symbolic>} {<--sq>} 
                                {(DQ ($ Id.VSub_At '@'))}
                              )
                            right: <Id.Eof_RParen _>
                          )
                        }
                      spids: [2378]
                    )
                  ]
                  redirects: []
                )
                (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'FLAGS='> name:FLAGS)
                  op: assign_op.Equal
                  rhs: (rhs_word.Empty)
                  spids: [2403]
                )
              ]
              redirects: []
            )
            (command.ForEach
              iter_names: [opt]
              iterable: (for_iter.Args)
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_DollarName opt))}
                      arms: [
                        (case_arm
                          pat_list: [{<-q>} {<--quiet>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.Name
                                      left: <Id.Lit_VarLike 'GIT_QUIET='>
                                      name: GIT_QUIET
                                    )
                                  op: assign_op.Equal
                                  rhs: {<-t>}
                                  spids: [2429]
                                )
                              ]
                              redirects: []
                            )
                          ]
                          spids: [2423 2426 2433 -1]
                        )
                        (case_arm
                          pat_list: [{<--index>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.Name
                                      left: <Id.Lit_VarLike 'INDEX_OPTION='>
                                      name: INDEX_OPTION
                                    )
                                  op: assign_op.Equal
                                  rhs: {<--index>}
                                  spids: [2440]
                                )
                              ]
                              redirects: []
                            )
                          ]
                          spids: [2436 2437 2444 -1]
                        )
                        (case_arm
                          pat_list: [{<--help>}]
                          action: [(C {<show_help>})]
                          spids: [2447 2448 2454 -1]
                        )
                        (case_arm
                          pat_list: [{<-> <Id.Lit_Star '*'>}]
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (C {<test>} {(DQ ($ Id.VSub_DollarName ALLOW_UNKNOWN_FLAGS))} 
                                  {<Id.Lit_Equals '='>} {<t>}
                                )
                                (C {<die>} 
                                  {
                                    (DQ 
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (C {<eval_gettext>} 
                                            {
                                              (DQ <'unknown option: '> 
                                                (word_part.EscapedLiteral
                                                  token: <Id.Lit_EscapedChar '\\$'>
                                                  ch: '$'
                                                ) <opt>
                                              )
                                            }
                                          )
                                        right: <Id.Eof_RParen _>
                                      )
                                    )
                                  }
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'FLAGS='> name:FLAGS)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ (${ Id.VSub_Name FLAGS) 
                                        (braced_var_sub
                                          left: <Id.Left_DollarBrace '${'>
                                          token: <Id.VSub_Name FLAGS>
                                          var_name: FLAGS
                                          suffix_op: 
                                            (suffix_op.Unary
                                              op: <Id.VTest_ColonPlus _>
                                              arg_word: {<' '>}
                                            )
                                          right: <Id.Right_DollarBrace '}'>
                                        ) ($ Id.VSub_DollarName opt)
                                      )
                                    }
                                  spids: [2490]
                                )
                              ]
                              redirects: []
                            )
                          ]
                          spids: [2457 2459 2504 -1]
                        )
                      ]
                      redirects: []
                    )
                  ]
                )
              redirects: []
            )
            (C {<eval>} {<set>} {<-->} {($ Id.VSub_DollarName REV)})
            (command.Case
              to_match: {($ Id.VSub_Pound '#')}
              arms: [
                (case_arm
                  pat_list: [{<0>}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<have_stash>})
                        (C {<die>} 
                          {
                            (DQ 
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: (C {<gettext>} {(DQ <'No stash found.'>)})
                                right: <Id.Eof_RParen _>
                              )
                            )
                          }
                        )
                      ]
                    )
                    (C {<set>} {<-->} 
                      {(${ Id.VSub_Name ref_stash) <Id.Lit_At '@'> <Id.Lit_LBrace '{'> <0> 
                        <Id.Lit_RBrace '}'>
                      }
                    )
                  ]
                  spids: [2531 2532 2565 -1]
                )
                (case_arm
                  pat_list: [{<1>}]
                  action: [(C {<Id.Lit_Colon ':'>})]
                  spids: [2568 2569 2575 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (C {<die>} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (C {<eval_gettext>} 
                                {
                                  (DQ <'Too many revisions specified: '> 
                                    (word_part.EscapedLiteral
                                      token: <Id.Lit_EscapedChar '\\$'>
                                      ch: '$'
                                    ) <REV>
                                  )
                                }
                              )
                            right: <Id.Eof_RParen _>
                          )
                        )
                      }
                    )
                  ]
                  spids: [2578 2579 2597 -1]
                )
              ]
              redirects: []
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'REV='> name:REV)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (C {<git>} {<rev-parse>} {<--symbolic>} {<--verify>} {<--quiet>} 
                                {(DQ ($ Id.VSub_Number 1))}
                              )
                            right: <Id.Eof_RParen _>
                          )
                        }
                      spids: [2604]
                    )
                  ]
                  redirects: []
                )
                (BraceGroup
                  left: <Id.Lit_LBrace '{'>
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'reference='> name:reference)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_Number 1))}
                          spids: [2626]
                        )
                      ]
                      redirects: []
                    )
                    (C {<die>} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (C {<eval_gettext>} 
                                {
                                  (DQ 
                                    (word_part.EscapedLiteral
                                      token: <Id.Lit_EscapedChar '\\$'>
                                      ch: '$'
                                    ) <'reference is not a valid reference'>
                                  )
                                }
                              )
                            right: <Id.Eof_RParen _>
                          )
                        )
                      }
                    )
                  ]
                  redirects: []
                  right: <Id.Lit_RBrace '}'>
                )
              ]
            )
            (command.AndOr
              ops: [
                Id.Op_DAmp
                Id.Op_DAmp
                Id.Op_DAmp
                Id.Op_DAmp
                Id.Op_DAmp
                Id.Op_DAmp
                Id.Op_DAmp
                Id.Op_DAmp
                Id.Op_DAmp
                Id.Op_DAmp
              ]
              children: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'i_commit='> name:i_commit)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (C {<git>} {<rev-parse>} {<--verify>} {<--quiet>} 
                                {(DQ ($ Id.VSub_DollarName REV) <'^2'>)}
                              )
                            right: <Id.Eof_RParen _>
                          )
                        }
                      spids: [2650]
                    )
                  ]
                  redirects: []
                )
                (C {<set>} {<-->} 
                  {
                    (command_sub
                      left_token: <Id.Left_DollarParen '$('>
                      child: 
                        (command.Simple
                          words: [
                            {<git>}
                            {<rev-parse>}
                            {(DQ ($ Id.VSub_DollarName REV))}
                            {(DQ ($ Id.VSub_DollarName REV) <'^1'>)}
                            {(DQ ($ Id.VSub_DollarName REV) <':'>)}
                            {(DQ ($ Id.VSub_DollarName REV) <'^1:'>)}
                            {(DQ ($ Id.VSub_DollarName REV) <'^2:'>)}
                          ]
                          redirects: [
                            (redir
                              op: <Id.Redir_Great '2>'>
                              loc: (redir_loc.Fd fd:2)
                              arg: {<'/dev/null'>}
                            )
                          ]
                          more_env: []
                          do_fork: T
                        )
                      right: <Id.Eof_RParen _>
                    )
                  }
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 's='> name:s)
                      op: assign_op.Equal
                      rhs: {($ Id.VSub_Number 1)}
                      spids: [2709]
                    )
                  ]
                  redirects: []
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'w_commit='> name:w_commit)
                      op: assign_op.Equal
                      rhs: {($ Id.VSub_Number 1)}
                      spids: [2715]
                    )
                  ]
                  redirects: []
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'b_commit='> name:b_commit)
                      op: assign_op.Equal
                      rhs: {($ Id.VSub_Number 2)}
                      spids: [2721]
                    )
                  ]
                  redirects: []
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'w_tree='> name:w_tree)
                      op: assign_op.Equal
                      rhs: {($ Id.VSub_Number 3)}
                      spids: [2727]
                    )
                  ]
                  redirects: []
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'b_tree='> name:b_tree)
                      op: assign_op.Equal
                      rhs: {($ Id.VSub_Number 4)}
                      spids: [2733]
                    )
                  ]
                  redirects: []
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'i_tree='> name:i_tree)
                      op: assign_op.Equal
                      rhs: {($ Id.VSub_Number 5)}
                      spids: [2739]
                    )
                  ]
                  redirects: []
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: 
                        (sh_lhs_expr.Name
                          left: <Id.Lit_VarLike 'IS_STASH_LIKE='>
                          name: IS_STASH_LIKE
                        )
                      op: assign_op.Equal
                      rhs: {<t>}
                      spids: [2745]
                    )
                  ]
                  redirects: []
                )
                (C {<test>} {(DQ ($ Id.VSub_DollarName ref_stash))} {<Id.Lit_Equals '='>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (C {<git>} {<rev-parse>} {<--symbolic-full-name>} 
                            {
                              (DQ 
                                (braced_var_sub
                                  left: <Id.Left_DollarBrace '${'>
                                  token: <Id.VSub_Name REV>
                                  var_name: REV
                                  suffix_op: 
                                    (suffix_op.Unary
                                      op: <Id.VOp1_Percent '%'>
                                      arg_word: {<Id.Lit_Other '@'> <Id.Lit_Other '*'>}
                                    )
                                  right: <Id.Right_DollarBrace '}'>
                                )
                              )
                            }
                          )
                        right: <Id.Eof_RParen _>
                      )
                    )
                  }
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'IS_STASH_REF='> name:IS_STASH_REF)
                      op: assign_op.Equal
                      rhs: {<t>}
                      spids: [2781]
                    )
                  ]
                  redirects: []
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'u_commit='> name:u_commit)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (C {<git>} {<rev-parse>} {<--verify>} {<--quiet>} 
                                {(DQ ($ Id.VSub_DollarName REV) <'^3'>)}
                              )
                            right: <Id.Eof_RParen _>
                          )
                        }
                      spids: [2786]
                    )
                  ]
                  redirects: []
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'u_tree='> name:u_tree)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (command.Simple
                                words: [{<git>} {<rev-parse>} {(DQ ($ Id.VSub_DollarName REV) <'^3:'>)}]
                                redirects: [
                                  (redir
                                    op: <Id.Redir_Great '2>'>
                                    loc: (redir_loc.Fd fd:2)
                                    arg: {<'/dev/null'>}
                                  )
                                ]
                                more_env: []
                                do_fork: T
                              )
                            right: <Id.Eof_RParen _>
                          )
                        }
                      spids: [2805]
                    )
                  ]
                  redirects: []
                )
              ]
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: is_stash_like
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (C {<parse_flags_and_rev>} {(DQ ($ Id.VSub_At '@'))})
            (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName IS_STASH_LIKE))})
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: assert_stash_like
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<is_stash_like>} {(DQ ($ Id.VSub_At '@'))})
                (BraceGroup
                  left: <Id.Lit_LBrace '{'>
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'args='> name:args)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_Star '*'))}
                          spids: [2866]
                        )
                      ]
                      redirects: []
                    )
                    (C {<die>} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (C {<eval_gettext>} 
                                {
                                  (DQ <'\''> 
                                    (word_part.EscapedLiteral
                                      token: <Id.Lit_EscapedChar '\\$'>
                                      ch: '$'
                                    ) <'args\' is not a stash-like commit'>
                                  )
                                }
                              )
                            right: <Id.Eof_RParen _>
                          )
                        )
                      }
                    )
                  ]
                  redirects: []
                  right: <Id.Lit_RBrace '}'>
                )
              ]
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: is_stash_ref
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<is_stash_like>} {(DQ ($ Id.VSub_At '@'))})
                (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName IS_STASH_REF))})
              ]
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: assert_stash_ref
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<is_stash_ref>} {(DQ ($ Id.VSub_At '@'))})
                (BraceGroup
                  left: <Id.Lit_LBrace '{'>
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'args='> name:args)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_Star '*'))}
                          spids: [2936]
                        )
                      ]
                      redirects: []
                    )
                    (C {<die>} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (C {<eval_gettext>} 
                                {
                                  (DQ <'\''> 
                                    (word_part.EscapedLiteral
                                      token: <Id.Lit_EscapedChar '\\$'>
                                      ch: '$'
                                    ) <'args\' is not a stash reference'>
                                  )
                                }
                              )
                            right: <Id.Eof_RParen _>
                          )
                        )
                      }
                    )
                  ]
                  redirects: []
                  right: <Id.Lit_RBrace '}'>
                )
              ]
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: apply_stash
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (C {<assert_stash_like>} {(DQ ($ Id.VSub_At '@'))})
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<git>} {<update-index>} {<-q>} {<--refresh>})
                (C {<die>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<gettext>} {(DQ <'unable to refresh index'>)})
                        right: <Id.Eof_RParen _>
                      )
                    )
                  }
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'c_tree='> name:c_tree)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: (C {<git>} {<write-tree>})
                            right: <Id.Eof_RParen _>
                          )
                        }
                      spids: [3007]
                    )
                  ]
                  redirects: []
                )
                (C {<die>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<gettext>} {(DQ <'Cannot apply a stash in the middle of a merge'>)})
                        right: <Id.Eof_RParen _>
                      )
                    )
                  }
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: 
                    (sh_lhs_expr.Name
                      left: <Id.Lit_VarLike 'unstashed_index_tree='>
                      name: unstashed_index_tree
                    )
                  op: assign_op.Equal
                  rhs: (rhs_word.Empty)
                  spids: [3031]
                )
              ]
              redirects: []
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.AndOr
                          ops: [Id.Op_DAmp Id.Op_DAmp]
                          children: [
                            (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName INDEX_OPTION))})
                            (C {<test>} {(DQ ($ Id.VSub_DollarName b_tree))} 
                              {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ ($ Id.VSub_DollarName i_tree))}
                            )
                            (C {<test>} {(DQ ($ Id.VSub_DollarName c_tree))} 
                              {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ ($ Id.VSub_DollarName i_tree))}
                            )
                          ]
                        )
                      ]
                    )
                  action: [
                    (command.Pipeline
                      children: [
                        (C {<git>} {<diff-tree>} {<--binary>} 
                          {($ Id.VSub_DollarName s) <Id.Lit_Other '^'> <2> <Id.Lit_Other '^'> <..> 
                            ($ Id.VSub_DollarName s) <Id.Lit_Other '^'> <2>
                          }
                        )
                        (C {<git>} {<apply>} {<--cached>})
                      ]
                      negated: F
                      stderr_indices: []
                    )
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<test>} {($ Id.VSub_QMark '?')} {<-ne>} {<0>})
                        (C {<die>} 
                          {
                            (DQ 
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<gettext>} {(DQ <'Conflicts in index. Try without --index.'>)})
                                right: <Id.Eof_RParen _>
                              )
                            )
                          }
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: 
                                (sh_lhs_expr.Name
                                  left: <Id.Lit_VarLike 'unstashed_index_tree='>
                                  name: unstashed_index_tree
                                )
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: (C {<git>} {<write-tree>})
                                    right: <Id.Eof_RParen _>
                                  )
                                }
                              spids: [3127]
                            )
                          ]
                          redirects: []
                        )
                        (C {<die>} 
                          {
                            (DQ 
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: (C {<gettext>} {(DQ <'Could not save index tree'>)})
                                right: <Id.Eof_RParen _>
                              )
                            )
                          }
                        )
                      ]
                    )
                    (C {<git>} {<reset>})
                  ]
                  spids: [3034 3076]
                )
              ]
              else_action: []
              redirects: []
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [(C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName u_tree))})]
                    )
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp Id.Op_DAmp Id.Op_DPipe]
                      children: [
                        (command.Simple
                          words: [{<git-read-tree>} {(DQ ($ Id.VSub_DollarName u_tree))}]
                          redirects: []
                          more_env: [
                            (env_pair
                              name: GIT_INDEX_FILE
                              val: {(DQ ($ Id.VSub_DollarName TMPindex))}
                              spids: [3173]
                            )
                          ]
                          do_fork: T
                        )
                        (command.Simple
                          words: [{<git>} {<checkout-index>} {<--all>}]
                          redirects: []
                          more_env: [
                            (env_pair
                              name: GIT_INDEX_FILE
                              val: {(DQ ($ Id.VSub_DollarName TMPindex))}
                              spids: [3187]
                            )
                          ]
                          do_fork: T
                        )
                        (C {<rm>} {<-f>} {(DQ ($ Id.VSub_DollarName TMPindex))})
                        (C {<die>} 
                          {
                            (DQ 
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<gettext>} {(DQ <'Could not restore untracked files from stash'>)})
                                right: <Id.Eof_RParen _>
                              )
                            )
                          }
                        )
                      ]
                    )
                  ]
                  spids: [3159 3170]
                )
              ]
              else_action: []
              redirects: []
            )
            (C {<eval>} 
              {
                (DQ <'\n'> <'\t\tGITHEAD_'> ($ Id.VSub_DollarName w_tree) <'=\'Stashed changes\' &&\n'> 
                  <'\t\tGITHEAD_'> ($ Id.VSub_DollarName c_tree) <'=\'Updated upstream\' &&\n'> <'\t\tGITHEAD_'> 
                  ($ Id.VSub_DollarName b_tree) <'=\'Version stash was based on\' &&\n'> <'\t\texport GITHEAD_'> ($ Id.VSub_DollarName w_tree) 
                  <' GITHEAD_'> ($ Id.VSub_DollarName c_tree) <' GITHEAD_'> ($ Id.VSub_DollarName b_tree) <'\n'> <'\t'>
                )
              }
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [(C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName GIT_QUIET))})]
                    )
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: 
                                (sh_lhs_expr.Name
                                  left: <Id.Lit_VarLike 'GIT_MERGE_VERBOSITY='>
                                  name: GIT_MERGE_VERBOSITY
                                )
                              op: assign_op.Equal
                              rhs: {<0>}
                              spids: [3268]
                            )
                          ]
                          redirects: []
                        )
                        (C {<export>} {<GIT_MERGE_VERBOSITY>})
                      ]
                    )
                  ]
                  spids: [3254 3265]
                )
              ]
              else_action: []
              redirects: []
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (C {<git>} {<merge-recursive>} {($ Id.VSub_DollarName b_tree)} {<-->} 
                          {($ Id.VSub_DollarName c_tree)} {($ Id.VSub_DollarName w_tree)}
                        )
                      ]
                    )
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName unstashed_index_tree))})
                              ]
                            )
                          action: [
                            (C {<git>} {<read-tree>} {(DQ ($ Id.VSub_DollarName unstashed_index_tree))})
                          ]
                          spids: [3303 3314]
                        )
                      ]
                      else_action: [
                        (command.AndOr
                          ops: [Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp Id.Op_DPipe]
                          children: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'a='> name:a)
                                  op: assign_op.Equal
                                  rhs: {(DQ ($ Id.VSub_DollarName TMP) <-added>)}
                                  spids: [3329]
                                )
                              ]
                              redirects: []
                            )
                            (command.Simple
                              words: [
                                {<git>}
                                {<diff-index>}
                                {<--cached>}
                                {<--name-only>}
                                {<--diff-filter> <Id.Lit_Equals '='> <A>}
                                {($ Id.VSub_DollarName c_tree)}
                              ]
                              redirects: [
                                (redir
                                  op: <Id.Redir_Great '>'>
                                  loc: (redir_loc.Fd fd:1)
                                  arg: {(DQ ($ Id.VSub_DollarName a))}
                                )
                              ]
                              more_env: []
                              do_fork: T
                            )
                            (C {<git>} {<read-tree>} {<--reset>} {($ Id.VSub_DollarName c_tree)})
                            (command.Simple
                              words: [{<git>} {<update-index>} {<--add>} {<--stdin>}]
                              redirects: [
                                (redir
                                  op: <Id.Redir_Less '<'>
                                  loc: (redir_loc.Fd fd:0)
                                  arg: {(DQ ($ Id.VSub_DollarName a))}
                                )
                              ]
                              more_env: []
                              do_fork: T
                            )
                            (C {<die>} 
                              {
                                (DQ 
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: (C {<gettext>} {(DQ <'Cannot unstage modified files'>)})
                                    right: <Id.Eof_RParen _>
                                  )
                                )
                              }
                            )
                          ]
                        )
                        (C {<rm>} {<-f>} {(DQ ($ Id.VSub_DollarName a))})
                      ]
                      redirects: []
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'squelch='> name:squelch)
                          op: assign_op.Equal
                          rhs: (rhs_word.Empty)
                          spids: [3412]
                        )
                      ]
                      redirects: []
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [(C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName GIT_QUIET))})]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.Name
                                      left: <Id.Lit_VarLike 'squelch='>
                                      name: squelch
                                    )
                                  op: assign_op.Equal
                                  rhs: {(SQ <'>/dev/null 2>&1'>)}
                                  spids: [3429]
                                )
                              ]
                              redirects: []
                            )
                          ]
                          spids: [3415 3426]
                        )
                      ]
                      else_action: []
                      redirects: []
                    )
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (command.Subshell
                          child: 
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<cd>} {(DQ ($ Id.VSub_DollarName START_DIR))})
                                (C {<eval>} {(DQ <'git status '> ($ Id.VSub_DollarName squelch))})
                              ]
                            )
                          redirects: []
                        )
                        (C {<Id.Lit_Colon ':'>})
                      ]
                    )
                  ]
                  spids: [3281 3296]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'status='> name:status)
                      op: assign_op.Equal
                      rhs: {($ Id.VSub_QMark '?')}
                      spids: [3467]
                    )
                  ]
                  redirects: []
                )
                (C {<git>} {<rerere>})
                (command.If
                  arms: [
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [(C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName INDEX_OPTION))})]
                        )
                      action: [
                        (command.Simple
                          words: [{<gettextln>} {(DQ <'Index was not unstashed.'>)}]
                          redirects: [
                            (redir
                              op: <Id.Redir_GreatAnd '>&'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<2>}
                            )
                          ]
                          more_env: []
                          do_fork: T
                        )
                      ]
                      spids: [3476 3487]
                    )
                  ]
                  else_action: []
                  redirects: []
                )
                (command.ControlFlow
                  token: <Id.ControlFlow_Exit exit>
                  arg_word: {($ Id.VSub_DollarName status)}
                )
              ]
              redirects: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: pop_stash
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (C {<assert_stash_ref>} {(DQ ($ Id.VSub_At '@'))})
            (command.If
              arms: [
                (if_arm
                  cond: (condition.Shell commands:[(C {<apply_stash>} {(DQ ($ Id.VSub_At '@'))})])
                  action: [(C {<drop_stash>} {(DQ ($ Id.VSub_At '@'))})]
                  spids: [3528 3537]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'status='> name:status)
                      op: assign_op.Equal
                      rhs: {($ Id.VSub_QMark '?')}
                      spids: [3550]
                    )
                  ]
                  redirects: []
                )
                (C {<say>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<gettext>} {(DQ <'The stash is kept in case you need it again.'>)})
                        right: <Id.Eof_RParen _>
                      )
                    )
                  }
                )
                (command.ControlFlow
                  token: <Id.ControlFlow_Exit exit>
                  arg_word: {($ Id.VSub_DollarName status)}
                )
              ]
              redirects: []
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: drop_stash
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (C {<assert_stash_ref>} {(DQ ($ Id.VSub_At '@'))})
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DPipe]
              children: [
                (C {<git>} {<reflog>} {<delete>} {<--updateref>} {<--rewrite>} {(DQ (${ Id.VSub_Name REV))})
                (C {<say>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (C {<eval_gettext>} 
                            {
                              (DQ <'Dropped '> 
                                (word_part.EscapedLiteral
                                  token: <Id.Lit_EscapedChar '\\$'>
                                  ch: '$'
                                ) <'{REV} ('> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'> ch:'$') <'s)'>
                              )
                            }
                          )
                        right: <Id.Eof_RParen _>
                      )
                    )
                  }
                )
                (C {<die>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (C {<eval_gettext>} 
                            {
                              (DQ (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'> ch:'$') 
                                <'{REV}: Could not drop stash entry'>
                              )
                            }
                          )
                        right: <Id.Eof_RParen _>
                      )
                    )
                  }
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.Simple
                  words: [
                    {<git>}
                    {<rev-parse>}
                    {<--verify>}
                    {<--quiet>}
                    {(DQ ($ Id.VSub_DollarName ref_stash) <'@{0}'>)}
                  ]
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {<'/dev/null'>}
                    )
                  ]
                  more_env: []
                  do_fork: T
                )
                (C {<clear_stash>})
              ]
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShFunction
      name: apply_to_branch
      body: 
        (BraceGroup
          left: <Id.Lit_LBrace '{'>
          children: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<test>} {<-n>} {(DQ ($ Id.VSub_Number 1))})
                (C {<die>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: (C {<gettext>} {(DQ <'No branch name specified'>)})
                        right: <Id.Eof_RParen _>
                      )
                    )
                  }
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'branch='> name:branch)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number 1)}
                  spids: [3705]
                )
              ]
              redirects: []
            )
            (C {<shift>} {<1>})
            (C {<set>} {<-->} {<--index>} {(DQ ($ Id.VSub_At '@'))})
            (C {<assert_stash_like>} {(DQ ($ Id.VSub_At '@'))})
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DAmp]
              children: [
                (C {<git>} {<checkout>} {<-b>} {($ Id.VSub_DollarName branch)} 
                  {($ Id.VSub_DollarName REV) <Id.Lit_Other '^'>}
                )
                (C {<apply_stash>} {(DQ ($ Id.VSub_At '@'))})
                (BraceGroup
                  left: <Id.Lit_LBrace '{'>
                  children: [
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName IS_STASH_REF))})
                        (C {<drop_stash>} {(DQ ($ Id.VSub_At '@'))})
                      ]
                    )
                  ]
                  redirects: []
                  right: <Id.Lit_RBrace '}'>
                )
              ]
            )
          ]
          redirects: []
          right: <Id.Lit_RBrace '}'>
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'PARSE_CACHE='> name:PARSE_CACHE)
          op: assign_op.Equal
          rhs: {(SQ <--not-parsed>)}
          spids: [3781]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'seen_non_option='> name:seen_non_option)
          op: assign_op.Equal
          rhs: (rhs_word.Empty)
          spids: [3789]
        )
      ]
      redirects: []
    )
    (command.ForEach
      iter_names: [opt]
      iterable: (for_iter.Args)
      body: 
        (command.DoGroup
          children: [
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName opt))}
              arms: [
                (case_arm
                  pat_list: [{<-> <Id.Lit_Star '*'>}]
                  action: []
                  spids: [3807 3809 3811 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: 
                                (sh_lhs_expr.Name
                                  left: <Id.Lit_VarLike 'seen_non_option='>
                                  name: seen_non_option
                                )
                              op: assign_op.Equal
                              rhs: {<t>}
                              spids: [3817]
                            )
                          ]
                          redirects: []
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (command.ControlFlow token:<Id.ControlFlow_Break break>)
                  ]
                  spids: [3814 3815 3823 -1]
                )
              ]
              redirects: []
            )
          ]
        )
      redirects: []
    )
    (command.AndOr
      ops: [Id.Op_DPipe]
      children: [
        (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName seen_non_option))})
        (C {<set>} {(DQ <save>)} {(DQ ($ Id.VSub_At '@'))})
      ]
    )
    (command.Case
      to_match: {(DQ ($ Id.VSub_Number 1))}
      arms: [
        (case_arm
          pat_list: [{<list>}]
          action: [(C {<shift>}) (C {<list_stash>} {(DQ ($ Id.VSub_At '@'))})]
          spids: [3863 3864 3877 -1]
        )
        (case_arm
          pat_list: [{<show>}]
          action: [(C {<shift>}) (C {<show_stash>} {(DQ ($ Id.VSub_At '@'))})]
          spids: [3879 3880 3893 -1]
        )
        (case_arm
          pat_list: [{<save>}]
          action: [(C {<shift>}) (C {<save_stash>} {(DQ ($ Id.VSub_At '@'))})]
          spids: [3895 3896 3909 -1]
        )
        (case_arm
          pat_list: [{<apply>}]
          action: [(C {<shift>}) (C {<apply_stash>} {(DQ ($ Id.VSub_At '@'))})]
          spids: [3911 3912 3925 -1]
        )
        (case_arm
          pat_list: [{<clear>}]
          action: [(C {<shift>}) (C {<clear_stash>} {(DQ ($ Id.VSub_At '@'))})]
          spids: [3927 3928 3941 -1]
        )
        (case_arm
          pat_list: [{<create>}]
          action: [
            (C {<shift>})
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<create_stash>} {(DQ ($ Id.VSub_Star '*'))})
                (C {<echo>} {(DQ ($ Id.VSub_DollarName w_commit))})
              ]
            )
          ]
          spids: [3943 3944 3965 -1]
        )
        (case_arm
          pat_list: [{<store>}]
          action: [(C {<shift>}) (C {<store_stash>} {(DQ ($ Id.VSub_At '@'))})]
          spids: [3967 3968 3981 -1]
        )
        (case_arm
          pat_list: [{<drop>}]
          action: [(C {<shift>}) (C {<drop_stash>} {(DQ ($ Id.VSub_At '@'))})]
          spids: [3983 3984 3997 -1]
        )
        (case_arm
          pat_list: [{<pop>}]
          action: [(C {<shift>}) (C {<pop_stash>} {(DQ ($ Id.VSub_At '@'))})]
          spids: [3999 4000 4013 -1]
        )
        (case_arm
          pat_list: [{<branch>}]
          action: [(C {<shift>}) (C {<apply_to_branch>} {(DQ ($ Id.VSub_At '@'))})]
          spids: [4015 4016 4029 -1]
        )
        (case_arm
          pat_list: [{<Id.Lit_Star '*'>}]
          action: [
            (command.Case
              to_match: {($ Id.VSub_Pound '#')}
              arms: [
                (case_arm
                  pat_list: [{<0>}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<save_stash>})
                        (C {<say>} 
                          {
                            (DQ 
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<gettext>} 
                                    {
                                      (DQ <'(To restore them type '> 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\"'>
                                          ch: '"'
                                        ) <'git stash apply'> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'> ch:'"') <')'>
                                      )
                                    }
                                  )
                                right: <Id.Eof_RParen _>
                              )
                            )
                          }
                        )
                      ]
                    )
                  ]
                  spids: [4042 4043 4068 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [(C {<usage>})]
                  spids: [4071 4072 -1 4078]
                )
              ]
              redirects: []
            )
          ]
          spids: [4031 4032 4081 -1]
        )
      ]
      redirects: []
    )
  ]
)