(CommandList
  children: [
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:dashless)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (Pipeline
                        children: [
                          (C {(basename)} {(DQ ($ VSub_Number '$0'))})
                          (C {(sed)} {(-e)} {(SQ <'s/-/ /'>)})
                        ]
                        negated: False
                      )
                    ]
                  )
                left_token: <Left_CommandSub '$('>
                spids: [8 24]
              )
            }
          spids: [7]
        )
      ]
      spids: [7]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:USAGE)
          op: Equal
          rhs: 
            {
              (DQ ('list [<options>]\n') ('   or: ') ($ VSub_Name '$dashless') (' show [<stash>]\n') 
                ('   or: ') ($ VSub_Name '$dashless') (' drop [-q|--quiet] [<stash>]\n') ('   or: ') ($ VSub_Name '$dashless') 
                (' ( pop | apply ) [--index] [-q|--quiet] [<stash>]\n') ('   or: ') ($ VSub_Name '$dashless') (' branch <branchname> [<stash>]\n') ('   or: ') 
                ($ VSub_Name '$dashless') (' [save [--patch] [-k|--[no-]keep-index] [-q|--quiet]\n') 
                ('\t\t       [-u|--include-untracked] [-a|--all] [<message>]]\n') ('   or: ') ($ VSub_Name '$dashless') (' clear')
              )
            }
          spids: [26]
        )
      ]
      spids: [26]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:SUBDIRECTORY_OK) op:Equal rhs:{(Yes)} spids:[51])]
      spids: [51]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:OPTIONS_SPEC) op:Equal rhs:{(SQ )} spids:[54])]
      spids: [54]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:START_DIR)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: (CommandList children:[(C {(pwd)})])
                left_token: <Left_CommandSub '$('>
                spids: [57 59]
              )
            }
          spids: [56]
        )
      ]
      spids: [56]
    )
    (C {(.)} {(git-sh-setup)})
    (C {(require_work_tree)})
    (C {(cd_to_toplevel)})
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:TMP)
          op: Equal
          rhs: {(DQ ($ VSub_Name '$GIT_DIR') (/.git-stash.) ($ VSub_Dollar '$$'))}
          spids: [70]
        )
      ]
      spids: [70]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:TMPindex)
          op: Equal
          rhs: 
            {
              (BracedVarSub
                token: <VSub_Name GIT_INDEX_FILE>
                suffix_op: 
                  (StringUnary
                    op_id: VTest_Hyphen
                    arg_word: 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [(C {(git)} {(rev-parse)} {(--git-path)} {(index)})]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [82 90]
                          )
                        )
                      }
                  )
                spids: [78 92]
              ) (.stash.) ($ VSub_Dollar '$$')
            }
          spids: [77]
        )
      ]
      spids: [77]
    )
    (C {(trap)} {(SQ <'rm -f "$TMP-"* "$TMPindex"'>)} {(0)})
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:ref_stash) op:Equal rhs:{(refs/stash)} spids:[105])]
      spids: [105]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (Sentence
              child: (C {(git)} {(config)} {(--get-colorbool)} {(color.interactive)})
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:help_color)
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (CommandSubPart
                          command_list: 
                            (CommandList
                              children: [
                                (C {(git)} {(config)} {(--get-color)} {(color.interactive.help)} 
                                  {(SQ <'red bold'>)}
                                )
                              ]
                            )
                          left_token: <Left_CommandSub '$('>
                          spids: [125 137]
                        )
                      )
                    }
                  spids: [123]
                )
              ]
              spids: [123]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:reset_color)
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (CommandSubPart
                          command_list: 
                            (CommandList
                              children: [(C {(git)} {(config)} {(--get-color)} {(SQ )} {(reset)})]
                            )
                          left_token: <Left_CommandSub '$('>
                          spids: [143 154]
                        )
                      )
                    }
                  spids: [141]
                )
              ]
              spids: [141]
            )
          ]
          spids: [16777215 120]
        )
      ]
      else_action: [
        (Assignment
          keyword: Assign_None
          pairs: [(assign_pair lhs:(LhsName name:help_color) op:Equal rhs:{(SQ )} spids:[160])]
          spids: [160]
        )
        (Assignment
          keyword: Assign_None
          pairs: [(assign_pair lhs:(LhsName name:reset_color) op:Equal rhs:{(SQ )} spids:[163])]
          spids: [163]
        )
      ]
      spids: [157 165]
    )
    (FuncDef
      name: no_changes
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(git)} {(diff-index)} {(--quiet)} {(--cached)} {(HEAD)} {(--ignore-submodules)} {(--)})
                (AndOr
                  children: [
                    (C {(git)} {(diff-files)} {(--quiet)} {(--ignore-submodules)})
                    (Subshell
                      child: 
                        (AndOr
                          children: [
                            (C {(test)} {(-z)} {(DQ ($ VSub_Name '$untracked'))})
                            (C {(test)} {(-z)} 
                              {
                                (DQ 
                                  (CommandSubPart
                                    command_list: (CommandList children:[(C {(untracked_files)})])
                                    left_token: <Left_CommandSub '$('>
                                    spids: [220 222]
                                  )
                                )
                              }
                            )
                          ]
                          op_id: Op_DPipe
                        )
                      spids: [204 224]
                    )
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [173]
        )
      spids: [168 172]
    )
    (FuncDef
      name: untracked_files
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:excl_opt)
                  op: Equal
                  rhs: {(--exclude-standard)}
                  spids: [237]
                )
              ]
              spids: [237]
            )
            (AndOr
              children: [
                (C {(test)} {(DQ ($ VSub_Name '$untracked'))} {(Lit_Other '=')} {(DQ (all))})
                (Assignment
                  keyword: Assign_None
                  pairs: [(assign_pair lhs:(LhsName name:excl_opt) op:Equal rhs:{(SQ )} spids:[255])]
                  spids: [255]
                )
              ]
              op_id: Op_DAmp
            )
            (C {(git)} {(ls-files)} {(-o)} {(-z)} {($ VSub_Name '$excl_opt')})
          ]
          spids: [234]
        )
      spids: [229 233]
    )
    (FuncDef
      name: clear_stash
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {($ VSub_Pound '$#')} {(KW_Bang '!') (Lit_Other '=')} {(0)})]
                  action: [
                    (C {(die)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(gettext)} 
                                    {(DQ ('git stash clear with parameters is unimplemented'))}
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [297 303]
                          )
                        )
                      }
                    )
                  ]
                  spids: [16777215 291]
                )
              ]
              spids: [16777215 307]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:current)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(git)} {(rev-parse)} {(--verify)} {(--quiet)} 
                                        {($ VSub_Name '$ref_stash')}
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [313 323]
                              )
                            }
                          spids: [312]
                        )
                      ]
                      spids: [312]
                    )
                  ]
                  action: [
                    (C {(git)} {(update-ref)} {(-d)} {($ VSub_Name '$ref_stash')} 
                      {($ VSub_Name '$current')}
                    )
                  ]
                  spids: [16777215 326]
                )
              ]
              spids: [16777215 340]
            )
          ]
          spids: [276]
        )
      spids: [271 275]
    )
    (FuncDef
      name: create_stash
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:stash_msg)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number '$1'))}
                  spids: [353]
                )
              ]
              spids: [353]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:untracked)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number '$2'))}
                  spids: [359]
                )
              ]
              spids: [359]
            )
            (C {(git)} {(update-index)} {(-q)} {(--refresh)})
            (If
              arms: [
                (if_arm
                  cond: [(C {(no_changes)})]
                  action: [(C {(exit)} {(0)})]
                  spids: [16777215 380]
                )
              ]
              spids: [16777215 388]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:b_commit)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [(C {(git)} {(rev-parse)} {(--verify)} {(HEAD)})]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [399 407]
                              )
                            }
                          spids: [398]
                        )
                      ]
                      spids: [398]
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:head)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(git)} {(rev-list)} {(--oneline)} {(-n)} {(1)} {(HEAD)} {(--)})
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [414 428]
                              )
                            }
                          spids: [413]
                        )
                      ]
                      spids: [413]
                    )
                  ]
                  spids: [16777215 410]
                )
              ]
              else_action: [
                (C {(die)} 
                  {
                    (DQ 
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [(C {(gettext)} {(DQ ('You do not have the initial commit yet'))})]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [437 443]
                      )
                    )
                  }
                )
              ]
              spids: [431 447]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:branch)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [(C {(git)} {(symbolic-ref)} {(-q)} {(HEAD)})]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [454 462]
                              )
                            }
                          spids: [453]
                        )
                      ]
                      spids: [453]
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:branch)
                          op: Equal
                          rhs: 
                            {
                              (BracedVarSub
                                token: <VSub_Name branch>
                                suffix_op: 
                                  (StringUnary
                                    op_id: VOp1_Pound
                                    arg_word: {(refs) (Lit_Slash /) (heads) (Lit_Slash /)}
                                  )
                                spids: [469 476]
                              )
                            }
                          spids: [468]
                        )
                      ]
                      spids: [468]
                    )
                  ]
                  spids: [16777215 465]
                )
              ]
              else_action: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:branch)
                      op: Equal
                      rhs: {(SQ <'(no branch)'>)}
                      spids: [482]
                    )
                  ]
                  spids: [482]
                )
              ]
              spids: [479 488]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:msg)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(printf)} {(SQ <'%s: %s'>)} {(DQ ($ VSub_Name '$branch'))} 
                                {(DQ ($ VSub_Name '$head'))}
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [492 506]
                      )
                    }
                  spids: [491]
                )
              ]
              spids: [491]
            )
            (AndOr
              children: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:i_tree)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: (CommandList children:[(C {(git)} {(write-tree)})])
                            left_token: <Left_CommandSub '$('>
                            spids: [515 519]
                          )
                        }
                      spids: [514]
                    )
                  ]
                  spids: [514]
                )
                (AndOr
                  children: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:i_commit)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (Pipeline
                                        children: [
                                          (C {(printf)} {(SQ <'index on %s\\n'>)} 
                                            {(DQ ($ VSub_Name '$msg'))}
                                          )
                                          (C {(git)} {(commit-tree)} {($ VSub_Name '$i_tree')} {(-p)} 
                                            {($ VSub_Name '$b_commit')}
                                          )
                                        ]
                                        negated: False
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [525 548]
                              )
                            }
                          spids: [524]
                        )
                      ]
                      spids: [524]
                    )
                    (C {(die)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(gettext)} {(DQ ('Cannot save the current index state'))})
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [556 562]
                          )
                        )
                      }
                    )
                  ]
                  op_id: Op_DPipe
                )
              ]
              op_id: Op_DAmp
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name '$untracked'))})]
                  action: [
                    (AndOr
                      children: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:u_commit)
                              op: Equal
                              rhs: 
                                {
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (Pipeline
                                            children: [
                                              (C {(untracked_files)})
                                              (Subshell
                                                child: 
                                                  (AndOr
                                                    children: [
                                                      (Assignment
                                                        keyword: Assign_None
                                                        pairs: [
                                                          (assign_pair
                                                            lhs: (LhsName name:GIT_INDEX_FILE)
                                                            op: Equal
                                                            rhs: {(DQ ($ VSub_Name '$TMPindex'))}
                                                            spids: [600]
                                                          )
                                                        ]
                                                        spids: [600]
                                                      )
                                                      (AndOr
                                                        children: [
                                                          (C {(export)} {(GIT_INDEX_FILE)})
                                                          (AndOr
                                                            children: [
                                                              (C {(rm)} {(-f)} 
                                                                {(DQ ($ VSub_Name '$TMPindex'))}
                                                              )
                                                              (AndOr
                                                                children: [
                                                                  (C {(git)} {(update-index)} {(-z)} 
                                                                    {(--add)} {(--remove)} {(--stdin)}
                                                                  )
                                                                  (AndOr
                                                                    children: [
                                                                      (Assignment
                                                                        keyword: Assign_None
                                                                        pairs: [
                                                                          (assign_pair
                                                                            lhs: 
                                                                              (LhsName
                                                                                name: u_tree
                                                                              )
                                                                            op: Equal
                                                                            rhs: 
                                                                              {
                                                                                (CommandSubPart
                                                                                  command_list: 
                                                                                    (CommandList
                                                                                      children: [
                                                                                        (C {(git)} 
                                                                                          {
                                                                                            (
write-tree
                                                                                            )
                                                                                          }
                                                                                        )
                                                                                      ]
                                                                                    )
                                                                                  left_token: 
                                                                                    <
Left_CommandSub '$('
                                                                                    >
                                                                                  spids: [642 646]
                                                                                )
                                                                              }
                                                                            spids: [641]
                                                                          )
                                                                        ]
                                                                        spids: [641]
                                                                      )
                                                                      (AndOr
                                                                        children: [
                                                                          (Pipeline
                                                                            children: [
                                                                              (C {(printf)} 
                                                                                {
                                                                                  (SQ 
                                                                                    <
'untracked files on %s\\n'
                                                                                    >
                                                                                  )
                                                                                } {(DQ ($ VSub_Name '$msg'))}
                                                                              )
                                                                              (C {(git)} 
                                                                                {(commit-tree)} {($ VSub_Name '$u_tree')}
                                                                              )
                                                                            ]
                                                                            negated: False
                                                                          )
                                                                          (C {(rm)} {(-f)} 
                                                                            {
                                                                              (DQ 
                                                                                ($ VSub_Name 
'$TMPindex'
                                                                                )
                                                                              )
                                                                            }
                                                                          )
                                                                        ]
                                                                        op_id: Op_DAmp
                                                                      )
                                                                    ]
                                                                    op_id: Op_DAmp
                                                                  )
                                                                ]
                                                                op_id: Op_DAmp
                                                              )
                                                            ]
                                                            op_id: Op_DAmp
                                                          )
                                                        ]
                                                        op_id: Op_DAmp
                                                      )
                                                    ]
                                                    op_id: Op_DAmp
                                                  )
                                                spids: [597 681]
                                              )
                                            ]
                                            negated: False
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [590 683]
                                  )
                                }
                              spids: [589]
                            )
                          ]
                          spids: [589]
                        )
                        (C {(die)} 
                          {
                            (DQ 
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(gettext)} {(DQ ('Cannot save the untracked files'))})
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [690 696]
                              )
                            )
                          }
                        )
                      ]
                      op_id: Op_DPipe
                    )
                    (Sentence
                      child: 
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:untracked_commit_option)
                              op: Equal
                              rhs: {(DQ ('-p ') ($ VSub_Name '$u_commit'))}
                              spids: [701]
                            )
                          ]
                          spids: [701]
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  spids: [16777215 578]
                )
              ]
              else_action: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:untracked_commit_option)
                      op: Equal
                      rhs: {(SQ )}
                      spids: [712]
                    )
                  ]
                  spids: [712]
                )
              ]
              spids: [709 715]
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name '$patch_mode'))})]
                  action: [
                    (AndOr
                      children: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:w_tree)
                              op: Equal
                              rhs: 
                                {
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (Subshell
                                            child: 
                                              (AndOr
                                                children: [
                                                  (C {(git)} {(read-tree)} 
                                                    {(--index-output) (Lit_Other '=') 
                                                      (DQ ($ VSub_Name '$TMPindex'))
                                                    } {(-m)} {($ VSub_Name '$i_tree')}
                                                  )
                                                  (AndOr
                                                    children: [
                                                      (Assignment
                                                        keyword: Assign_None
                                                        pairs: [
                                                          (assign_pair
                                                            lhs: (LhsName name:GIT_INDEX_FILE)
                                                            op: Equal
                                                            rhs: {(DQ ($ VSub_Name '$TMPindex'))}
                                                            spids: [761]
                                                          )
                                                        ]
                                                        spids: [761]
                                                      )
                                                      (AndOr
                                                        children: [
                                                          (C {(export)} {(GIT_INDEX_FILE)})
                                                          (AndOr
                                                            children: [
                                                              (SimpleCommand
                                                                words: [
                                                                  {(git)}
                                                                  {(diff)}
                                                                  {(--name-only)}
                                                                  {(-z)}
                                                                  {(HEAD)}
                                                                  {(--)}
                                                                ]
                                                                redirects: [
                                                                  (Redir
                                                                    op_id: Redir_Great
                                                                    fd: 16777215
                                                                    arg_word: 
                                                                      {
                                                                        (DQ ($ VSub_Name '$TMP') 
                                                                          (-stagenames)
                                                                        )
                                                                      }
                                                                    spids: [788]
                                                                  )
                                                                ]
                                                              )
                                                              (AndOr
                                                                children: [
                                                                  (SimpleCommand
                                                                    words: [
                                                                      {(git)}
                                                                      {(update-index)}
                                                                      {(-z)}
                                                                      {(--add)}
                                                                      {(--remove)}
                                                                      {(--stdin)}
                                                                    ]
                                                                    redirects: [
                                                                      (Redir
                                                                        op_id: Redir_Less
                                                                        fd: 16777215
                                                                        arg_word: 
                                                                          {
                                                                            (DQ ($ VSub_Name '$TMP') 
                                                                              (-stagenames)
                                                                            )
                                                                          }
                                                                        spids: [809]
                                                                      )
                                                                    ]
                                                                  )
                                                                  (AndOr
                                                                    children: [
                                                                      (C {(git)} {(write-tree)})
                                                                      (C {(rm)} {(-f)} 
                                                                        {
                                                                          (DQ 
                                                                            ($ VSub_Name '$TMPindex')
                                                                          )
                                                                        }
                                                                      )
                                                                    ]
                                                                    op_id: Op_DAmp
                                                                  )
                                                                ]
                                                                op_id: Op_DAmp
                                                              )
                                                            ]
                                                            op_id: Op_DAmp
                                                          )
                                                        ]
                                                        op_id: Op_DAmp
                                                      )
                                                    ]
                                                    op_id: Op_DAmp
                                                  )
                                                ]
                                                op_id: Op_DAmp
                                              )
                                            spids: [741 834]
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [739 836]
                                  )
                                }
                              spids: [738]
                            )
                          ]
                          spids: [738]
                        )
                        (C {(die)} 
                          {
                            (DQ 
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(gettext)} {(DQ ('Cannot save the current worktree state'))})
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [844 850]
                              )
                            )
                          }
                        )
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  spids: [16777215 730]
                )
              ]
              else_action: [
                (AndOr
                  children: [
                    (C {(rm)} {(-f)} {(DQ ($ VSub_Name '$TMP') (-index))})
                    (AndOr
                      children: [
                        (SimpleCommand
                          words: [{(git)} {(read-tree)} {(HEAD)}]
                          more_env: [
                            (env_pair
                              name: GIT_INDEX_FILE
                              val: {(DQ ($ VSub_Name '$TMP') (-index))}
                              spids: [871]
                            )
                          ]
                        )
                        (AndOr
                          children: [
                            (SimpleCommand
                              words: [
                                {(git)}
                                {(add--interactive)}
                                {(--patch) (Lit_Other '=') (stash)}
                                {(--)}
                              ]
                              more_env: [
                                (env_pair
                                  name: GIT_INDEX_FILE
                                  val: {(DQ ($ VSub_Name '$TMP') (-index))}
                                  spids: [891]
                                )
                              ]
                            )
                            (AndOr
                              children: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:w_tree)
                                      op: Equal
                                      rhs: 
                                        {
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (SimpleCommand
                                                    words: [{(git)} {(write-tree)}]
                                                    more_env: [
                                                      (env_pair
                                                        name: GIT_INDEX_FILE
                                                        val: {(DQ ($ VSub_Name '$TMP') (-index))}
                                                        spids: [919]
                                                      )
                                                    ]
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub '$('>
                                            spids: [918 928]
                                          )
                                        }
                                      spids: [917]
                                    )
                                  ]
                                  spids: [917]
                                )
                                (C {(die)} 
                                  {
                                    (DQ 
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (C {(gettext)} 
                                                {(DQ ('Cannot save the current worktree state'))}
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub '$('>
                                        spids: [936 942]
                                      )
                                    )
                                  }
                                )
                              ]
                              op_id: Op_DPipe
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  op_id: Op_DAmp
                )
                (AndOr
                  children: [
                    (SimpleCommand
                      words: [{(git)} {(diff-tree)} {(-p)} {(HEAD)} {($ VSub_Name '$w_tree')} {(--)}]
                      redirects: [
                        (Redir
                          op_id: Redir_Great
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_Name '$TMP') (-patch))}
                          spids: [959]
                        )
                      ]
                    )
                    (AndOr
                      children: [
                        (C {(test)} {(-s)} {(DQ ($ VSub_Name '$TMP') (-patch))})
                        (C {(die)} 
                          {
                            (DQ 
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [(C {(gettext)} {(DQ ('No changes selected'))})]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [983 989]
                              )
                            )
                          }
                        )
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  op_id: Op_DAmp
                )
                (AndOr
                  children: [
                    (C {(rm)} {(-f)} {(DQ ($ VSub_Name '$TMP') (-index))})
                    (C {(die)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(gettext)} {(DQ ("Cannot remove temporary index (can't happen)"))})
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [1009 1015]
                          )
                        )
                      }
                    )
                  ]
                  op_id: Op_DPipe
                )
              ]
              spids: [855 1020]
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name '$stash_msg'))})]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:stash_msg)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(printf)} {(SQ <'WIP on %s'>)} {(DQ ($ VSub_Name '$msg'))})
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [1043 1053]
                              )
                            }
                          spids: [1042]
                        )
                      ]
                      spids: [1042]
                    )
                  ]
                  spids: [16777215 1039]
                )
              ]
              else_action: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:stash_msg)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(printf)} {(SQ <'On %s: %s'>)} {(DQ ($ VSub_Name '$branch'))} 
                                    {(DQ ($ VSub_Name '$stash_msg'))}
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [1060 1074]
                          )
                        }
                      spids: [1059]
                    )
                  ]
                  spids: [1059]
                )
              ]
              spids: [1056 1077]
            )
            (AndOr
              children: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:w_commit)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (Pipeline
                                    children: [
                                      (C {(printf)} {(SQ <'%s\\n'>)} {(DQ ($ VSub_Name '$stash_msg'))})
                                      (C {(git)} {(commit-tree)} {($ VSub_Name '$w_tree')} {(-p)} 
                                        {($ VSub_Name '$b_commit')} {(-p)} {($ VSub_Name '$i_commit')} {($ VSub_Name '$untracked_commit_option')}
                                      )
                                    ]
                                    negated: False
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [1081 1110]
                          )
                        }
                      spids: [1080]
                    )
                  ]
                  spids: [1080]
                )
                (C {(die)} 
                  {
                    (DQ 
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [(C {(gettext)} {(DQ ('Cannot record working tree state'))})]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [1118 1124]
                      )
                    )
                  }
                )
              ]
              op_id: Op_DPipe
            )
          ]
          spids: [350]
        )
      spids: [345 349]
    )
    (FuncDef
      name: store_stash
      body: 
        (BraceGroup
          children: [
            (While
              cond: [(C {(test)} {($ VSub_Pound '$#')} {(KW_Bang '!') (Lit_Other '=')} {(0)})]
              body: 
                (DoGroup
                  children: [
                    (Case
                      to_match: {(DQ ($ VSub_Number '$1'))}
                      arms: [
                        (case_arm
                          pat_list: [{(-m)} {(--message)}]
                          action: [
                            (C {(shift)})
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:stash_msg)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Number '$1'))}
                                  spids: [1171]
                                )
                              ]
                              spids: [1171]
                            )
                          ]
                          spids: [1162 1165 1177 16777215]
                        )
                        (case_arm
                          pat_list: [{(-q)} {(--quiet)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:quiet)
                                  op: Equal
                                  rhs: {(t)}
                                  spids: [1186]
                                )
                              ]
                              spids: [1186]
                            )
                          ]
                          spids: [1180 1183 1190 16777215]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other '*')}]
                          action: [(ControlFlow token:<ControlFlow_Break break>)]
                          spids: [1193 1194 1200 16777215]
                        )
                      ]
                      spids: [1153 1159 1203]
                    )
                    (C {(shift)})
                  ]
                  spids: [1150 1209]
                )
            )
            (AndOr
              children: [
                (C {(test)} {($ VSub_Pound '$#')} {(Lit_Other '=')} {(1)})
                (C {(die)} 
                  {
                    (DQ 
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(eval_gettext)} 
                                {
                                  (DQ (EscapedLiteralPart token:<Lit_EscapedChar '\\"'>) 
                                    ($ VSub_Name '$dashless') (' store') (EscapedLiteralPart token:<Lit_EscapedChar '\\"'>) (' requires one <commit> argument')
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [1226 1236]
                      )
                    )
                  }
                )
              ]
              op_id: Op_DPipe
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:w_commit)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number '$1'))}
                  spids: [1241]
                )
              ]
              spids: [1241]
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name '$stash_msg'))})]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:stash_msg)
                          op: Equal
                          rhs: 
                            {
                              (DQ ('Created via ') (EscapedLiteralPart token:<Lit_EscapedChar '\\"'>) 
                                ('git stash store') (EscapedLiteralPart token:<Lit_EscapedChar '\\"'>) (.)
                              )
                            }
                          spids: [1261]
                        )
                      ]
                      spids: [1261]
                    )
                  ]
                  spids: [16777215 1258]
                )
              ]
              spids: [16777215 1271]
            )
            (C {(git)} {(update-ref)} {(--create-reflog)} {(-m)} {(DQ ($ VSub_Name '$stash_msg'))} 
              {($ VSub_Name '$ref_stash')} {($ VSub_Name '$w_commit')}
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:ret)
                  op: Equal
                  rhs: {($ VSub_QMark '$?')}
                  spids: [1292]
                )
              ]
              spids: [1292]
            )
            (AndOr
              children: [
                (C {(test)} {($ VSub_Name '$ret')} {(KW_Bang '!') (Lit_Other '=')} {(0)})
                (AndOr
                  children: [
                    (C {(test)} {(-z)} {(DQ ($ VSub_Name '$quiet'))})
                    (C {(die)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ ('Cannot update ') 
                                        (EscapedLiteralPart
                                          token: <Lit_EscapedChar '\\$'>
                                        ) ('ref_stash with ') (EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) (w_commit)
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [1321 1331]
                          )
                        )
                      }
                    )
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
            (ControlFlow token:<ControlFlow_Return return> arg_word:{($ VSub_Name '$ret')})
          ]
          spids: [1135]
        )
      spids: [1130 1134]
    )
    (FuncDef
      name: save_stash
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:keep_index) op:Equal rhs:{(SQ )} spids:[1350])]
              spids: [1350]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:patch_mode) op:Equal rhs:{(SQ )} spids:[1353])]
              spids: [1353]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:untracked) op:Equal rhs:{(SQ )} spids:[1356])]
              spids: [1356]
            )
            (While
              cond: [(C {(test)} {($ VSub_Pound '$#')} {(KW_Bang '!') (Lit_Other '=')} {(0)})]
              body: 
                (DoGroup
                  children: [
                    (Case
                      to_match: {(DQ ($ VSub_Number '$1'))}
                      arms: [
                        (case_arm
                          pat_list: [{(-k)} {(--keep-index)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:keep_index)
                                  op: Equal
                                  rhs: {(t)}
                                  spids: [1389]
                                )
                              ]
                              spids: [1389]
                            )
                          ]
                          spids: [1383 1386 1393 16777215]
                        )
                        (case_arm
                          pat_list: [{(--no-keep-index)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:keep_index)
                                  op: Equal
                                  rhs: {(n)}
                                  spids: [1400]
                                )
                              ]
                              spids: [1400]
                            )
                          ]
                          spids: [1396 1397 1404 16777215]
                        )
                        (case_arm
                          pat_list: [{(-p)} {(--patch)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:patch_mode)
                                  op: Equal
                                  rhs: {(t)}
                                  spids: [1413]
                                )
                              ]
                              spids: [1413]
                            )
                            (AndOr
                              children: [
                                (C {(test)} {(-z)} {(DQ ($ VSub_Name '$keep_index'))})
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:keep_index)
                                      op: Equal
                                      rhs: {(t)}
                                      spids: [1431]
                                    )
                                  ]
                                  spids: [1431]
                                )
                              ]
                              op_id: Op_DAmp
                            )
                          ]
                          spids: [1407 1410 1435 16777215]
                        )
                        (case_arm
                          pat_list: [{(-q)} {(--quiet)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:GIT_QUIET)
                                  op: Equal
                                  rhs: {(t)}
                                  spids: [1444]
                                )
                              ]
                              spids: [1444]
                            )
                          ]
                          spids: [1438 1441 1448 16777215]
                        )
                        (case_arm
                          pat_list: [{(-u)} {(--include-untracked)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:untracked)
                                  op: Equal
                                  rhs: {(untracked)}
                                  spids: [1457]
                                )
                              ]
                              spids: [1457]
                            )
                          ]
                          spids: [1451 1454 1461 16777215]
                        )
                        (case_arm
                          pat_list: [{(-a)} {(--all)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:untracked)
                                  op: Equal
                                  rhs: {(all)}
                                  spids: [1470]
                                )
                              ]
                              spids: [1470]
                            )
                          ]
                          spids: [1464 1467 1474 16777215]
                        )
                        (case_arm
                          pat_list: [{(--help)}]
                          action: [(C {(show_help)})]
                          spids: [1477 1478 1484 16777215]
                        )
                        (case_arm
                          pat_list: [{(--)}]
                          action: [(C {(shift)}) (ControlFlow token:<ControlFlow_Break break>)]
                          spids: [1487 1488 1497 16777215]
                        )
                        (case_arm
                          pat_list: [{(-) (Lit_Other '*')}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:option)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Number '$1'))}
                                  spids: [1505]
                                )
                              ]
                              spids: [1505]
                            )
                            (C {(eval_gettextln)} 
                              {
                                (DQ ("error: unknown option for 'stash save': ") 
                                  (EscapedLiteralPart
                                    token: <Lit_EscapedChar '\\$'>
                                  ) ('option\n') ("       To provide a message, use git stash save -- '") 
                                  (EscapedLiteralPart
                                    token: <Lit_EscapedChar '\\$'>
                                  ) ("option'")
                                )
                              }
                            )
                            (C {(usage)})
                          ]
                          spids: [1500 1502 1566 16777215]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other '*')}]
                          action: [(ControlFlow token:<ControlFlow_Break break>)]
                          spids: [1569 1570 1576 16777215]
                        )
                      ]
                      spids: [1374 1380 1579]
                    )
                    (C {(shift)})
                  ]
                  spids: [1371 1585]
                )
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (AndOr
                      children: [
                        (C {(test)} {(-n)} {(DQ ($ VSub_Name '$patch_mode'))})
                        (C {(test)} {(-n)} {(DQ ($ VSub_Name '$untracked'))})
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  action: [
                    (C {(die)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(gettext)} 
                                    {
                                      (DQ 
                                        (
"Can't use --patch and --include-untracked or --all at the same time"
                                        )
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [1616 1622]
                          )
                        )
                      }
                    )
                  ]
                  spids: [16777215 1610]
                )
              ]
              spids: [16777215 1626]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:stash_msg)
                  op: Equal
                  rhs: {(DQ ($ VSub_Star '$*'))}
                  spids: [1630]
                )
              ]
              spids: [1630]
            )
            (C {(git)} {(update-index)} {(-q)} {(--refresh)})
            (If
              arms: [
                (if_arm
                  cond: [(C {(no_changes)})]
                  action: [
                    (C {(say)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [(C {(gettext)} {(DQ ('No local changes to save'))})]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [1657 1663]
                          )
                        )
                      }
                    )
                    (C {(exit)} {(0)})
                  ]
                  spids: [16777215 1651]
                )
              ]
              spids: [16777215 1672]
            )
            (AndOr
              children: [
                (C {(git)} {(reflog)} {(exists)} {($ VSub_Name '$ref_stash')})
                (AndOr
                  children: [
                    (C {(clear_stash)})
                    (C {(die)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [(C {(gettext)} {(DQ ('Cannot initialize stash'))})]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [1693 1699]
                          )
                        )
                      }
                    )
                  ]
                  op_id: Op_DPipe
                )
              ]
              op_id: Op_DPipe
            )
            (C {(create_stash)} {(DQ ($ VSub_Name '$stash_msg'))} {($ VSub_Name '$untracked')})
            (AndOr
              children: [
                (C {(store_stash)} {(-m)} {(DQ ($ VSub_Name '$stash_msg'))} {(-q)} 
                  {($ VSub_Name '$w_commit')}
                )
                (C {(die)} 
                  {
                    (DQ 
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [(C {(gettext)} {(DQ ('Cannot save the current status'))})]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [1731 1737]
                      )
                    )
                  }
                )
              ]
              op_id: Op_DPipe
            )
            (C {(say)} 
              {
                (DQ 
                  (CommandSubPart
                    command_list: 
                      (CommandList
                        children: [
                          (C {(eval_gettext)} 
                            {
                              (DQ ('Saved working directory and index state ') 
                                (EscapedLiteralPart
                                  token: <Lit_EscapedChar '\\$'>
                                ) (stash_msg)
                              )
                            }
                          )
                        ]
                      )
                    left_token: <Left_CommandSub '$('>
                    spids: [1744 1752]
                  )
                )
              }
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name '$patch_mode'))})]
                  action: [
                    (C {(git)} {(reset)} {(--hard)} 
                      {
                        (BracedVarSub
                          token: <VSub_Name GIT_QUIET>
                          suffix_op: (StringUnary op_id:VTest_ColonPlus arg_word:{(-q)})
                          spids: [1777 1781]
                        )
                      }
                    )
                    (AndOr
                      children: [
                        (C {(test)} {(DQ ($ VSub_Name '$untracked'))} {(Lit_Other '=')} {(DQ (all))})
                        (AndOr
                          children: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:CLEAN_X_OPTION)
                                  op: Equal
                                  rhs: {(-x)}
                                  spids: [1798]
                                )
                              ]
                              spids: [1798]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:CLEAN_X_OPTION)
                                  op: Equal
                                  rhs: {(SQ )}
                                  spids: [1803]
                                )
                              ]
                              spids: [1803]
                            )
                          ]
                          op_id: Op_DPipe
                        )
                      ]
                      op_id: Op_DAmp
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name '$untracked'))})]
                          action: [
                            (C {(git)} {(clean)} {(--force)} {(--quiet)} {(-d)} 
                              {($ VSub_Name '$CLEAN_X_OPTION')}
                            )
                          ]
                          spids: [16777215 1817]
                        )
                      ]
                      spids: [16777215 1833]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (AndOr
                              children: [
                                (C {(test)} {(DQ ($ VSub_Name '$keep_index'))} {(Lit_Other '=')} 
                                  {(DQ (t))}
                                )
                                (C {(test)} {(-n)} {(DQ ($ VSub_Name '$i_tree'))})
                              ]
                              op_id: Op_DAmp
                            )
                          ]
                          action: [
                            (C {(git)} {(read-tree)} {(--reset)} {(-u)} {($ VSub_Name '$i_tree')})
                          ]
                          spids: [16777215 1862]
                        )
                      ]
                      spids: [16777215 1876]
                    )
                  ]
                  spids: [16777215 1768]
                )
              ]
              else_action: [
                (AndOr
                  children: [
                    (SimpleCommand
                      words: [{(git)} {(apply)} {(-R)}]
                      redirects: [
                        (Redir
                          op_id: Redir_Less
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_Name '$TMP') (-patch))}
                          spids: [1888]
                        )
                      ]
                    )
                    (C {(die)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [(C {(gettext)} {(DQ ('Cannot remove worktree changes'))})]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [1901 1907]
                          )
                        )
                      }
                    )
                  ]
                  op_id: Op_DPipe
                )
                (If
                  arms: [
                    (if_arm
                      cond: [
                        (C {(test)} {(DQ ($ VSub_Name '$keep_index'))} {(KW_Bang '!') (Lit_Other '=')} 
                          {(DQ (t))}
                        )
                      ]
                      action: [(C {(git)} {(reset)})]
                      spids: [16777215 1928]
                    )
                  ]
                  spids: [16777215 1936]
                )
              ]
              spids: [1879 1939]
            )
          ]
          spids: [1347]
        )
      spids: [1342 1346]
    )
    (FuncDef
      name: have_stash
      body: 
        (BraceGroup
          children: [
            (SimpleCommand
              words: [{(git)} {(rev-parse)} {(--verify)} {(--quiet)} {($ VSub_Name '$ref_stash')}]
              redirects: [(Redir op_id:Redir_Great fd:16777215 arg_word:{(/dev/null)} spids:[1962])]
            )
          ]
          spids: [1949]
        )
      spids: [1944 1948]
    )
    (FuncDef
      name: list_stash
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(have_stash)})
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
              ]
              op_id: Op_DPipe
            )
            (C {(git)} {(log)} {(--format) (Lit_Other '=') (DQ ('%gd: %gs'))} {(-g)} {(--first-parent)} 
              {(-m)} {(DQ ($ VSub_At '$@'))} {($ VSub_Name '$ref_stash')} {(--)}
            )
          ]
          spids: [1973]
        )
      spids: [1968 1972]
    )
    (FuncDef
      name: show_stash
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:ALLOW_UNKNOWN_FLAGS)
                  op: Equal
                  rhs: {(t)}
                  spids: [2020]
                )
              ]
              spids: [2020]
            )
            (C {(assert_stash_like)} {(DQ ($ VSub_At '$@'))})
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name '$FLAGS'))})]
                  action: [
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (C {(test)} 
                              {
                                (DQ 
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (AndOr
                                            children: [
                                              (C {(git)} {(config)} {(--bool)} {(stash.showStat)})
                                              (C {(echo)} {(true)})
                                            ]
                                            op_id: Op_DPipe
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [2051 2065]
                                  )
                                )
                              } {(Lit_Other '=')} {(DQ (true))}
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:FLAGS)
                                  op: Equal
                                  rhs: {(--stat)}
                                  spids: [2078]
                                )
                              ]
                              spids: [2078]
                            )
                          ]
                          spids: [16777215 2075]
                        )
                      ]
                      spids: [16777215 2082]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (C {(test)} 
                              {
                                (DQ 
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (AndOr
                                            children: [
                                              (C {(git)} {(config)} {(--bool)} {(stash.showPatch)})
                                              (C {(echo)} {(false)})
                                            ]
                                            op_id: Op_DPipe
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [2091 2105]
                                  )
                                )
                              } {(Lit_Other '=')} {(DQ (true))}
                            )
                          ]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:FLAGS)
                                  op: Equal
                                  rhs: 
                                    {(${ VSub_Name FLAGS) 
                                      (BracedVarSub
                                        token: <VSub_Name FLAGS>
                                        suffix_op: (StringUnary op_id:VTest_ColonPlus arg_word:{(' ')})
                                        spids: [2122 2126]
                                      ) (-p)
                                    }
                                  spids: [2118]
                                )
                              ]
                              spids: [2118]
                            )
                          ]
                          spids: [16777215 2115]
                        )
                      ]
                      spids: [16777215 2130]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name '$FLAGS'))})]
                          action: [(ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})]
                          spids: [16777215 2145]
                        )
                      ]
                      spids: [16777215 2153]
                    )
                  ]
                  spids: [16777215 2043]
                )
              ]
              spids: [16777215 2156]
            )
            (C {(git)} {(diff)} {(${ VSub_Name FLAGS)} {($ VSub_Name '$b_commit')} 
              {($ VSub_Name '$w_commit')}
            )
          ]
          spids: [2017]
        )
      spids: [2012 2016]
    )
    (FuncDef
      name: show_help
      body: 
        (BraceGroup
          children: [(C {(exec)} {(git)} {(help)} {(stash)}) (C {(exit)} {(1)})]
          spids: [2180]
        )
      spids: [2175 2179]
    )
    (FuncDef
      name: parse_flags_and_rev
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(test)} {(DQ ($ VSub_Name '$PARSE_CACHE'))} {(Lit_Other '=')} 
                  {(DQ ($ VSub_Star '$*'))}
                )
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
              ]
              op_id: Op_DAmp
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:PARSE_CACHE)
                  op: Equal
                  rhs: {(DQ ($ VSub_Star '$*'))}
                  spids: [2334]
                )
              ]
              spids: [2334]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:IS_STASH_LIKE)
                  op: Equal
                  rhs: {(SQ )}
                  spids: [2341]
                )
              ]
              spids: [2341]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:IS_STASH_REF) op:Equal rhs:{(SQ )} spids:[2344])]
              spids: [2344]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:INDEX_OPTION) op:Equal rhs:{(SQ )} spids:[2347])]
              spids: [2347]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:s) op:Equal rhs:{(SQ )} spids:[2350])]
              spids: [2350]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:w_commit) op:Equal rhs:{(SQ )} spids:[2353])]
              spids: [2353]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:b_commit) op:Equal rhs:{(SQ )} spids:[2356])]
              spids: [2356]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:i_commit) op:Equal rhs:{(SQ )} spids:[2359])]
              spids: [2359]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:u_commit) op:Equal rhs:{(SQ )} spids:[2362])]
              spids: [2362]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:w_tree) op:Equal rhs:{(SQ )} spids:[2365])]
              spids: [2365]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:b_tree) op:Equal rhs:{(SQ )} spids:[2368])]
              spids: [2368]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:i_tree) op:Equal rhs:{(SQ )} spids:[2371])]
              spids: [2371]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:u_tree) op:Equal rhs:{(SQ )} spids:[2374])]
              spids: [2374]
            )
            (AndOr
              children: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:REV)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(git)} {(rev-parse)} {(--no-flags)} {(--symbolic)} {(--sq)} 
                                    {(DQ ($ VSub_At '$@'))}
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [2379 2393]
                          )
                        }
                      spids: [2378]
                    )
                  ]
                  spids: [2378]
                )
                (C {(exit)} {(1)})
              ]
              op_id: Op_DPipe
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:FLAGS) op:Equal rhs:{(SQ )} spids:[2403])]
              spids: [2403]
            )
            (ForEach
              iter_name: opt
              do_arg_iter: True
              body: 
                (DoGroup
                  children: [
                    (Case
                      to_match: {(DQ ($ VSub_Name '$opt'))}
                      arms: [
                        (case_arm
                          pat_list: [{(-q)} {(--quiet)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:GIT_QUIET)
                                  op: Equal
                                  rhs: {(-t)}
                                  spids: [2429]
                                )
                              ]
                              spids: [2429]
                            )
                          ]
                          spids: [2423 2426 2433 16777215]
                        )
                        (case_arm
                          pat_list: [{(--index)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:INDEX_OPTION)
                                  op: Equal
                                  rhs: {(--index)}
                                  spids: [2440]
                                )
                              ]
                              spids: [2440]
                            )
                          ]
                          spids: [2436 2437 2444 16777215]
                        )
                        (case_arm
                          pat_list: [{(--help)}]
                          action: [(C {(show_help)})]
                          spids: [2447 2448 2454 16777215]
                        )
                        (case_arm
                          pat_list: [{(-) (Lit_Other '*')}]
                          action: [
                            (AndOr
                              children: [
                                (C {(test)} {(DQ ($ VSub_Name '$ALLOW_UNKNOWN_FLAGS'))} 
                                  {(Lit_Other '=')} {(t)}
                                )
                                (C {(die)} 
                                  {
                                    (DQ 
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (C {(eval_gettext)} 
                                                {
                                                  (DQ ('unknown option: ') 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar '\\$'>
                                                    ) (opt)
                                                  )
                                                }
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub '$('>
                                        spids: [2478 2486]
                                      )
                                    )
                                  }
                                )
                              ]
                              op_id: Op_DPipe
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:FLAGS)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ (${ VSub_Name FLAGS) 
                                        (BracedVarSub
                                          token: <VSub_Name FLAGS>
                                          suffix_op: 
                                            (StringUnary
                                              op_id: VTest_ColonPlus
                                              arg_word: {(' ')}
                                            )
                                          spids: [2495 2499]
                                        ) ($ VSub_Name '$opt')
                                      )
                                    }
                                  spids: [2490]
                                )
                              ]
                              spids: [2490]
                            )
                          ]
                          spids: [2457 2459 2504 16777215]
                        )
                      ]
                      spids: [2414 2420 2507]
                    )
                  ]
                  spids: [2411 2510]
                )
              spids: [16777215 16777215]
            )
            (C {(eval)} {(set)} {(--)} {($ VSub_Name '$REV')})
            (Case
              to_match: {($ VSub_Pound '$#')}
              arms: [
                (case_arm
                  pat_list: [{(0)}]
                  action: [
                    (AndOr
                      children: [
                        (C {(have_stash)})
                        (C {(die)} 
                          {
                            (DQ 
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [(C {(gettext)} {(DQ ('No stash found.'))})]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [2542 2548]
                              )
                            )
                          }
                        )
                      ]
                      op_id: Op_DPipe
                    )
                    (C {(set)} {(--)} 
                      {(${ VSub_Name ref_stash) (Lit_Other '@') (Lit_LBrace '{') (0) (Lit_RBrace '}')}
                    )
                  ]
                  spids: [2531 2532 2565 16777215]
                )
                (case_arm
                  pat_list: [{(1)}]
                  action: [(C {(Lit_Other ':')})]
                  spids: [2568 2569 2575 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [
                    (C {(die)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ ('Too many revisions specified: ') 
                                        (EscapedLiteralPart
                                          token: <Lit_EscapedChar '\\$'>
                                        ) (REV)
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [2585 2593]
                          )
                        )
                      }
                    )
                  ]
                  spids: [2578 2579 2597 16777215]
                )
              ]
              spids: [2524 2528 2600]
            )
            (AndOr
              children: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:REV)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(git)} {(rev-parse)} {(--symbolic)} {(--verify)} {(--quiet)} 
                                    {(DQ ($ VSub_Number '$1'))}
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [2605 2619]
                          )
                        }
                      spids: [2604]
                    )
                  ]
                  spids: [2604]
                )
                (BraceGroup
                  children: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:reference)
                          op: Equal
                          rhs: {(DQ ($ VSub_Number '$1'))}
                          spids: [2626]
                        )
                      ]
                      spids: [2626]
                    )
                    (C {(die)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ (EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) 
                                        ('reference is not a valid reference')
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [2635 2642]
                          )
                        )
                      }
                    )
                  ]
                  spids: [2623]
                )
              ]
              op_id: Op_DPipe
            )
            (AndOr
              children: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:i_commit)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(git)} {(rev-parse)} {(--verify)} {(--quiet)} 
                                    {(DQ ($ VSub_Name '$REV') ('^2'))}
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [2651 2664]
                          )
                        }
                      spids: [2650]
                    )
                  ]
                  spids: [2650]
                )
                (AndOr
                  children: [
                    (C {(set)} {(--)} 
                      {
                        (CommandSubPart
                          command_list: 
                            (CommandList
                              children: [
                                (SimpleCommand
                                  words: [
                                    {(git)}
                                    {(rev-parse)}
                                    {(DQ ($ VSub_Name '$REV'))}
                                    {(DQ ($ VSub_Name '$REV') ('^1'))}
                                    {(DQ ($ VSub_Name '$REV') (':'))}
                                    {(DQ ($ VSub_Name '$REV') ('^1:'))}
                                    {(DQ ($ VSub_Name '$REV') ('^2:'))}
                                  ]
                                  redirects: [
                                    (Redir
                                      op_id: Redir_Great
                                      fd: 2
                                      arg_word: {(/dev/null)}
                                      spids: [2702]
                                    )
                                  ]
                                )
                              ]
                            )
                          left_token: <Left_CommandSub '$('>
                          spids: [2673 2704]
                        )
                      }
                    )
                    (AndOr
                      children: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:s)
                              op: Equal
                              rhs: {($ VSub_Number '$1')}
                              spids: [2709]
                            )
                          ]
                          spids: [2709]
                        )
                        (AndOr
                          children: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:w_commit)
                                  op: Equal
                                  rhs: {($ VSub_Number '$1')}
                                  spids: [2715]
                                )
                              ]
                              spids: [2715]
                            )
                            (AndOr
                              children: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:b_commit)
                                      op: Equal
                                      rhs: {($ VSub_Number '$2')}
                                      spids: [2721]
                                    )
                                  ]
                                  spids: [2721]
                                )
                                (AndOr
                                  children: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:w_tree)
                                          op: Equal
                                          rhs: {($ VSub_Number '$3')}
                                          spids: [2727]
                                        )
                                      ]
                                      spids: [2727]
                                    )
                                    (AndOr
                                      children: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:b_tree)
                                              op: Equal
                                              rhs: {($ VSub_Number '$4')}
                                              spids: [2733]
                                            )
                                          ]
                                          spids: [2733]
                                        )
                                        (AndOr
                                          children: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:i_tree)
                                                  op: Equal
                                                  rhs: {($ VSub_Number '$5')}
                                                  spids: [2739]
                                                )
                                              ]
                                              spids: [2739]
                                            )
                                            (AndOr
                                              children: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:IS_STASH_LIKE)
                                                      op: Equal
                                                      rhs: {(t)}
                                                      spids: [2745]
                                                    )
                                                  ]
                                                  spids: [2745]
                                                )
                                                (AndOr
                                                  children: [
                                                    (C {(test)} {(DQ ($ VSub_Name '$ref_stash'))} 
                                                      {(Lit_Other '=')} 
                                                      {
                                                        (DQ 
                                                          (CommandSubPart
                                                            command_list: 
                                                              (CommandList
                                                                children: [
                                                                  (C {(git)} {(rev-parse)} 
                                                                    {(--symbolic-full-name)} 
                                                                    {
                                                                      (DQ 
                                                                        (BracedVarSub
                                                                          token: <VSub_Name REV>
                                                                          suffix_op: 
                                                                            (StringUnary
                                                                              op_id: VOp1_Percent
                                                                              arg_word: {('@*')}
                                                                            )
                                                                          spids: [2768 2772]
                                                                        )
                                                                      )
                                                                    }
                                                                  )
                                                                ]
                                                              )
                                                            left_token: <Left_CommandSub '$('>
                                                            spids: [2760 2774]
                                                          )
                                                        )
                                                      }
                                                    )
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:IS_STASH_REF)
                                                          op: Equal
                                                          rhs: {(t)}
                                                          spids: [2780]
                                                        )
                                                      ]
                                                      spids: [2780]
                                                    )
                                                  ]
                                                  op_id: Op_DAmp
                                                )
                                              ]
                                              op_id: Op_DAmp
                                            )
                                          ]
                                          op_id: Op_DAmp
                                        )
                                      ]
                                      op_id: Op_DAmp
                                    )
                                  ]
                                  op_id: Op_DAmp
                                )
                              ]
                              op_id: Op_DAmp
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
            (AndOr
              children: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:u_commit)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(git)} {(rev-parse)} {(--verify)} {(--quiet)} 
                                    {(DQ ($ VSub_Name '$REV') ('^3'))}
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [2786 2799]
                          )
                        }
                      spids: [2785]
                    )
                  ]
                  spids: [2785]
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:u_tree)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (SimpleCommand
                                    words: [{(git)} {(rev-parse)} {(DQ ($ VSub_Name '$REV') ('^3:'))}]
                                    redirects: [
                                      (Redir
                                        op_id: Redir_Great
                                        fd: 2
                                        arg_word: {(/dev/null)}
                                        spids: [2815]
                                      )
                                    ]
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [2805 2817]
                          )
                        }
                      spids: [2804]
                    )
                  ]
                  spids: [2804]
                )
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [2309]
        )
      spids: [2305 2308]
    )
    (FuncDef
      name: is_stash_like
      body: 
        (BraceGroup
          children: [
            (C {(parse_flags_and_rev)} {(DQ ($ VSub_At '$@'))})
            (C {(test)} {(-n)} {(DQ ($ VSub_Name '$IS_STASH_LIKE'))})
          ]
          spids: [2826]
        )
      spids: [2822 2825]
    )
    (FuncDef
      name: assert_stash_like
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(is_stash_like)} {(DQ ($ VSub_At '$@'))})
                (BraceGroup
                  children: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:args)
                          op: Equal
                          rhs: {(DQ ($ VSub_Star '$*'))}
                          spids: [2865]
                        )
                      ]
                      spids: [2865]
                    )
                    (C {(die)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ ("'") (EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) 
                                        ("args' is not a stash-like commit")
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [2874 2882]
                          )
                        )
                      }
                    )
                  ]
                  spids: [2862]
                )
              ]
              op_id: Op_DPipe
            )
          ]
          spids: [2851]
        )
      spids: [2847 2850]
    )
    (FuncDef
      name: is_stash_ref
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(is_stash_like)} {(DQ ($ VSub_At '$@'))})
                (C {(test)} {(-n)} {(DQ ($ VSub_Name '$IS_STASH_REF'))})
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [2895]
        )
      spids: [2891 2894]
    )
    (FuncDef
      name: assert_stash_ref
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(is_stash_ref)} {(DQ ($ VSub_At '$@'))})
                (BraceGroup
                  children: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:args)
                          op: Equal
                          rhs: {(DQ ($ VSub_Star '$*'))}
                          spids: [2935]
                        )
                      ]
                      spids: [2935]
                    )
                    (C {(die)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ ("'") (EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) 
                                        ("args' is not a stash reference")
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [2944 2952]
                          )
                        )
                      }
                    )
                  ]
                  spids: [2932]
                )
              ]
              op_id: Op_DPipe
            )
          ]
          spids: [2921]
        )
      spids: [2917 2920]
    )
    (FuncDef
      name: apply_stash
      body: 
        (BraceGroup
          children: [
            (C {(assert_stash_like)} {(DQ ($ VSub_At '$@'))})
            (AndOr
              children: [
                (C {(git)} {(update-index)} {(-q)} {(--refresh)})
                (C {(die)} 
                  {
                    (DQ 
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [(C {(gettext)} {(DQ ('unable to refresh index'))})]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [2991 2997]
                      )
                    )
                  }
                )
              ]
              op_id: Op_DPipe
            )
            (AndOr
              children: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:c_tree)
                      op: Equal
                      rhs: 
                        {
                          (CommandSubPart
                            command_list: (CommandList children:[(C {(git)} {(write-tree)})])
                            left_token: <Left_CommandSub '$('>
                            spids: [3007 3011]
                          )
                        }
                      spids: [3006]
                    )
                  ]
                  spids: [3006]
                )
                (C {(die)} 
                  {
                    (DQ 
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(gettext)} {(DQ ('Cannot apply a stash in the middle of a merge'))})
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [3019 3025]
                      )
                    )
                  }
                )
              ]
              op_id: Op_DPipe
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:unstashed_index_tree)
                  op: Equal
                  rhs: {(SQ )}
                  spids: [3030]
                )
              ]
              spids: [3030]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (AndOr
                      children: [
                        (C {(test)} {(-n)} {(DQ ($ VSub_Name '$INDEX_OPTION'))})
                        (AndOr
                          children: [
                            (C {(test)} {(DQ ($ VSub_Name '$b_tree'))} {(KW_Bang '!') (Lit_Other '=')} 
                              {(DQ ($ VSub_Name '$i_tree'))}
                            )
                            (C {(test)} {(DQ ($ VSub_Name '$c_tree'))} {(KW_Bang '!') (Lit_Other '=')} 
                              {(DQ ($ VSub_Name '$i_tree'))}
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  action: [
                    (Pipeline
                      children: [
                        (C {(git)} {(diff-tree)} {(--binary)} 
                          {($ VSub_Name '$s') (Lit_Other '^') (2) (Lit_Other '^') (..) 
                            ($ VSub_Name '$s') (Lit_Other '^') (2)
                          }
                        )
                        (C {(git)} {(apply)} {(--cached)})
                      ]
                      negated: False
                    )
                    (AndOr
                      children: [
                        (C {(test)} {($ VSub_QMark '$?')} {(-ne)} {(0)})
                        (C {(die)} 
                          {
                            (DQ 
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(gettext)} {(DQ ('Conflicts in index. Try without --index.'))})
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [3116 3122]
                              )
                            )
                          }
                        )
                      ]
                      op_id: Op_DAmp
                    )
                    (AndOr
                      children: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:unstashed_index_tree)
                              op: Equal
                              rhs: 
                                {
                                  (CommandSubPart
                                    command_list: (CommandList children:[(C {(git)} {(write-tree)})])
                                    left_token: <Left_CommandSub '$('>
                                    spids: [3127 3131]
                                  )
                                }
                              spids: [3126]
                            )
                          ]
                          spids: [3126]
                        )
                        (C {(die)} 
                          {
                            (DQ 
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [(C {(gettext)} {(DQ ('Could not save index tree'))})]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [3139 3145]
                              )
                            )
                          }
                        )
                      ]
                      op_id: Op_DPipe
                    )
                    (C {(git)} {(reset)})
                  ]
                  spids: [16777215 3075]
                )
              ]
              spids: [16777215 3154]
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name '$u_tree'))})]
                  action: [
                    (AndOr
                      children: [
                        (SimpleCommand
                          words: [{(git-read-tree)} {(DQ ($ VSub_Name '$u_tree'))}]
                          more_env: [
                            (env_pair
                              name: GIT_INDEX_FILE
                              val: {(DQ ($ VSub_Name '$TMPindex'))}
                              spids: [3172]
                            )
                          ]
                        )
                        (AndOr
                          children: [
                            (SimpleCommand
                              words: [{(git)} {(checkout-index)} {(--all)}]
                              more_env: [
                                (env_pair
                                  name: GIT_INDEX_FILE
                                  val: {(DQ ($ VSub_Name '$TMPindex'))}
                                  spids: [3186]
                                )
                              ]
                            )
                            (AndOr
                              children: [
                                (C {(rm)} {(-f)} {(DQ ($ VSub_Name '$TMPindex'))})
                                (C {(die)} 
                                  {
                                    (DQ 
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (C {(gettext)} 
                                                {
                                                  (DQ 
                                                    (
'Could not restore untracked files from stash'
                                                    )
                                                  )
                                                }
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub '$('>
                                        spids: [3214 3220]
                                      )
                                    )
                                  }
                                )
                              ]
                              op_id: Op_DPipe
                            )
                          ]
                          op_id: Op_DAmp
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  spids: [16777215 3169]
                )
              ]
              spids: [16777215 3224]
            )
            (C {(eval)} 
              {
                (DQ ('\n') ('\t\tGITHEAD_') ($ VSub_Name '$w_tree') ("='Stashed changes' &&\n") 
                  ('\t\tGITHEAD_') ($ VSub_Name '$c_tree') ("='Updated upstream' &&\n") ('\t\tGITHEAD_') ($ VSub_Name '$b_tree') 
                  ("='Version stash was based on' &&\n") ('\t\texport GITHEAD_') ($ VSub_Name '$w_tree') (' GITHEAD_') ($ VSub_Name '$c_tree') (' GITHEAD_') 
                  ($ VSub_Name '$b_tree') ('\n') ('\t')
                )
              }
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name '$GIT_QUIET'))})]
                  action: [
                    (AndOr
                      children: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:GIT_MERGE_VERBOSITY)
                              op: Equal
                              rhs: {(0)}
                              spids: [3267]
                            )
                          ]
                          spids: [3267]
                        )
                        (C {(export)} {(GIT_MERGE_VERBOSITY)})
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  spids: [16777215 3264]
                )
              ]
              spids: [16777215 3277]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (C {(git)} {(merge-recursive)} {($ VSub_Name '$b_tree')} {(--)} 
                      {($ VSub_Name '$c_tree')} {($ VSub_Name '$w_tree')}
                    )
                  ]
                  action: [
                    (If
                      arms: [
                        (if_arm
                          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name '$unstashed_index_tree'))})]
                          action: [
                            (C {(git)} {(read-tree)} {(DQ ($ VSub_Name '$unstashed_index_tree'))})
                          ]
                          spids: [16777215 3313]
                        )
                      ]
                      else_action: [
                        (AndOr
                          children: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:a)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name '$TMP') (-added))}
                                  spids: [3328]
                                )
                              ]
                              spids: [3328]
                            )
                            (AndOr
                              children: [
                                (SimpleCommand
                                  words: [
                                    {(git)}
                                    {(diff-index)}
                                    {(--cached)}
                                    {(--name-only)}
                                    {(--diff-filter) (Lit_Other '=') (A)}
                                    {($ VSub_Name '$c_tree')}
                                  ]
                                  redirects: [
                                    (Redir
                                      op_id: Redir_Great
                                      fd: 16777215
                                      arg_word: {(DQ ($ VSub_Name '$a'))}
                                      spids: [3351]
                                    )
                                  ]
                                )
                                (AndOr
                                  children: [
                                    (C {(git)} {(read-tree)} {(--reset)} {($ VSub_Name '$c_tree')})
                                    (AndOr
                                      children: [
                                        (SimpleCommand
                                          words: [{(git)} {(update-index)} {(--add)} {(--stdin)}]
                                          redirects: [
                                            (Redir
                                              op_id: Redir_Less
                                              fd: 16777215
                                              arg_word: {(DQ ($ VSub_Name '$a'))}
                                              spids: [3378]
                                            )
                                          ]
                                        )
                                        (C {(die)} 
                                          {
                                            (DQ 
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (C {(gettext)} 
                                                        {(DQ ('Cannot unstage modified files'))}
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_CommandSub '$('>
                                                spids: [3389 3395]
                                              )
                                            )
                                          }
                                        )
                                      ]
                                      op_id: Op_DPipe
                                    )
                                  ]
                                  op_id: Op_DAmp
                                )
                              ]
                              op_id: Op_DAmp
                            )
                          ]
                          op_id: Op_DAmp
                        )
                        (C {(rm)} {(-f)} {(DQ ($ VSub_Name '$a'))})
                      ]
                      spids: [3325 3408]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:squelch)
                          op: Equal
                          rhs: {(SQ )}
                          spids: [3411]
                        )
                      ]
                      spids: [3411]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name '$GIT_QUIET'))})]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:squelch)
                                  op: Equal
                                  rhs: {(SQ <'>/dev/null 2>&1'>)}
                                  spids: [3428]
                                )
                              ]
                              spids: [3428]
                            )
                          ]
                          spids: [16777215 3425]
                        )
                      ]
                      spids: [16777215 3434]
                    )
                    (AndOr
                      children: [
                        (Subshell
                          child: 
                            (AndOr
                              children: [
                                (C {(cd)} {(DQ ($ VSub_Name '$START_DIR'))})
                                (C {(eval)} {(DQ ('git status ') ($ VSub_Name '$squelch'))})
                              ]
                              op_id: Op_DAmp
                            )
                          spids: [3437 3452]
                        )
                        (C {(Lit_Other ':')})
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  spids: [16777215 3295]
                )
              ]
              else_action: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:status)
                      op: Equal
                      rhs: {($ VSub_QMark '$?')}
                      spids: [3466]
                    )
                  ]
                  spids: [3466]
                )
                (C {(git)} {(rerere)})
                (If
                  arms: [
                    (if_arm
                      cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name '$INDEX_OPTION'))})]
                      action: [
                        (SimpleCommand
                          words: [{(gettextln)} {(DQ ('Index was not unstashed.'))}]
                          redirects: [
                            (Redir
                              op_id: Redir_GreatAnd
                              fd: 16777215
                              arg_word: {(2)}
                              spids: [3495]
                            )
                          ]
                        )
                      ]
                      spids: [16777215 3486]
                    )
                  ]
                  spids: [16777215 3499]
                )
                (C {(exit)} {($ VSub_Name '$status')})
              ]
              spids: [3459 3507]
            )
          ]
          spids: [2966]
        )
      spids: [2961 2965]
    )
    (FuncDef
      name: pop_stash
      body: 
        (BraceGroup
          children: [
            (C {(assert_stash_ref)} {(DQ ($ VSub_At '$@'))})
            (If
              arms: [
                (if_arm
                  cond: [(C {(apply_stash)} {(DQ ($ VSub_At '$@'))})]
                  action: [(C {(drop_stash)} {(DQ ($ VSub_At '$@'))})]
                  spids: [16777215 3536]
                )
              ]
              else_action: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:status)
                      op: Equal
                      rhs: {($ VSub_QMark '$?')}
                      spids: [3549]
                    )
                  ]
                  spids: [3549]
                )
                (C {(say)} 
                  {
                    (DQ 
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(gettext)} {(DQ ('The stash is kept in case you need it again.'))})
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [3556 3562]
                      )
                    )
                  }
                )
                (C {(exit)} {($ VSub_Name '$status')})
              ]
              spids: [3546 3571]
            )
          ]
          spids: [3516]
        )
      spids: [3512 3515]
    )
    (FuncDef
      name: drop_stash
      body: 
        (BraceGroup
          children: [
            (C {(assert_stash_ref)} {(DQ ($ VSub_At '$@'))})
            (AndOr
              children: [
                (C {(git)} {(reflog)} {(delete)} {(--updateref)} {(--rewrite)} {(DQ (${ VSub_Name REV))})
                (AndOr
                  children: [
                    (C {(say)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ ('Dropped ') 
                                        (EscapedLiteralPart
                                          token: <Lit_EscapedChar '\\$'>
                                        ) ('{REV} (') (EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) ('s)')
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [3614 3624]
                          )
                        )
                      }
                    )
                    (C {(die)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ (EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) 
                                        ('{REV}: Could not drop stash entry')
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [3633 3640]
                          )
                        )
                      }
                    )
                  ]
                  op_id: Op_DPipe
                )
              ]
              op_id: Op_DAmp
            )
            (AndOr
              children: [
                (SimpleCommand
                  words: [
                    {(git)}
                    {(rev-parse)}
                    {(--verify)}
                    {(--quiet)}
                    {(DQ ($ VSub_Name '$ref_stash') ('@{0}'))}
                  ]
                  redirects: [
                    (Redir
                      op_id: Redir_Great
                      fd: 16777215
                      arg_word: {(/dev/null)}
                      spids: [3662]
                    )
                  ]
                )
                (C {(clear_stash)})
              ]
              op_id: Op_DPipe
            )
          ]
          spids: [3581]
        )
      spids: [3576 3580]
    )
    (FuncDef
      name: apply_to_branch
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_Number '$1'))})
                (C {(die)} 
                  {
                    (DQ 
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [(C {(gettext)} {(DQ ('No branch name specified'))})]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [3694 3700]
                      )
                    )
                  }
                )
              ]
              op_id: Op_DPipe
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:branch)
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                  spids: [3704]
                )
              ]
              spids: [3704]
            )
            (C {(shift)} {(1)})
            (C {(set)} {(--)} {(--index)} {(DQ ($ VSub_At '$@'))})
            (C {(assert_stash_like)} {(DQ ($ VSub_At '$@'))})
            (AndOr
              children: [
                (C {(git)} {(checkout)} {(-b)} {($ VSub_Name '$branch')} 
                  {($ VSub_Name '$REV') (Lit_Other '^')}
                )
                (AndOr
                  children: [
                    (C {(apply_stash)} {(DQ ($ VSub_At '$@'))})
                    (BraceGroup
                      children: [
                        (AndOr
                          children: [
                            (C {(test)} {(-z)} {(DQ ($ VSub_Name '$IS_STASH_REF'))})
                            (C {(drop_stash)} {(DQ ($ VSub_At '$@'))})
                          ]
                          op_id: Op_DPipe
                        )
                      ]
                      spids: [3755]
                    )
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [3678]
        )
      spids: [3673 3677]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:PARSE_CACHE)
          op: Equal
          rhs: {(SQ <--not-parsed>)}
          spids: [3780]
        )
      ]
      spids: [3780]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:seen_non_option) op:Equal rhs:{(SQ )} spids:[3788])]
      spids: [3788]
    )
    (ForEach
      iter_name: opt
      do_arg_iter: True
      body: 
        (DoGroup
          children: [
            (Case
              to_match: {(DQ ($ VSub_Name '$opt'))}
              arms: [
                (case_arm
                  pat_list: [{(-) (Lit_Other '*')}]
                  spids: [3806 3808 3810 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [
                    (Sentence
                      child: 
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:seen_non_option)
                              op: Equal
                              rhs: {(t)}
                              spids: [3816]
                            )
                          ]
                          spids: [3816]
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (ControlFlow token:<ControlFlow_Break break>)
                  ]
                  spids: [3813 3814 3822 16777215]
                )
              ]
              spids: [3797 3803 3825]
            )
          ]
          spids: [3794 3827]
        )
      spids: [16777215 16777215]
    )
    (AndOr
      children: [
        (C {(test)} {(-n)} {(DQ ($ VSub_Name '$seen_non_option'))})
        (C {(set)} {(DQ (save))} {(DQ ($ VSub_At '$@'))})
      ]
      op_id: Op_DPipe
    )
    (Case
      to_match: {(DQ ($ VSub_Number '$1'))}
      arms: [
        (case_arm
          pat_list: [{(list)}]
          action: [(C {(shift)}) (C {(list_stash)} {(DQ ($ VSub_At '$@'))})]
          spids: [3862 3863 3876 16777215]
        )
        (case_arm
          pat_list: [{(show)}]
          action: [(C {(shift)}) (C {(show_stash)} {(DQ ($ VSub_At '$@'))})]
          spids: [3878 3879 3892 16777215]
        )
        (case_arm
          pat_list: [{(save)}]
          action: [(C {(shift)}) (C {(save_stash)} {(DQ ($ VSub_At '$@'))})]
          spids: [3894 3895 3908 16777215]
        )
        (case_arm
          pat_list: [{(apply)}]
          action: [(C {(shift)}) (C {(apply_stash)} {(DQ ($ VSub_At '$@'))})]
          spids: [3910 3911 3924 16777215]
        )
        (case_arm
          pat_list: [{(clear)}]
          action: [(C {(shift)}) (C {(clear_stash)} {(DQ ($ VSub_At '$@'))})]
          spids: [3926 3927 3940 16777215]
        )
        (case_arm
          pat_list: [{(create)}]
          action: [
            (C {(shift)})
            (AndOr
              children: [
                (C {(create_stash)} {(DQ ($ VSub_Star '$*'))})
                (C {(echo)} {(DQ ($ VSub_Name '$w_commit'))})
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [3942 3943 3964 16777215]
        )
        (case_arm
          pat_list: [{(store)}]
          action: [(C {(shift)}) (C {(store_stash)} {(DQ ($ VSub_At '$@'))})]
          spids: [3966 3967 3980 16777215]
        )
        (case_arm
          pat_list: [{(drop)}]
          action: [(C {(shift)}) (C {(drop_stash)} {(DQ ($ VSub_At '$@'))})]
          spids: [3982 3983 3996 16777215]
        )
        (case_arm
          pat_list: [{(pop)}]
          action: [(C {(shift)}) (C {(pop_stash)} {(DQ ($ VSub_At '$@'))})]
          spids: [3998 3999 4012 16777215]
        )
        (case_arm
          pat_list: [{(branch)}]
          action: [(C {(shift)}) (C {(apply_to_branch)} {(DQ ($ VSub_At '$@'))})]
          spids: [4014 4015 4028 16777215]
        )
        (case_arm
          pat_list: [{(Lit_Other '*')}]
          action: [
            (Case
              to_match: {($ VSub_Pound '$#')}
              arms: [
                (case_arm
                  pat_list: [{(0)}]
                  action: [
                    (AndOr
                      children: [
                        (C {(save_stash)})
                        (C {(say)} 
                          {
                            (DQ 
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(gettext)} 
                                        {
                                          (DQ ('(To restore them type ') 
                                            (EscapedLiteralPart
                                              token: <Lit_EscapedChar '\\"'>
                                            ) ('git stash apply') (EscapedLiteralPart token:<Lit_EscapedChar '\\"'>) (')')
                                          )
                                        }
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [4053 4063]
                              )
                            )
                          }
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  spids: [4041 4042 4067 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [(C {(usage)})]
                  spids: [4070 4071 16777215 4077]
                )
              ]
              spids: [4034 4038 4077]
            )
          ]
          spids: [4030 4031 4080 16777215]
        )
      ]
      spids: [3854 3860 4082]
    )
  ]
)