(command.CommandList
  children: [
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:dashless spids:[15])
          op: Equal
          rhs: 
            {
              (word_part.CommandSubPart
                command_list: 
                  (command.CommandList
                    children: [
                      (command.Pipeline
                        children: [
                          (C {(basename)} {(DQ ($ VSub_Number '$0'))})
                          (C {(sed)} {(-e)} {(SQ <'s/-/ /'>)})
                        ]
                        negated: F
                      )
                    ]
                  )
                left_token: <Left_CommandSub '$('>
                spids: [16 32]
              )
            }
          spids: [15]
        )
      ]
      spids: [15]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:USAGE spids:[34])
          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: [34]
        )
      ]
      spids: [34]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:SUBDIRECTORY_OK spids:[59])
          op: Equal
          rhs: {(Yes)}
          spids: [59]
        )
      ]
      spids: [59]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:OPTIONS_SPEC spids:[62])
          op: Equal
          rhs: (word.EmptyWord)
          spids: [62]
        )
      ]
      spids: [62]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:START_DIR spids:[64])
          op: Equal
          rhs: 
            {
              (word_part.CommandSubPart
                command_list: (command.CommandList children:[(C {(pwd)})])
                left_token: <Left_CommandSub '$('>
                spids: [65 67]
              )
            }
          spids: [64]
        )
      ]
      spids: [64]
    )
    (C {(.)} {(git-sh-setup)})
    (C {(require_work_tree)})
    (C {(cd_to_toplevel)})
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:TMP spids:[78])
          op: Equal
          rhs: {(DQ ($ VSub_Name '$GIT_DIR') (/.git-stash.) ($ VSub_Dollar '$$'))}
          spids: [78]
        )
      ]
      spids: [78]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:TMPindex spids:[85])
          op: Equal
          rhs: 
            {
              (word_part.BracedVarSub
                token: <VSub_Name GIT_INDEX_FILE>
                suffix_op: 
                  (suffix_op.StringUnary
                    op_id: VTest_Hyphen
                    arg_word: 
                      {
                        (DQ 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [(C {(git)} {(rev-parse)} {(--git-path)} {(index)})]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [90 98]
                          )
                        )
                      }
                  )
                spids: [86 100]
              ) (.stash.) ($ VSub_Dollar '$$')
            }
          spids: [85]
        )
      ]
      spids: [85]
    )
    (C {(trap)} {(SQ <'rm -f "$TMP-"* "$TMPindex"'>)} {(0)})
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:ref_stash spids:[113])
          op: Equal
          rhs: {(refs/stash)}
          spids: [113]
        )
      ]
      spids: [113]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: (C {(git)} {(config)} {(--get-colorbool)} {(color.interactive)})
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:help_color spids:[131])
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (word_part.CommandSubPart
                          command_list: 
                            (command.CommandList
                              children: [
                                (C {(git)} {(config)} {(--get-color)} {(color.interactive.help)} 
                                  {(SQ <'red bold'>)}
                                )
                              ]
                            )
                          left_token: <Left_CommandSub '$('>
                          spids: [133 145]
                        )
                      )
                    }
                  spids: [131]
                )
              ]
              spids: [131]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:reset_color spids:[149])
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (word_part.CommandSubPart
                          command_list: 
                            (command.CommandList
                              children: [(C {(git)} {(config)} {(--get-color)} {(SQ )} {(reset)})]
                            )
                          left_token: <Left_CommandSub '$('>
                          spids: [151 162]
                        )
                      )
                    }
                  spids: [149]
                )
              ]
              spids: [149]
            )
          ]
          spids: [16777215 128]
        )
      ]
      else_action: [
        (command.Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (lhs_expr.LhsName name:help_color spids:[168])
              op: Equal
              rhs: (word.EmptyWord)
              spids: [168]
            )
          ]
          spids: [168]
        )
        (command.Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (lhs_expr.LhsName name:reset_color spids:[171])
              op: Equal
              rhs: (word.EmptyWord)
              spids: [171]
            )
          ]
          spids: [171]
        )
      ]
      spids: [165 173]
    )
    (command.FuncDef
      name: no_changes
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DAmp Op_DAmp]
              children: [
                (C {(git)} {(diff-index)} {(--quiet)} {(--cached)} {(HEAD)} {(--ignore-submodules)} {(--)})
                (C {(git)} {(diff-files)} {(--quiet)} {(--ignore-submodules)})
                (command.Subshell
                  child: 
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_Name '$untracked'))})
                        (C {(test)} {(-z)} 
                          {
                            (DQ 
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [(C {(untracked_files)})]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [228 230]
                              )
                            )
                          }
                        )
                      ]
                    )
                  spids: [212 232]
                )
              ]
            )
          ]
          spids: [181]
        )
      spids: [176 180]
    )
    (command.FuncDef
      name: untracked_files
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:excl_opt spids:[245])
                  op: Equal
                  rhs: {(--exclude-standard)}
                  spids: [245]
                )
              ]
              spids: [245]
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(DQ ($ VSub_Name '$untracked'))} {(Lit_Other '=')} {(DQ (all))})
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:excl_opt spids:[263])
                      op: Equal
                      rhs: (word.EmptyWord)
                      spids: [263]
                    )
                  ]
                  spids: [263]
                )
              ]
            )
            (C {(git)} {(ls-files)} {(-o)} {(-z)} {($ VSub_Name '$excl_opt')})
          ]
          spids: [242]
        )
      spids: [237 241]
    )
    (command.FuncDef
      name: clear_stash
      body: 
        (command.BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {($ VSub_Pound '$#')} {(KW_Bang '!') (Lit_Other '=')} {(0)})]
                  action: [
                    (C {(die)} 
                      {
                        (DQ 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(gettext)} 
                                    {(DQ ('git stash clear with parameters is unimplemented'))}
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [305 311]
                          )
                        )
                      }
                    )
                  ]
                  spids: [16777215 299]
                )
              ]
              spids: [16777215 315]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:current spids:[320])
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(git)} {(rev-parse)} {(--verify)} {(--quiet)} 
                                        {($ VSub_Name '$ref_stash')}
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [321 331]
                              )
                            }
                          spids: [320]
                        )
                      ]
                      spids: [320]
                    )
                  ]
                  action: [
                    (C {(git)} {(update-ref)} {(-d)} {($ VSub_Name '$ref_stash')} 
                      {($ VSub_Name '$current')}
                    )
                  ]
                  spids: [16777215 334]
                )
              ]
              spids: [16777215 348]
            )
          ]
          spids: [284]
        )
      spids: [279 283]
    )
    (command.FuncDef
      name: create_stash
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:stash_msg spids:[361])
                  op: Equal
                  rhs: {(DQ ($ VSub_Number '$1'))}
                  spids: [361]
                )
              ]
              spids: [361]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:untracked spids:[367])
                  op: Equal
                  rhs: {(DQ ($ VSub_Number '$2'))}
                  spids: [367]
                )
              ]
              spids: [367]
            )
            (C {(git)} {(update-index)} {(-q)} {(--refresh)})
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(no_changes)})]
                  action: [(command.ControlFlow token:<ControlFlow_Exit exit> arg_word:{(0)})]
                  spids: [16777215 388]
                )
              ]
              spids: [16777215 396]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:b_commit spids:[406])
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [(C {(git)} {(rev-parse)} {(--verify)} {(HEAD)})]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [407 415]
                              )
                            }
                          spids: [406]
                        )
                      ]
                      spids: [406]
                    )
                  ]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:head spids:[421])
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(git)} {(rev-list)} {(--oneline)} {(-n)} {(1)} {(HEAD)} {(--)})
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [422 436]
                              )
                            }
                          spids: [421]
                        )
                      ]
                      spids: [421]
                    )
                  ]
                  spids: [16777215 418]
                )
              ]
              else_action: [
                (C {(die)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [(C {(gettext)} {(DQ ('You do not have the initial commit yet'))})]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [445 451]
                      )
                    )
                  }
                )
              ]
              spids: [439 455]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:branch spids:[461])
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [(C {(git)} {(symbolic-ref)} {(-q)} {(HEAD)})]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [462 470]
                              )
                            }
                          spids: [461]
                        )
                      ]
                      spids: [461]
                    )
                  ]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:branch spids:[476])
                          op: Equal
                          rhs: 
                            {
                              (word_part.BracedVarSub
                                token: <VSub_Name branch>
                                suffix_op: 
                                  (suffix_op.StringUnary
                                    op_id: VOp1_Pound
                                    arg_word: {(refs) (Lit_Slash /) (heads) (Lit_Slash /)}
                                  )
                                spids: [477 484]
                              )
                            }
                          spids: [476]
                        )
                      ]
                      spids: [476]
                    )
                  ]
                  spids: [16777215 473]
                )
              ]
              else_action: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:branch spids:[490])
                      op: Equal
                      rhs: {(SQ <'(no branch)'>)}
                      spids: [490]
                    )
                  ]
                  spids: [490]
                )
              ]
              spids: [487 496]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:msg spids:[499])
                  op: Equal
                  rhs: 
                    {
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {(printf)} {(SQ <'%s: %s'>)} {(DQ ($ VSub_Name '$branch'))} 
                                {(DQ ($ VSub_Name '$head'))}
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [500 514]
                      )
                    }
                  spids: [499]
                )
              ]
              spids: [499]
            )
            (command.AndOr
              ops: [Op_DAmp Op_DPipe]
              children: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:i_tree spids:[522])
                      op: Equal
                      rhs: 
                        {
                          (word_part.CommandSubPart
                            command_list: (command.CommandList children:[(C {(git)} {(write-tree)})])
                            left_token: <Left_CommandSub '$('>
                            spids: [523 527]
                          )
                        }
                      spids: [522]
                    )
                  ]
                  spids: [522]
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:i_commit spids:[532])
                      op: Equal
                      rhs: 
                        {
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (command.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: F
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [533 556]
                          )
                        }
                      spids: [532]
                    )
                  ]
                  spids: [532]
                )
                (C {(die)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [(C {(gettext)} {(DQ ('Cannot save the current index state'))})]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [564 570]
                      )
                    )
                  }
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name '$untracked'))})]
                  action: [
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:u_commit spids:[597])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (command.Pipeline
                                            children: [
                                              (C {(untracked_files)})
                                              (command.Subshell
                                                child: 
                                                  (command.AndOr
                                                    ops: [Op_DAmp Op_DAmp Op_DAmp Op_DAmp Op_DAmp Op_DAmp]
                                                    children: [
                                                      (command.Assignment
                                                        keyword: Assign_None
                                                        pairs: [
                                                          (assign_pair
                                                            lhs: 
                                                              (lhs_expr.LhsName
                                                                name: GIT_INDEX_FILE
                                                                spids: [608]
                                                              )
                                                            op: Equal
                                                            rhs: {(DQ ($ VSub_Name '$TMPindex'))}
                                                            spids: [608]
                                                          )
                                                        ]
                                                        spids: [608]
                                                      )
                                                      (C {(export)} {(GIT_INDEX_FILE)})
                                                      (C {(rm)} {(-f)} {(DQ ($ VSub_Name '$TMPindex'))})
                                                      (C {(git)} {(update-index)} {(-z)} {(--add)} 
                                                        {(--remove)} {(--stdin)}
                                                      )
                                                      (command.Assignment
                                                        keyword: Assign_None
                                                        pairs: [
                                                          (assign_pair
                                                            lhs: 
                                                              (lhs_expr.LhsName
                                                                name: u_tree
                                                                spids: [649]
                                                              )
                                                            op: Equal
                                                            rhs: 
                                                              {
                                                                (word_part.CommandSubPart
                                                                  command_list: 
                                                                    (command.CommandList
                                                                      children: [
                                                                        (C {(git)} {(write-tree)})
                                                                      ]
                                                                    )
                                                                  left_token: <Left_CommandSub '$('>
                                                                  spids: [650 654]
                                                                )
                                                              }
                                                            spids: [649]
                                                          )
                                                        ]
                                                        spids: [649]
                                                      )
                                                      (command.Pipeline
                                                        children: [
                                                          (C {(printf)} 
                                                            {(SQ <'untracked files on %s\\n'>)} {(DQ ($ VSub_Name '$msg'))}
                                                          )
                                                          (C {(git)} {(commit-tree)} 
                                                            {($ VSub_Name '$u_tree')}
                                                          )
                                                        ]
                                                        negated: F
                                                      )
                                                      (C {(rm)} {(-f)} {(DQ ($ VSub_Name '$TMPindex'))})
                                                    ]
                                                  )
                                                spids: [605 689]
                                              )
                                            ]
                                            negated: F
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [598 691]
                                  )
                                }
                              spids: [597]
                            )
                          ]
                          spids: [597]
                        )
                        (C {(die)} 
                          {
                            (DQ 
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(gettext)} {(DQ ('Cannot save the untracked files'))})
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [698 704]
                              )
                            )
                          }
                        )
                      ]
                    )
                    (command.Sentence
                      child: 
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:untracked_commit_option spids:[709])
                              op: Equal
                              rhs: {(DQ ('-p ') ($ VSub_Name '$u_commit'))}
                              spids: [709]
                            )
                          ]
                          spids: [709]
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  spids: [16777215 586]
                )
              ]
              else_action: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:untracked_commit_option spids:[720])
                      op: Equal
                      rhs: (word.EmptyWord)
                      spids: [720]
                    )
                  ]
                  spids: [720]
                )
              ]
              spids: [717 723]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name '$patch_mode'))})]
                  action: [
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:w_tree spids:[746])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (command.Subshell
                                            child: 
                                              (command.AndOr
                                                ops: [Op_DAmp Op_DAmp Op_DAmp Op_DAmp Op_DAmp Op_DAmp]
                                                children: [
                                                  (C {(git)} {(read-tree)} 
                                                    {(--index-output) (Lit_Other '=') 
                                                      (DQ ($ VSub_Name '$TMPindex'))
                                                    } {(-m)} {($ VSub_Name '$i_tree')}
                                                  )
                                                  (command.Assignment
                                                    keyword: Assign_None
                                                    pairs: [
                                                      (assign_pair
                                                        lhs: 
                                                          (lhs_expr.LhsName
                                                            name: GIT_INDEX_FILE
                                                            spids: [769]
                                                          )
                                                        op: Equal
                                                        rhs: {(DQ ($ VSub_Name '$TMPindex'))}
                                                        spids: [769]
                                                      )
                                                    ]
                                                    spids: [769]
                                                  )
                                                  (C {(export)} {(GIT_INDEX_FILE)})
                                                  (command.SimpleCommand
                                                    words: [
                                                      {(git)}
                                                      {(diff)}
                                                      {(--name-only)}
                                                      {(-z)}
                                                      {(HEAD)}
                                                      {(--)}
                                                    ]
                                                    redirects: [
                                                      (redir.Redir
                                                        op: <Redir_Great '>'>
                                                        fd: 16777215
                                                        arg_word: 
                                                          {(DQ ($ VSub_Name '$TMP') (-stagenames))}
                                                      )
                                                    ]
                                                  )
                                                  (command.SimpleCommand
                                                    words: [
                                                      {(git)}
                                                      {(update-index)}
                                                      {(-z)}
                                                      {(--add)}
                                                      {(--remove)}
                                                      {(--stdin)}
                                                    ]
                                                    redirects: [
                                                      (redir.Redir
                                                        op: <Redir_Less '<'>
                                                        fd: 16777215
                                                        arg_word: 
                                                          {(DQ ($ VSub_Name '$TMP') (-stagenames))}
                                                      )
                                                    ]
                                                  )
                                                  (C {(git)} {(write-tree)})
                                                  (C {(rm)} {(-f)} {(DQ ($ VSub_Name '$TMPindex'))})
                                                ]
                                              )
                                            spids: [749 842]
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [747 844]
                                  )
                                }
                              spids: [746]
                            )
                          ]
                          spids: [746]
                        )
                        (C {(die)} 
                          {
                            (DQ 
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(gettext)} {(DQ ('Cannot save the current worktree state'))})
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [852 858]
                              )
                            )
                          }
                        )
                      ]
                    )
                  ]
                  spids: [16777215 738]
                )
              ]
              else_action: [
                (command.AndOr
                  ops: [Op_DAmp Op_DAmp Op_DAmp Op_DPipe]
                  children: [
                    (C {(rm)} {(-f)} {(DQ ($ VSub_Name '$TMP') (-index))})
                    (command.SimpleCommand
                      words: [{(git)} {(read-tree)} {(HEAD)}]
                      more_env: [
                        (env_pair
                          name: GIT_INDEX_FILE
                          val: {(DQ ($ VSub_Name '$TMP') (-index))}
                          spids: [879]
                        )
                      ]
                    )
                    (command.SimpleCommand
                      words: [{(git)} {(add--interactive)} {(--patch) (Lit_Other '=') (stash)} {(--)}]
                      more_env: [
                        (env_pair
                          name: GIT_INDEX_FILE
                          val: {(DQ ($ VSub_Name '$TMP') (-index))}
                          spids: [899]
                        )
                      ]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:w_tree spids:[925])
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (command.SimpleCommand
                                        words: [{(git)} {(write-tree)}]
                                        more_env: [
                                          (env_pair
                                            name: GIT_INDEX_FILE
                                            val: {(DQ ($ VSub_Name '$TMP') (-index))}
                                            spids: [927]
                                          )
                                        ]
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [926 936]
                              )
                            }
                          spids: [925]
                        )
                      ]
                      spids: [925]
                    )
                    (C {(die)} 
                      {
                        (DQ 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(gettext)} {(DQ ('Cannot save the current worktree state'))})
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [944 950]
                          )
                        )
                      }
                    )
                  ]
                )
                (command.AndOr
                  ops: [Op_DAmp Op_DPipe]
                  children: [
                    (command.SimpleCommand
                      words: [{(git)} {(diff-tree)} {(-p)} {(HEAD)} {($ VSub_Name '$w_tree')} {(--)}]
                      redirects: [
                        (redir.Redir
                          op: <Redir_Great '>'>
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_Name '$TMP') (-patch))}
                        )
                      ]
                    )
                    (C {(test)} {(-s)} {(DQ ($ VSub_Name '$TMP') (-patch))})
                    (C {(die)} 
                      {
                        (DQ 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [(C {(gettext)} {(DQ ('No changes selected'))})]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [991 997]
                          )
                        )
                      }
                    )
                  ]
                )
                (command.AndOr
                  ops: [Op_DPipe]
                  children: [
                    (C {(rm)} {(-f)} {(DQ ($ VSub_Name '$TMP') (-index))})
                    (C {(die)} 
                      {
                        (DQ 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(gettext)} {(DQ ("Cannot remove temporary index (can't happen)"))})
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [1017 1023]
                          )
                        )
                      }
                    )
                  ]
                )
              ]
              spids: [863 1028]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name '$stash_msg'))})]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:stash_msg spids:[1050])
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(printf)} {(SQ <'WIP on %s'>)} {(DQ ($ VSub_Name '$msg'))})
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [1051 1061]
                              )
                            }
                          spids: [1050]
                        )
                      ]
                      spids: [1050]
                    )
                  ]
                  spids: [16777215 1047]
                )
              ]
              else_action: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:stash_msg spids:[1067])
                      op: Equal
                      rhs: 
                        {
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(printf)} {(SQ <'On %s: %s'>)} {(DQ ($ VSub_Name '$branch'))} 
                                    {(DQ ($ VSub_Name '$stash_msg'))}
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [1068 1082]
                          )
                        }
                      spids: [1067]
                    )
                  ]
                  spids: [1067]
                )
              ]
              spids: [1064 1085]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:w_commit spids:[1088])
                      op: Equal
                      rhs: 
                        {
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (command.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: F
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [1089 1118]
                          )
                        }
                      spids: [1088]
                    )
                  ]
                  spids: [1088]
                )
                (C {(die)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [(C {(gettext)} {(DQ ('Cannot record working tree state'))})]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [1126 1132]
                      )
                    )
                  }
                )
              ]
            )
          ]
          spids: [358]
        )
      spids: [353 357]
    )
    (command.FuncDef
      name: store_stash
      body: 
        (command.BraceGroup
          children: [
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [(C {(test)} {($ VSub_Pound '$#')} {(KW_Bang '!') (Lit_Other '=')} {(0)})]
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ VSub_Number '$1'))}
                      arms: [
                        (case_arm
                          pat_list: [{(-m)} {(--message)}]
                          action: [
                            (C {(shift)})
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:stash_msg spids:[1179])
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Number '$1'))}
                                  spids: [1179]
                                )
                              ]
                              spids: [1179]
                            )
                          ]
                          spids: [1170 1173 1185 16777215]
                        )
                        (case_arm
                          pat_list: [{(-q)} {(--quiet)}]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:quiet spids:[1194])
                                  op: Equal
                                  rhs: {(t)}
                                  spids: [1194]
                                )
                              ]
                              spids: [1194]
                            )
                          ]
                          spids: [1188 1191 1198 16777215]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other '*')}]
                          action: [(command.ControlFlow token:<ControlFlow_Break break>)]
                          spids: [1201 1202 1208 16777215]
                        )
                      ]
                      spids: [1161 1167 1211]
                    )
                    (C {(shift)})
                  ]
                  spids: [1158 1217]
                )
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(test)} {($ VSub_Pound '$#')} {(Lit_Other '=')} {(1)})
                (C {(die)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {(eval_gettext)} 
                                {
                                  (DQ (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\"'>) 
                                    ($ VSub_Name '$dashless') (' store') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\"'>) 
                                    (' requires one <commit> argument')
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [1234 1244]
                      )
                    )
                  }
                )
              ]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:w_commit spids:[1249])
                  op: Equal
                  rhs: {(DQ ($ VSub_Number '$1'))}
                  spids: [1249]
                )
              ]
              spids: [1249]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name '$stash_msg'))})]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:stash_msg spids:[1269])
                          op: Equal
                          rhs: 
                            {
                              (DQ ('Created via ') 
                                (word_part.EscapedLiteralPart
                                  token: <Lit_EscapedChar '\\"'>
                                ) ('git stash store') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\"'>) (.)
                              )
                            }
                          spids: [1269]
                        )
                      ]
                      spids: [1269]
                    )
                  ]
                  spids: [16777215 1266]
                )
              ]
              spids: [16777215 1279]
            )
            (C {(git)} {(update-ref)} {(--create-reflog)} {(-m)} {(DQ ($ VSub_Name '$stash_msg'))} 
              {($ VSub_Name '$ref_stash')} {($ VSub_Name '$w_commit')}
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:ret spids:[1300])
                  op: Equal
                  rhs: {($ VSub_QMark '$?')}
                  spids: [1300]
                )
              ]
              spids: [1300]
            )
            (command.AndOr
              ops: [Op_DAmp Op_DAmp]
              children: [
                (C {(test)} {($ VSub_Name '$ret')} {(KW_Bang '!') (Lit_Other '=')} {(0)})
                (C {(test)} {(-z)} {(DQ ($ VSub_Name '$quiet'))})
                (C {(die)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {(eval_gettext)} 
                                {
                                  (DQ ('Cannot update ') 
                                    (word_part.EscapedLiteralPart
                                      token: <Lit_EscapedChar '\\$'>
                                    ) ('ref_stash with ') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) (w_commit)
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [1329 1339]
                      )
                    )
                  }
                )
              ]
            )
            (command.ControlFlow
              token: <ControlFlow_Return return>
              arg_word: {($ VSub_Name '$ret')}
            )
          ]
          spids: [1143]
        )
      spids: [1138 1142]
    )
    (command.FuncDef
      name: save_stash
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:keep_index spids:[1358])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [1358]
                )
              ]
              spids: [1358]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:patch_mode spids:[1361])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [1361]
                )
              ]
              spids: [1361]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:untracked spids:[1364])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [1364]
                )
              ]
              spids: [1364]
            )
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [(C {(test)} {($ VSub_Pound '$#')} {(KW_Bang '!') (Lit_Other '=')} {(0)})]
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ VSub_Number '$1'))}
                      arms: [
                        (case_arm
                          pat_list: [{(-k)} {(--keep-index)}]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:keep_index spids:[1397])
                                  op: Equal
                                  rhs: {(t)}
                                  spids: [1397]
                                )
                              ]
                              spids: [1397]
                            )
                          ]
                          spids: [1391 1394 1401 16777215]
                        )
                        (case_arm
                          pat_list: [{(--no-keep-index)}]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:keep_index spids:[1408])
                                  op: Equal
                                  rhs: {(n)}
                                  spids: [1408]
                                )
                              ]
                              spids: [1408]
                            )
                          ]
                          spids: [1404 1405 1412 16777215]
                        )
                        (case_arm
                          pat_list: [{(-p)} {(--patch)}]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:patch_mode spids:[1421])
                                  op: Equal
                                  rhs: {(t)}
                                  spids: [1421]
                                )
                              ]
                              spids: [1421]
                            )
                            (command.AndOr
                              ops: [Op_DAmp]
                              children: [
                                (C {(test)} {(-z)} {(DQ ($ VSub_Name '$keep_index'))})
                                (command.Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:keep_index spids:[1439])
                                      op: Equal
                                      rhs: {(t)}
                                      spids: [1439]
                                    )
                                  ]
                                  spids: [1439]
                                )
                              ]
                            )
                          ]
                          spids: [1415 1418 1443 16777215]
                        )
                        (case_arm
                          pat_list: [{(-q)} {(--quiet)}]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:GIT_QUIET spids:[1452])
                                  op: Equal
                                  rhs: {(t)}
                                  spids: [1452]
                                )
                              ]
                              spids: [1452]
                            )
                          ]
                          spids: [1446 1449 1456 16777215]
                        )
                        (case_arm
                          pat_list: [{(-u)} {(--include-untracked)}]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:untracked spids:[1465])
                                  op: Equal
                                  rhs: {(untracked)}
                                  spids: [1465]
                                )
                              ]
                              spids: [1465]
                            )
                          ]
                          spids: [1459 1462 1469 16777215]
                        )
                        (case_arm
                          pat_list: [{(-a)} {(--all)}]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:untracked spids:[1478])
                                  op: Equal
                                  rhs: {(all)}
                                  spids: [1478]
                                )
                              ]
                              spids: [1478]
                            )
                          ]
                          spids: [1472 1475 1482 16777215]
                        )
                        (case_arm
                          pat_list: [{(--help)}]
                          action: [(C {(show_help)})]
                          spids: [1485 1486 1492 16777215]
                        )
                        (case_arm
                          pat_list: [{(--)}]
                          action: [(C {(shift)}) (command.ControlFlow token:<ControlFlow_Break break>)]
                          spids: [1495 1496 1505 16777215]
                        )
                        (case_arm
                          pat_list: [{(-) (Lit_Other '*')}]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:option spids:[1513])
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Number '$1'))}
                                  spids: [1513]
                                )
                              ]
                              spids: [1513]
                            )
                            (C {(eval_gettextln)} 
                              {
                                (DQ ("error: unknown option for 'stash save': ") 
                                  (word_part.EscapedLiteralPart
                                    token: <Lit_EscapedChar '\\$'>
                                  ) ('option\n') ("       To provide a message, use git stash save -- '") 
                                  (word_part.EscapedLiteralPart
                                    token: <Lit_EscapedChar '\\$'>
                                  ) ("option'")
                                )
                              }
                            )
                            (C {(usage)})
                          ]
                          spids: [1508 1510 1574 16777215]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other '*')}]
                          action: [(command.ControlFlow token:<ControlFlow_Break break>)]
                          spids: [1577 1578 1584 16777215]
                        )
                      ]
                      spids: [1382 1388 1587]
                    )
                    (C {(shift)})
                  ]
                  spids: [1379 1593]
                )
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(-n)} {(DQ ($ VSub_Name '$patch_mode'))})
                        (C {(test)} {(-n)} {(DQ ($ VSub_Name '$untracked'))})
                      ]
                    )
                  ]
                  action: [
                    (C {(die)} 
                      {
                        (DQ 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(gettext)} 
                                    {
                                      (DQ 
                                        (
"Can't use --patch and --include-untracked or --all at the same time"
                                        )
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [1624 1630]
                          )
                        )
                      }
                    )
                  ]
                  spids: [16777215 1618]
                )
              ]
              spids: [16777215 1634]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:stash_msg spids:[1638])
                  op: Equal
                  rhs: {(DQ ($ VSub_Star '$*'))}
                  spids: [1638]
                )
              ]
              spids: [1638]
            )
            (C {(git)} {(update-index)} {(-q)} {(--refresh)})
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(no_changes)})]
                  action: [
                    (C {(say)} 
                      {
                        (DQ 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [(C {(gettext)} {(DQ ('No local changes to save'))})]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [1665 1671]
                          )
                        )
                      }
                    )
                    (command.ControlFlow
                      token: <ControlFlow_Exit exit>
                      arg_word: {(0)}
                    )
                  ]
                  spids: [16777215 1659]
                )
              ]
              spids: [16777215 1680]
            )
            (command.AndOr
              ops: [Op_DPipe Op_DPipe]
              children: [
                (C {(git)} {(reflog)} {(exists)} {($ VSub_Name '$ref_stash')})
                (C {(clear_stash)})
                (C {(die)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [(C {(gettext)} {(DQ ('Cannot initialize stash'))})]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [1701 1707]
                      )
                    )
                  }
                )
              ]
            )
            (C {(create_stash)} {(DQ ($ VSub_Name '$stash_msg'))} {($ VSub_Name '$untracked')})
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(store_stash)} {(-m)} {(DQ ($ VSub_Name '$stash_msg'))} {(-q)} 
                  {($ VSub_Name '$w_commit')}
                )
                (C {(die)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [(C {(gettext)} {(DQ ('Cannot save the current status'))})]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [1739 1745]
                      )
                    )
                  }
                )
              ]
            )
            (C {(say)} 
              {
                (DQ 
                  (word_part.CommandSubPart
                    command_list: 
                      (command.CommandList
                        children: [
                          (C {(eval_gettext)} 
                            {
                              (DQ ('Saved working directory and index state ') 
                                (word_part.EscapedLiteralPart
                                  token: <Lit_EscapedChar '\\$'>
                                ) (stash_msg)
                              )
                            }
                          )
                        ]
                      )
                    left_token: <Left_CommandSub '$('>
                    spids: [1752 1760]
                  )
                )
              }
            )
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name '$patch_mode'))})]
                  action: [
                    (C {(git)} {(reset)} {(--hard)} 
                      {
                        (word_part.BracedVarSub
                          token: <VSub_Name GIT_QUIET>
                          suffix_op: (suffix_op.StringUnary op_id:VTest_ColonPlus arg_word:{(-q)})
                          spids: [1785 1789]
                        )
                      }
                    )
                    (command.AndOr
                      ops: [Op_DAmp Op_DPipe]
                      children: [
                        (C {(test)} {(DQ ($ VSub_Name '$untracked'))} {(Lit_Other '=')} {(DQ (all))})
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:CLEAN_X_OPTION spids:[1806])
                              op: Equal
                              rhs: {(-x)}
                              spids: [1806]
                            )
                          ]
                          spids: [1806]
                        )
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:CLEAN_X_OPTION spids:[1811])
                              op: Equal
                              rhs: (word.EmptyWord)
                              spids: [1811]
                            )
                          ]
                          spids: [1811]
                        )
                      ]
                    )
                    (command.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 1825]
                        )
                      ]
                      spids: [16777215 1841]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.AndOr
                              ops: [Op_DAmp]
                              children: [
                                (C {(test)} {(DQ ($ VSub_Name '$keep_index'))} {(Lit_Other '=')} 
                                  {(DQ (t))}
                                )
                                (C {(test)} {(-n)} {(DQ ($ VSub_Name '$i_tree'))})
                              ]
                            )
                          ]
                          action: [
                            (C {(git)} {(read-tree)} {(--reset)} {(-u)} {($ VSub_Name '$i_tree')})
                          ]
                          spids: [16777215 1870]
                        )
                      ]
                      spids: [16777215 1884]
                    )
                  ]
                  spids: [16777215 1776]
                )
              ]
              else_action: [
                (command.AndOr
                  ops: [Op_DPipe]
                  children: [
                    (command.SimpleCommand
                      words: [{(git)} {(apply)} {(-R)}]
                      redirects: [
                        (redir.Redir
                          op: <Redir_Less '<'>
                          fd: 16777215
                          arg_word: {(DQ ($ VSub_Name '$TMP') (-patch))}
                        )
                      ]
                    )
                    (C {(die)} 
                      {
                        (DQ 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [(C {(gettext)} {(DQ ('Cannot remove worktree changes'))})]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [1909 1915]
                          )
                        )
                      }
                    )
                  ]
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: [
                        (C {(test)} {(DQ ($ VSub_Name '$keep_index'))} {(KW_Bang '!') (Lit_Other '=')} 
                          {(DQ (t))}
                        )
                      ]
                      action: [(C {(git)} {(reset)})]
                      spids: [16777215 1936]
                    )
                  ]
                  spids: [16777215 1944]
                )
              ]
              spids: [1887 1947]
            )
          ]
          spids: [1355]
        )
      spids: [1350 1354]
    )
    (command.FuncDef
      name: have_stash
      body: 
        (command.BraceGroup
          children: [
            (command.SimpleCommand
              words: [{(git)} {(rev-parse)} {(--verify)} {(--quiet)} {($ VSub_Name '$ref_stash')}]
              redirects: [(redir.Redir op:<Redir_Great '>'> fd:16777215 arg_word:{(/dev/null)})]
            )
          ]
          spids: [1957]
        )
      spids: [1952 1956]
    )
    (command.FuncDef
      name: list_stash
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(have_stash)})
                (command.ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
              ]
            )
            (C {(git)} {(log)} {(--format) (Lit_Other '=') (DQ ('%gd: %gs'))} {(-g)} {(--first-parent)} 
              {(-m)} {(DQ ($ VSub_At '$@'))} {($ VSub_Name '$ref_stash')} {(--)}
            )
          ]
          spids: [1981]
        )
      spids: [1976 1980]
    )
    (command.FuncDef
      name: show_stash
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:ALLOW_UNKNOWN_FLAGS spids:[2028])
                  op: Equal
                  rhs: {(t)}
                  spids: [2028]
                )
              ]
              spids: [2028]
            )
            (C {(assert_stash_like)} {(DQ ($ VSub_At '$@'))})
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name '$FLAGS'))})]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (C {(test)} 
                              {
                                (DQ 
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (command.AndOr
                                            ops: [Op_DPipe]
                                            children: [
                                              (C {(git)} {(config)} {(--bool)} {(stash.showStat)})
                                              (C {(echo)} {(true)})
                                            ]
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [2059 2073]
                                  )
                                )
                              } {(Lit_Other '=')} {(DQ (true))}
                            )
                          ]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:FLAGS spids:[2086])
                                  op: Equal
                                  rhs: {(--stat)}
                                  spids: [2086]
                                )
                              ]
                              spids: [2086]
                            )
                          ]
                          spids: [16777215 2083]
                        )
                      ]
                      spids: [16777215 2090]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (C {(test)} 
                              {
                                (DQ 
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (command.AndOr
                                            ops: [Op_DPipe]
                                            children: [
                                              (C {(git)} {(config)} {(--bool)} {(stash.showPatch)})
                                              (C {(echo)} {(false)})
                                            ]
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [2099 2113]
                                  )
                                )
                              } {(Lit_Other '=')} {(DQ (true))}
                            )
                          ]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:FLAGS spids:[2126])
                                  op: Equal
                                  rhs: 
                                    {(${ VSub_Name FLAGS) 
                                      (word_part.BracedVarSub
                                        token: <VSub_Name FLAGS>
                                        suffix_op: 
                                          (suffix_op.StringUnary
                                            op_id: VTest_ColonPlus
                                            arg_word: {(' ')}
                                          )
                                        spids: [2130 2134]
                                      ) (-p)
                                    }
                                  spids: [2126]
                                )
                              ]
                              spids: [2126]
                            )
                          ]
                          spids: [16777215 2123]
                        )
                      ]
                      spids: [16777215 2138]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name '$FLAGS'))})]
                          action: [
                            (command.ControlFlow
                              token: <ControlFlow_Return return>
                              arg_word: {(0)}
                            )
                          ]
                          spids: [16777215 2153]
                        )
                      ]
                      spids: [16777215 2161]
                    )
                  ]
                  spids: [16777215 2051]
                )
              ]
              spids: [16777215 2164]
            )
            (C {(git)} {(diff)} {(${ VSub_Name FLAGS)} {($ VSub_Name '$b_commit')} 
              {($ VSub_Name '$w_commit')}
            )
          ]
          spids: [2025]
        )
      spids: [2020 2024]
    )
    (command.FuncDef
      name: show_help
      body: 
        (command.BraceGroup
          children: [
            (C {(exec)} {(git)} {(help)} {(stash)})
            (command.ControlFlow token:<ControlFlow_Exit exit> arg_word:{(1)})
          ]
          spids: [2188]
        )
      spids: [2183 2187]
    )
    (command.FuncDef
      name: parse_flags_and_rev
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(DQ ($ VSub_Name '$PARSE_CACHE'))} {(Lit_Other '=')} 
                  {(DQ ($ VSub_Star '$*'))}
                )
                (command.ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
              ]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:PARSE_CACHE spids:[2342])
                  op: Equal
                  rhs: {(DQ ($ VSub_Star '$*'))}
                  spids: [2342]
                )
              ]
              spids: [2342]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:IS_STASH_LIKE spids:[2349])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [2349]
                )
              ]
              spids: [2349]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:IS_STASH_REF spids:[2352])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [2352]
                )
              ]
              spids: [2352]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:INDEX_OPTION spids:[2355])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [2355]
                )
              ]
              spids: [2355]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:s spids:[2358])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [2358]
                )
              ]
              spids: [2358]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:w_commit spids:[2361])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [2361]
                )
              ]
              spids: [2361]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:b_commit spids:[2364])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [2364]
                )
              ]
              spids: [2364]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:i_commit spids:[2367])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [2367]
                )
              ]
              spids: [2367]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:u_commit spids:[2370])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [2370]
                )
              ]
              spids: [2370]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:w_tree spids:[2373])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [2373]
                )
              ]
              spids: [2373]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:b_tree spids:[2376])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [2376]
                )
              ]
              spids: [2376]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:i_tree spids:[2379])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [2379]
                )
              ]
              spids: [2379]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:u_tree spids:[2382])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [2382]
                )
              ]
              spids: [2382]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:REV spids:[2386])
                      op: Equal
                      rhs: 
                        {
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(git)} {(rev-parse)} {(--no-flags)} {(--symbolic)} {(--sq)} 
                                    {(DQ ($ VSub_At '$@'))}
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [2387 2401]
                          )
                        }
                      spids: [2386]
                    )
                  ]
                  spids: [2386]
                )
                (command.ControlFlow token:<ControlFlow_Exit exit> arg_word:{(1)})
              ]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:FLAGS spids:[2411])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [2411]
                )
              ]
              spids: [2411]
            )
            (command.ForEach
              iter_name: opt
              do_arg_iter: T
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ VSub_Name '$opt'))}
                      arms: [
                        (case_arm
                          pat_list: [{(-q)} {(--quiet)}]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:GIT_QUIET spids:[2437])
                                  op: Equal
                                  rhs: {(-t)}
                                  spids: [2437]
                                )
                              ]
                              spids: [2437]
                            )
                          ]
                          spids: [2431 2434 2441 16777215]
                        )
                        (case_arm
                          pat_list: [{(--index)}]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:INDEX_OPTION spids:[2448])
                                  op: Equal
                                  rhs: {(--index)}
                                  spids: [2448]
                                )
                              ]
                              spids: [2448]
                            )
                          ]
                          spids: [2444 2445 2452 16777215]
                        )
                        (case_arm
                          pat_list: [{(--help)}]
                          action: [(C {(show_help)})]
                          spids: [2455 2456 2462 16777215]
                        )
                        (case_arm
                          pat_list: [{(-) (Lit_Other '*')}]
                          action: [
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {(test)} {(DQ ($ VSub_Name '$ALLOW_UNKNOWN_FLAGS'))} 
                                  {(Lit_Other '=')} {(t)}
                                )
                                (C {(die)} 
                                  {
                                    (DQ 
                                      (word_part.CommandSubPart
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (C {(eval_gettext)} 
                                                {
                                                  (DQ ('unknown option: ') 
                                                    (word_part.EscapedLiteralPart
                                                      token: <Lit_EscapedChar '\\$'>
                                                    ) (opt)
                                                  )
                                                }
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub '$('>
                                        spids: [2486 2494]
                                      )
                                    )
                                  }
                                )
                              ]
                            )
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:FLAGS spids:[2498])
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ (${ VSub_Name FLAGS) 
                                        (word_part.BracedVarSub
                                          token: <VSub_Name FLAGS>
                                          suffix_op: 
                                            (suffix_op.StringUnary
                                              op_id: VTest_ColonPlus
                                              arg_word: {(' ')}
                                            )
                                          spids: [2503 2507]
                                        ) ($ VSub_Name '$opt')
                                      )
                                    }
                                  spids: [2498]
                                )
                              ]
                              spids: [2498]
                            )
                          ]
                          spids: [2465 2467 2512 16777215]
                        )
                      ]
                      spids: [2422 2428 2515]
                    )
                  ]
                  spids: [2419 2518]
                )
              spids: [16777215 16777215]
            )
            (C {(eval)} {(set)} {(--)} {($ VSub_Name '$REV')})
            (command.Case
              to_match: {($ VSub_Pound '$#')}
              arms: [
                (case_arm
                  pat_list: [{(0)}]
                  action: [
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(have_stash)})
                        (C {(die)} 
                          {
                            (DQ 
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [(C {(gettext)} {(DQ ('No stash found.'))})]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [2550 2556]
                              )
                            )
                          }
                        )
                      ]
                    )
                    (C {(set)} {(--)} 
                      {(${ VSub_Name ref_stash) (Lit_Other '@') (Lit_LBrace '{') (0) (Lit_RBrace '}')}
                    )
                  ]
                  spids: [2539 2540 2573 16777215]
                )
                (case_arm
                  pat_list: [{(1)}]
                  action: [(C {(Lit_Other ':')})]
                  spids: [2576 2577 2583 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [
                    (C {(die)} 
                      {
                        (DQ 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ ('Too many revisions specified: ') 
                                        (word_part.EscapedLiteralPart
                                          token: <Lit_EscapedChar '\\$'>
                                        ) (REV)
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [2593 2601]
                          )
                        )
                      }
                    )
                  ]
                  spids: [2586 2587 2605 16777215]
                )
              ]
              spids: [2532 2536 2608]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:REV spids:[2612])
                      op: Equal
                      rhs: 
                        {
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(git)} {(rev-parse)} {(--symbolic)} {(--verify)} {(--quiet)} 
                                    {(DQ ($ VSub_Number '$1'))}
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [2613 2627]
                          )
                        }
                      spids: [2612]
                    )
                  ]
                  spids: [2612]
                )
                (command.BraceGroup
                  children: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:reference spids:[2634])
                          op: Equal
                          rhs: {(DQ ($ VSub_Number '$1'))}
                          spids: [2634]
                        )
                      ]
                      spids: [2634]
                    )
                    (C {(die)} 
                      {
                        (DQ 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) 
                                        ('reference is not a valid reference')
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [2643 2650]
                          )
                        )
                      }
                    )
                  ]
                  spids: [2631]
                )
              ]
            )
            (command.AndOr
              ops: [Op_DAmp Op_DAmp Op_DAmp Op_DAmp Op_DAmp Op_DAmp Op_DAmp Op_DAmp Op_DAmp Op_DAmp]
              children: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:i_commit spids:[2658])
                      op: Equal
                      rhs: 
                        {
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(git)} {(rev-parse)} {(--verify)} {(--quiet)} 
                                    {(DQ ($ VSub_Name '$REV') ('^2'))}
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [2659 2672]
                          )
                        }
                      spids: [2658]
                    )
                  ]
                  spids: [2658]
                )
                (C {(set)} {(--)} 
                  {
                    (word_part.CommandSubPart
                      command_list: 
                        (command.CommandList
                          children: [
                            (command.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.Redir
                                  op: <Redir_Great '2>'>
                                  fd: 2
                                  arg_word: {(/dev/null)}
                                )
                              ]
                            )
                          ]
                        )
                      left_token: <Left_CommandSub '$('>
                      spids: [2681 2712]
                    )
                  }
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:s spids:[2717])
                      op: Equal
                      rhs: {($ VSub_Number '$1')}
                      spids: [2717]
                    )
                  ]
                  spids: [2717]
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:w_commit spids:[2723])
                      op: Equal
                      rhs: {($ VSub_Number '$1')}
                      spids: [2723]
                    )
                  ]
                  spids: [2723]
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:b_commit spids:[2729])
                      op: Equal
                      rhs: {($ VSub_Number '$2')}
                      spids: [2729]
                    )
                  ]
                  spids: [2729]
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:w_tree spids:[2735])
                      op: Equal
                      rhs: {($ VSub_Number '$3')}
                      spids: [2735]
                    )
                  ]
                  spids: [2735]
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:b_tree spids:[2741])
                      op: Equal
                      rhs: {($ VSub_Number '$4')}
                      spids: [2741]
                    )
                  ]
                  spids: [2741]
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:i_tree spids:[2747])
                      op: Equal
                      rhs: {($ VSub_Number '$5')}
                      spids: [2747]
                    )
                  ]
                  spids: [2747]
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:IS_STASH_LIKE spids:[2753])
                      op: Equal
                      rhs: {(t)}
                      spids: [2753]
                    )
                  ]
                  spids: [2753]
                )
                (C {(test)} {(DQ ($ VSub_Name '$ref_stash'))} {(Lit_Other '=')} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {(git)} {(rev-parse)} {(--symbolic-full-name)} 
                                {
                                  (DQ 
                                    (word_part.BracedVarSub
                                      token: <VSub_Name REV>
                                      suffix_op: 
                                        (suffix_op.StringUnary
                                          op_id: VOp1_Percent
                                          arg_word: {('@*')}
                                        )
                                      spids: [2776 2780]
                                    )
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [2768 2782]
                      )
                    )
                  }
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:IS_STASH_REF spids:[2788])
                      op: Equal
                      rhs: {(t)}
                      spids: [2788]
                    )
                  ]
                  spids: [2788]
                )
              ]
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:u_commit spids:[2793])
                      op: Equal
                      rhs: 
                        {
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(git)} {(rev-parse)} {(--verify)} {(--quiet)} 
                                    {(DQ ($ VSub_Name '$REV') ('^3'))}
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [2794 2807]
                          )
                        }
                      spids: [2793]
                    )
                  ]
                  spids: [2793]
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:u_tree spids:[2812])
                      op: Equal
                      rhs: 
                        {
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (command.SimpleCommand
                                    words: [{(git)} {(rev-parse)} {(DQ ($ VSub_Name '$REV') ('^3:'))}]
                                    redirects: [
                                      (redir.Redir
                                        op: <Redir_Great '2>'>
                                        fd: 2
                                        arg_word: {(/dev/null)}
                                      )
                                    ]
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [2813 2825]
                          )
                        }
                      spids: [2812]
                    )
                  ]
                  spids: [2812]
                )
              ]
            )
          ]
          spids: [2317]
        )
      spids: [2313 2316]
    )
    (command.FuncDef
      name: is_stash_like
      body: 
        (command.BraceGroup
          children: [
            (C {(parse_flags_and_rev)} {(DQ ($ VSub_At '$@'))})
            (C {(test)} {(-n)} {(DQ ($ VSub_Name '$IS_STASH_LIKE'))})
          ]
          spids: [2834]
        )
      spids: [2830 2833]
    )
    (command.FuncDef
      name: assert_stash_like
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(is_stash_like)} {(DQ ($ VSub_At '$@'))})
                (command.BraceGroup
                  children: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:args spids:[2873])
                          op: Equal
                          rhs: {(DQ ($ VSub_Star '$*'))}
                          spids: [2873]
                        )
                      ]
                      spids: [2873]
                    )
                    (C {(die)} 
                      {
                        (DQ 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ ("'") 
                                        (word_part.EscapedLiteralPart
                                          token: <Lit_EscapedChar '\\$'>
                                        ) ("args' is not a stash-like commit")
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [2882 2890]
                          )
                        )
                      }
                    )
                  ]
                  spids: [2870]
                )
              ]
            )
          ]
          spids: [2859]
        )
      spids: [2855 2858]
    )
    (command.FuncDef
      name: is_stash_ref
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(is_stash_like)} {(DQ ($ VSub_At '$@'))})
                (C {(test)} {(-n)} {(DQ ($ VSub_Name '$IS_STASH_REF'))})
              ]
            )
          ]
          spids: [2903]
        )
      spids: [2899 2902]
    )
    (command.FuncDef
      name: assert_stash_ref
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(is_stash_ref)} {(DQ ($ VSub_At '$@'))})
                (command.BraceGroup
                  children: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:args spids:[2943])
                          op: Equal
                          rhs: {(DQ ($ VSub_Star '$*'))}
                          spids: [2943]
                        )
                      ]
                      spids: [2943]
                    )
                    (C {(die)} 
                      {
                        (DQ 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ ("'") 
                                        (word_part.EscapedLiteralPart
                                          token: <Lit_EscapedChar '\\$'>
                                        ) ("args' is not a stash reference")
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [2952 2960]
                          )
                        )
                      }
                    )
                  ]
                  spids: [2940]
                )
              ]
            )
          ]
          spids: [2929]
        )
      spids: [2925 2928]
    )
    (command.FuncDef
      name: apply_stash
      body: 
        (command.BraceGroup
          children: [
            (C {(assert_stash_like)} {(DQ ($ VSub_At '$@'))})
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(git)} {(update-index)} {(-q)} {(--refresh)})
                (C {(die)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [(C {(gettext)} {(DQ ('unable to refresh index'))})]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [2999 3005]
                      )
                    )
                  }
                )
              ]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:c_tree spids:[3014])
                      op: Equal
                      rhs: 
                        {
                          (word_part.CommandSubPart
                            command_list: (command.CommandList children:[(C {(git)} {(write-tree)})])
                            left_token: <Left_CommandSub '$('>
                            spids: [3015 3019]
                          )
                        }
                      spids: [3014]
                    )
                  ]
                  spids: [3014]
                )
                (C {(die)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {(gettext)} {(DQ ('Cannot apply a stash in the middle of a merge'))})
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [3027 3033]
                      )
                    )
                  }
                )
              ]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:unstashed_index_tree spids:[3038])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [3038]
                )
              ]
              spids: [3038]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.AndOr
                      ops: [Op_DAmp Op_DAmp]
                      children: [
                        (C {(test)} {(-n)} {(DQ ($ VSub_Name '$INDEX_OPTION'))})
                        (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'))}
                        )
                      ]
                    )
                  ]
                  action: [
                    (command.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: F
                    )
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {($ VSub_QMark '$?')} {(-ne)} {(0)})
                        (C {(die)} 
                          {
                            (DQ 
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(gettext)} {(DQ ('Conflicts in index. Try without --index.'))})
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [3124 3130]
                              )
                            )
                          }
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:unstashed_index_tree spids:[3134])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [(C {(git)} {(write-tree)})]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [3135 3139]
                                  )
                                }
                              spids: [3134]
                            )
                          ]
                          spids: [3134]
                        )
                        (C {(die)} 
                          {
                            (DQ 
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [(C {(gettext)} {(DQ ('Could not save index tree'))})]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [3147 3153]
                              )
                            )
                          }
                        )
                      ]
                    )
                    (C {(git)} {(reset)})
                  ]
                  spids: [16777215 3083]
                )
              ]
              spids: [16777215 3162]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name '$u_tree'))})]
                  action: [
                    (command.AndOr
                      ops: [Op_DAmp Op_DAmp Op_DPipe]
                      children: [
                        (command.SimpleCommand
                          words: [{(git-read-tree)} {(DQ ($ VSub_Name '$u_tree'))}]
                          more_env: [
                            (env_pair
                              name: GIT_INDEX_FILE
                              val: {(DQ ($ VSub_Name '$TMPindex'))}
                              spids: [3180]
                            )
                          ]
                        )
                        (command.SimpleCommand
                          words: [{(git)} {(checkout-index)} {(--all)}]
                          more_env: [
                            (env_pair
                              name: GIT_INDEX_FILE
                              val: {(DQ ($ VSub_Name '$TMPindex'))}
                              spids: [3194]
                            )
                          ]
                        )
                        (C {(rm)} {(-f)} {(DQ ($ VSub_Name '$TMPindex'))})
                        (C {(die)} 
                          {
                            (DQ 
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(gettext)} 
                                        {(DQ ('Could not restore untracked files from stash'))}
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [3222 3228]
                              )
                            )
                          }
                        )
                      ]
                    )
                  ]
                  spids: [16777215 3177]
                )
              ]
              spids: [16777215 3232]
            )
            (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')
                )
              }
            )
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name '$GIT_QUIET'))})]
                  action: [
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:GIT_MERGE_VERBOSITY spids:[3275])
                              op: Equal
                              rhs: {(0)}
                              spids: [3275]
                            )
                          ]
                          spids: [3275]
                        )
                        (C {(export)} {(GIT_MERGE_VERBOSITY)})
                      ]
                    )
                  ]
                  spids: [16777215 3272]
                )
              ]
              spids: [16777215 3285]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (C {(git)} {(merge-recursive)} {($ VSub_Name '$b_tree')} {(--)} 
                      {($ VSub_Name '$c_tree')} {($ VSub_Name '$w_tree')}
                    )
                  ]
                  action: [
                    (command.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 3321]
                        )
                      ]
                      else_action: [
                        (command.AndOr
                          ops: [Op_DAmp Op_DAmp Op_DAmp Op_DPipe]
                          children: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:a spids:[3336])
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Name '$TMP') (-added))}
                                  spids: [3336]
                                )
                              ]
                              spids: [3336]
                            )
                            (command.SimpleCommand
                              words: [
                                {(git)}
                                {(diff-index)}
                                {(--cached)}
                                {(--name-only)}
                                {(--diff-filter) (Lit_Other '=') (A)}
                                {($ VSub_Name '$c_tree')}
                              ]
                              redirects: [
                                (redir.Redir
                                  op: <Redir_Great '>'>
                                  fd: 16777215
                                  arg_word: {(DQ ($ VSub_Name '$a'))}
                                )
                              ]
                            )
                            (C {(git)} {(read-tree)} {(--reset)} {($ VSub_Name '$c_tree')})
                            (command.SimpleCommand
                              words: [{(git)} {(update-index)} {(--add)} {(--stdin)}]
                              redirects: [
                                (redir.Redir
                                  op: <Redir_Less '<'>
                                  fd: 16777215
                                  arg_word: {(DQ ($ VSub_Name '$a'))}
                                )
                              ]
                            )
                            (C {(die)} 
                              {
                                (DQ 
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(gettext)} {(DQ ('Cannot unstage modified files'))})
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [3397 3403]
                                  )
                                )
                              }
                            )
                          ]
                        )
                        (C {(rm)} {(-f)} {(DQ ($ VSub_Name '$a'))})
                      ]
                      spids: [3333 3416]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:squelch spids:[3419])
                          op: Equal
                          rhs: (word.EmptyWord)
                          spids: [3419]
                        )
                      ]
                      spids: [3419]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name '$GIT_QUIET'))})]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:squelch spids:[3436])
                                  op: Equal
                                  rhs: {(SQ <'>/dev/null 2>&1'>)}
                                  spids: [3436]
                                )
                              ]
                              spids: [3436]
                            )
                          ]
                          spids: [16777215 3433]
                        )
                      ]
                      spids: [16777215 3442]
                    )
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (command.Subshell
                          child: 
                            (command.AndOr
                              ops: [Op_DAmp]
                              children: [
                                (C {(cd)} {(DQ ($ VSub_Name '$START_DIR'))})
                                (C {(eval)} {(DQ ('git status ') ($ VSub_Name '$squelch'))})
                              ]
                            )
                          spids: [3445 3460]
                        )
                        (C {(Lit_Other ':')})
                      ]
                    )
                  ]
                  spids: [16777215 3303]
                )
              ]
              else_action: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:status spids:[3474])
                      op: Equal
                      rhs: {($ VSub_QMark '$?')}
                      spids: [3474]
                    )
                  ]
                  spids: [3474]
                )
                (C {(git)} {(rerere)})
                (command.If
                  arms: [
                    (if_arm
                      cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name '$INDEX_OPTION'))})]
                      action: [
                        (command.SimpleCommand
                          words: [{(gettextln)} {(DQ ('Index was not unstashed.'))}]
                          redirects: [(redir.Redir op:<Redir_GreatAnd '>&'> fd:16777215 arg_word:{(2)})]
                        )
                      ]
                      spids: [16777215 3494]
                    )
                  ]
                  spids: [16777215 3507]
                )
                (command.ControlFlow
                  token: <ControlFlow_Exit exit>
                  arg_word: {($ VSub_Name '$status')}
                )
              ]
              spids: [3467 3515]
            )
          ]
          spids: [2974]
        )
      spids: [2969 2973]
    )
    (command.FuncDef
      name: pop_stash
      body: 
        (command.BraceGroup
          children: [
            (C {(assert_stash_ref)} {(DQ ($ VSub_At '$@'))})
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(apply_stash)} {(DQ ($ VSub_At '$@'))})]
                  action: [(C {(drop_stash)} {(DQ ($ VSub_At '$@'))})]
                  spids: [16777215 3544]
                )
              ]
              else_action: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:status spids:[3557])
                      op: Equal
                      rhs: {($ VSub_QMark '$?')}
                      spids: [3557]
                    )
                  ]
                  spids: [3557]
                )
                (C {(say)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {(gettext)} {(DQ ('The stash is kept in case you need it again.'))})
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [3564 3570]
                      )
                    )
                  }
                )
                (command.ControlFlow
                  token: <ControlFlow_Exit exit>
                  arg_word: {($ VSub_Name '$status')}
                )
              ]
              spids: [3554 3579]
            )
          ]
          spids: [3524]
        )
      spids: [3520 3523]
    )
    (command.FuncDef
      name: drop_stash
      body: 
        (command.BraceGroup
          children: [
            (C {(assert_stash_ref)} {(DQ ($ VSub_At '$@'))})
            (command.AndOr
              ops: [Op_DAmp Op_DPipe]
              children: [
                (C {(git)} {(reflog)} {(delete)} {(--updateref)} {(--rewrite)} {(DQ (${ VSub_Name REV))})
                (C {(say)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {(eval_gettext)} 
                                {
                                  (DQ ('Dropped ') 
                                    (word_part.EscapedLiteralPart
                                      token: <Lit_EscapedChar '\\$'>
                                    ) ('{REV} (') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) ('s)')
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [3622 3632]
                      )
                    )
                  }
                )
                (C {(die)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {(eval_gettext)} 
                                {
                                  (DQ (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) 
                                    ('{REV}: Could not drop stash entry')
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [3641 3648]
                      )
                    )
                  }
                )
              ]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (command.SimpleCommand
                  words: [
                    {(git)}
                    {(rev-parse)}
                    {(--verify)}
                    {(--quiet)}
                    {(DQ ($ VSub_Name '$ref_stash') ('@{0}'))}
                  ]
                  redirects: [(redir.Redir op:<Redir_Great '>'> fd:16777215 arg_word:{(/dev/null)})]
                )
                (C {(clear_stash)})
              ]
            )
          ]
          spids: [3589]
        )
      spids: [3584 3588]
    )
    (command.FuncDef
      name: apply_to_branch
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_Number '$1'))})
                (C {(die)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [(C {(gettext)} {(DQ ('No branch name specified'))})]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [3702 3708]
                      )
                    )
                  }
                )
              ]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:branch spids:[3712])
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                  spids: [3712]
                )
              ]
              spids: [3712]
            )
            (C {(shift)} {(1)})
            (C {(set)} {(--)} {(--index)} {(DQ ($ VSub_At '$@'))})
            (C {(assert_stash_like)} {(DQ ($ VSub_At '$@'))})
            (command.AndOr
              ops: [Op_DAmp Op_DAmp]
              children: [
                (C {(git)} {(checkout)} {(-b)} {($ VSub_Name '$branch')} 
                  {($ VSub_Name '$REV') (Lit_Other '^')}
                )
                (C {(apply_stash)} {(DQ ($ VSub_At '$@'))})
                (command.BraceGroup
                  children: [
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_Name '$IS_STASH_REF'))})
                        (C {(drop_stash)} {(DQ ($ VSub_At '$@'))})
                      ]
                    )
                  ]
                  spids: [3763]
                )
              ]
            )
          ]
          spids: [3686]
        )
      spids: [3681 3685]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:PARSE_CACHE spids:[3788])
          op: Equal
          rhs: {(SQ <--not-parsed>)}
          spids: [3788]
        )
      ]
      spids: [3788]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:seen_non_option spids:[3796])
          op: Equal
          rhs: (word.EmptyWord)
          spids: [3796]
        )
      ]
      spids: [3796]
    )
    (command.ForEach
      iter_name: opt
      do_arg_iter: T
      body: 
        (command.DoGroup
          children: [
            (command.Case
              to_match: {(DQ ($ VSub_Name '$opt'))}
              arms: [
                (case_arm
                  pat_list: [{(-) (Lit_Other '*')}]
                  spids: [3814 3816 3818 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [
                    (command.Sentence
                      child: 
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:seen_non_option spids:[3824])
                              op: Equal
                              rhs: {(t)}
                              spids: [3824]
                            )
                          ]
                          spids: [3824]
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (command.ControlFlow token:<ControlFlow_Break break>)
                  ]
                  spids: [3821 3822 3830 16777215]
                )
              ]
              spids: [3805 3811 3833]
            )
          ]
          spids: [3802 3835]
        )
      spids: [16777215 16777215]
    )
    (command.AndOr
      ops: [Op_DPipe]
      children: [
        (C {(test)} {(-n)} {(DQ ($ VSub_Name '$seen_non_option'))})
        (C {(set)} {(DQ (save))} {(DQ ($ VSub_At '$@'))})
      ]
    )
    (command.Case
      to_match: {(DQ ($ VSub_Number '$1'))}
      arms: [
        (case_arm
          pat_list: [{(list)}]
          action: [(C {(shift)}) (C {(list_stash)} {(DQ ($ VSub_At '$@'))})]
          spids: [3870 3871 3884 16777215]
        )
        (case_arm
          pat_list: [{(show)}]
          action: [(C {(shift)}) (C {(show_stash)} {(DQ ($ VSub_At '$@'))})]
          spids: [3886 3887 3900 16777215]
        )
        (case_arm
          pat_list: [{(save)}]
          action: [(C {(shift)}) (C {(save_stash)} {(DQ ($ VSub_At '$@'))})]
          spids: [3902 3903 3916 16777215]
        )
        (case_arm
          pat_list: [{(apply)}]
          action: [(C {(shift)}) (C {(apply_stash)} {(DQ ($ VSub_At '$@'))})]
          spids: [3918 3919 3932 16777215]
        )
        (case_arm
          pat_list: [{(clear)}]
          action: [(C {(shift)}) (C {(clear_stash)} {(DQ ($ VSub_At '$@'))})]
          spids: [3934 3935 3948 16777215]
        )
        (case_arm
          pat_list: [{(create)}]
          action: [
            (C {(shift)})
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(create_stash)} {(DQ ($ VSub_Star '$*'))})
                (C {(echo)} {(DQ ($ VSub_Name '$w_commit'))})
              ]
            )
          ]
          spids: [3950 3951 3972 16777215]
        )
        (case_arm
          pat_list: [{(store)}]
          action: [(C {(shift)}) (C {(store_stash)} {(DQ ($ VSub_At '$@'))})]
          spids: [3974 3975 3988 16777215]
        )
        (case_arm
          pat_list: [{(drop)}]
          action: [(C {(shift)}) (C {(drop_stash)} {(DQ ($ VSub_At '$@'))})]
          spids: [3990 3991 4004 16777215]
        )
        (case_arm
          pat_list: [{(pop)}]
          action: [(C {(shift)}) (C {(pop_stash)} {(DQ ($ VSub_At '$@'))})]
          spids: [4006 4007 4020 16777215]
        )
        (case_arm
          pat_list: [{(branch)}]
          action: [(C {(shift)}) (C {(apply_to_branch)} {(DQ ($ VSub_At '$@'))})]
          spids: [4022 4023 4036 16777215]
        )
        (case_arm
          pat_list: [{(Lit_Other '*')}]
          action: [
            (command.Case
              to_match: {($ VSub_Pound '$#')}
              arms: [
                (case_arm
                  pat_list: [{(0)}]
                  action: [
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(save_stash)})
                        (C {(say)} 
                          {
                            (DQ 
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(gettext)} 
                                        {
                                          (DQ ('(To restore them type ') 
                                            (word_part.EscapedLiteralPart
                                              token: <Lit_EscapedChar '\\"'>
                                            ) ('git stash apply') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\"'>) (')')
                                          )
                                        }
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [4061 4071]
                              )
                            )
                          }
                        )
                      ]
                    )
                  ]
                  spids: [4049 4050 4075 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [(C {(usage)})]
                  spids: [4078 4079 16777215 4085]
                )
              ]
              spids: [4042 4046 4085]
            )
          ]
          spids: [4038 4039 4088 16777215]
        )
      ]
      spids: [3862 3868 4090]
    )
  ]
)