(command.CommandList
  children: [
    (C {(.)} {(git-sh-i18n)})
    (C {(unset)} {(CDPATH)})
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:IFS spids:[47])
          op: Equal
          rhs: {(SQ <' \t\n'>)}
          spids: [47]
        )
      ]
      spids: [47]
    )
    (command.FuncDef
      name: git_broken_path_fix
      body: 
        (command.BraceGroup
          children: [
            (command.Case
              to_match: {(DQ (':') ($ VSub_DollarName '$PATH') (':'))}
              arms: [
                (case_arm
                  pat_list: [
                    {(Lit_Other '*') (Lit_Other ':') ($ VSub_Number '$1') (Lit_Other ':') 
                      (Lit_Other '*')
                    }
                  ]
                  action: [(C {(Lit_Other ':')} {(ok)})]
                  spids: [72 77 83 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:PATH spids:[90])
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (command.Assignment
                                        keyword: Assign_None
                                        pairs: [
                                          (assign_pair
                                            lhs: (lhs_expr.LhsName name:SANE_TOOL_PATH spids:[94])
                                            op: Equal
                                            rhs: {(DQ ($ VSub_Number '$1'))}
                                            spids: [94]
                                          )
                                        ]
                                        spids: [94]
                                      )
                                      (command.Assignment
                                        keyword: Assign_None
                                        pairs: [
                                          (assign_pair
                                            lhs: (lhs_expr.LhsName name:IFS spids:[100])
                                            op: Equal
                                            rhs: {(Lit_Other ':')}
                                            spids: [100]
                                          )
                                          (assign_pair
                                            lhs: (lhs_expr.LhsName name:path spids:[103])
                                            op: Equal
                                            rhs: (word.EmptyWord)
                                            spids: [103]
                                          )
                                          (assign_pair
                                            lhs: (lhs_expr.LhsName name:sep spids:[105])
                                            op: Equal
                                            rhs: (word.EmptyWord)
                                            spids: [105]
                                          )
                                        ]
                                        spids: [100]
                                      )
                                      (C {(set)} {(x)} {($ VSub_DollarName '$PATH')})
                                      (C {(shift)})
                                      (command.ForEach
                                        iter_name: elem
                                        do_arg_iter: T
                                        body: 
                                          (command.DoGroup
                                            children: [
                                              (command.Case
                                                to_match: 
                                                  {
                                                    (DQ ($ VSub_DollarName '$SANE_TOOL_PATH') (':') 
                                                      ($ VSub_DollarName '$elem')
                                                    )
                                                  }
                                                arms: [
                                                  (case_arm
                                                    pat_list: [
                                                      {(Lit_Other '?') (Lit_Other '*') 
                                                        (Lit_Other ':') (/bin)
                                                      }
                                                      {(Lit_Other '?') (Lit_Other '*') 
                                                        (Lit_Other ':') (/usr/bin)
                                                      }
                                                    ]
                                                    action: [
                                                      (command.Assignment
                                                        keyword: Assign_None
                                                        pairs: [
                                                          (assign_pair
                                                            lhs: 
                                                              (lhs_expr.LhsName
                                                                name: path
                                                                spids: [152]
                                                              )
                                                            op: Equal
                                                            rhs: 
                                                              {
                                                                (DQ ($ VSub_DollarName '$path') 
                                                                  ($ VSub_DollarName '$sep') ($ VSub_DollarName '$SANE_TOOL_PATH')
                                                                )
                                                              }
                                                            spids: [152]
                                                          )
                                                        ]
                                                        spids: [152]
                                                      )
                                                      (command.Assignment
                                                        keyword: Assign_None
                                                        pairs: [
                                                          (assign_pair
                                                            lhs: 
                                                              (lhs_expr.LhsName
                                                                name: sep
                                                                spids: [160]
                                                              )
                                                            op: Equal
                                                            rhs: {(Lit_Other ':')}
                                                            spids: [160]
                                                          )
                                                        ]
                                                        spids: [160]
                                                      )
                                                      (command.Assignment
                                                        keyword: Assign_None
                                                        pairs: [
                                                          (assign_pair
                                                            lhs: 
                                                              (lhs_expr.LhsName
                                                                name: SANE_TOOL_PATH
                                                                spids: [164]
                                                              )
                                                            op: Equal
                                                            rhs: (word.EmptyWord)
                                                            spids: [164]
                                                          )
                                                        ]
                                                        spids: [164]
                                                      )
                                                    ]
                                                    spids: [137 149 16777215 167]
                                                  )
                                                ]
                                                spids: [126 134 167]
                                              )
                                              (command.Assignment
                                                keyword: Assign_None
                                                pairs: [
                                                  (assign_pair
                                                    lhs: (lhs_expr.LhsName name:path spids:[170])
                                                    op: Equal
                                                    rhs: 
                                                      {
                                                        (DQ ($ VSub_DollarName '$path') 
                                                          ($ VSub_DollarName '$sep') ($ VSub_DollarName '$elem')
                                                        )
                                                      }
                                                    spids: [170]
                                                  )
                                                ]
                                                spids: [170]
                                              )
                                              (command.Assignment
                                                keyword: Assign_None
                                                pairs: [
                                                  (assign_pair
                                                    lhs: (lhs_expr.LhsName name:sep spids:[178])
                                                    op: Equal
                                                    rhs: {(Lit_Other ':')}
                                                    spids: [178]
                                                  )
                                                ]
                                                spids: [178]
                                              )
                                            ]
                                            spids: [123 182]
                                          )
                                        spids: [16777215 16777215]
                                      )
                                      (C {(echo)} {(DQ ($ VSub_DollarName '$path'))})
                                    ]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [91 192]
                              )
                            }
                          spids: [90]
                        )
                      ]
                      spids: [90]
                    )
                  ]
                  spids: [86 87 195 16777215]
                )
              ]
              spids: [61 69 198]
            )
          ]
          spids: [58]
        )
      spids: [53 57]
    )
    (command.FuncDef
      name: die
      body: 
        (command.BraceGroup
          children: [(C {(die_with_status)} {(1)} {(DQ ($ VSub_At '$@'))})]
          spids: [212]
        )
      spids: [207 211]
    )
    (command.FuncDef
      name: die_with_status
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:status spids:[234])
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                  spids: [234]
                )
              ]
              spids: [234]
            )
            (C {(shift)})
            (command.SimpleCommand
              words: [{(printf)} {(SQ <'%s\\n'>)} {(DQ ($ VSub_Star '$*'))}]
              redirects: [(redir.Redir op:<Redir_GreatAnd '>&'> fd:16777215 arg_word:{(2)})]
            )
            (command.ControlFlow
              token: <ControlFlow_Exit exit>
              arg_word: {(DQ ($ VSub_DollarName '$status'))}
            )
          ]
          spids: [231]
        )
      spids: [226 230]
    )
    (command.Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:GIT_QUIET spids:[264])
          op: Equal
          rhs: (word.EmptyWord)
          spids: [264]
        )
      ]
      spids: [264]
    )
    (command.FuncDef
      name: say
      body: 
        (command.BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$GIT_QUIET'))})]
                  action: [(C {(printf)} {(SQ <'%s\\n'>)} {(DQ ($ VSub_Star '$*'))})]
                  spids: [16777215 286]
                )
              ]
              spids: [16777215 300]
            )
          ]
          spids: [272]
        )
      spids: [267 271]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.Sentence
              child: (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$OPTIONS_SPEC'))})
              terminator: <Op_Semi ';'>
            )
          ]
          action: [
            (command.FuncDef
              name: usage
              body: 
                (command.BraceGroup
                  children: [
                    (C {(DQ ($ VSub_Number '$0'))} {(-h)})
                    (command.ControlFlow
                      token: <ControlFlow_Exit exit>
                      arg_word: {(1)}
                    )
                  ]
                  spids: [323]
                )
              spids: [319 322]
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:parseopt_extra spids:[342])
                  op: Equal
                  rhs: (word.EmptyWord)
                  spids: [342]
                )
              ]
              spids: [342]
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(Lit_Other '[')} {(-n)} {(DQ ($ VSub_DollarName '$OPTIONS_KEEPDASHDASH'))} 
                  {(Lit_Other ']')}
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:parseopt_extra spids:[358])
                      op: Equal
                      rhs: {(DQ (--keep-dashdash))}
                      spids: [358]
                    )
                  ]
                  spids: [358]
                )
              ]
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(Lit_Other '[')} {(-n)} {(DQ ($ VSub_DollarName '$OPTIONS_STUCKLONG'))} 
                  {(Lit_Other ']')}
                )
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:parseopt_extra spids:[377])
                      op: Equal
                      rhs: {(DQ ($ VSub_DollarName '$parseopt_extra') (' --stuck-long'))}
                      spids: [377]
                    )
                  ]
                  spids: [377]
                )
              ]
            )
            (C {(eval)} 
              {
                (DQ 
                  (word_part.CommandSubPart
                    command_list: 
                      (command.CommandList
                        children: [
                          (command.AndOr
                            ops: [Op_DPipe]
                            children: [
                              (command.Pipeline
                                children: [
                                  (C {(echo)} {(DQ ($ VSub_DollarName '$OPTIONS_SPEC'))})
                                  (C {(git)} {(rev-parse)} {(--parseopt)} 
                                    {($ VSub_DollarName '$parseopt_extra')} {(--)} {(DQ ($ VSub_At '$@'))}
                                  )
                                ]
                                negated: F
                              )
                              (C {(echo)} {(ControlFlow_Exit exit)} {($ VSub_QMark '$?')})
                            ]
                          )
                        ]
                      )
                    left_token: <Left_CommandSub '$('>
                    spids: [388 424]
                  )
                )
              }
            )
          ]
          spids: [16777215 316]
        )
      ]
      else_action: [
        (command.Assignment
          keyword: Assign_None
          pairs: [
            (assign_pair
              lhs: (lhs_expr.LhsName name:dashless spids:[430])
              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: [431 449]
                  )
                }
              spids: [430]
            )
          ]
          spids: [430]
        )
        (command.FuncDef
          name: usage
          body: 
            (command.BraceGroup
              children: [
                (C {(die)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {(eval_gettext)} 
                                {
                                  (DQ ('usage: ') 
                                    (word_part.EscapedLiteralPart
                                      token: <Lit_EscapedChar '\\$'>
                                    ) ('dashless ') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) (USAGE)
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [462 472]
                      )
                    )
                  }
                )
              ]
              spids: [456]
            )
          spids: [452 455]
        )
        (command.If
          arms: [
            (if_arm
              cond: [
                (C {(Lit_Other '[')} {(-z)} {(DQ ($ VSub_DollarName '$LONG_USAGE'))} {(Lit_Other ']')})
              ]
              action: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:LONG_USAGE spids:[496])
                      op: Equal
                      rhs: 
                        {
                          (DQ 
                            (word_part.CommandSubPart
                              command_list: 
                                (command.CommandList
                                  children: [
                                    (C {(eval_gettext)} 
                                      {
                                        (DQ ('usage: ') 
                                          (word_part.EscapedLiteralPart
                                            token: <Lit_EscapedChar '\\$'>
                                          ) ('dashless ') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) (USAGE)
                                        )
                                      }
                                    )
                                  ]
                                )
                              left_token: <Left_CommandSub '$('>
                              spids: [498 508]
                            )
                          )
                        }
                      spids: [496]
                    )
                  ]
                  spids: [496]
                )
              ]
              spids: [16777215 493]
            )
          ]
          else_action: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:LONG_USAGE spids:[515])
                  op: Equal
                  rhs: 
                    {
                      (DQ 
                        (word_part.CommandSubPart
                          command_list: 
                            (command.CommandList
                              children: [
                                (C {(eval_gettext)} 
                                  {
                                    (DQ ('usage: ') 
                                      (word_part.EscapedLiteralPart
                                        token: <Lit_EscapedChar '\\$'>
                                      ) ('dashless ') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\$'>) ('USAGE\n') ('\n') 
                                      ($ VSub_DollarName '$LONG_USAGE')
                                    )
                                  }
                                )
                              ]
                            )
                          left_token: <Left_CommandSub '$('>
                          spids: [517 529]
                        )
                      )
                    }
                  spids: [515]
                )
              ]
              spids: [515]
            )
          ]
          spids: [512 533]
        )
        (command.Case
          to_match: {(DQ ($ VSub_Number '$1'))}
          arms: [
            (case_arm
              pat_list: [{(-h)}]
              action: [
                (C {(echo)} {(DQ ($ VSub_DollarName '$LONG_USAGE'))})
                (command.ControlFlow token:<ControlFlow_Exit exit>)
              ]
              spids: [546 547 16777215 560]
            )
          ]
          spids: [537 543 560]
        )
      ]
      spids: [427 562]
    )
    (command.FuncDef
      name: set_reflog_action
      body: 
        (command.BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (C {(Lit_Other '[')} {(-z)} 
                      {
                        (DQ 
                          (word_part.BracedVarSub
                            token: <VSub_Name GIT_REFLOG_ACTION>
                            suffix_op: (suffix_op.StringUnary op_id:VTest_ColonPlus arg_word:{(set)})
                            spids: [681 685]
                          )
                        )
                      } {(Lit_Other ']')}
                    )
                  ]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:GIT_REFLOG_ACTION spids:[694])
                          op: Equal
                          rhs: {(DQ ($ VSub_Star '$*'))}
                          spids: [694]
                        )
                      ]
                      spids: [694]
                    )
                    (C {(export)} {(GIT_REFLOG_ACTION)})
                  ]
                  spids: [16777215 691]
                )
              ]
              spids: [16777215 705]
            )
          ]
          spids: [671]
        )
      spids: [667 670]
    )
    (command.FuncDef
      name: git_editor
      body: 
        (command.BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (C {(test)} {(-z)} 
                      {
                        (DQ 
                          (word_part.BracedVarSub
                            token: <VSub_Name GIT_EDITOR>
                            suffix_op: (suffix_op.StringUnary op_id:VTest_ColonPlus arg_word:{(set)})
                            spids: [724 728]
                          )
                        )
                      }
                    )
                  ]
                  action: [
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:GIT_EDITOR spids:[735])
                              op: Equal
                              rhs: 
                                {
                                  (DQ 
                                    (word_part.CommandSubPart
                                      command_list: 
                                        (command.CommandList
                                          children: [(C {(git)} {(var)} {(GIT_EDITOR)})]
                                        )
                                      left_token: <Left_CommandSub '$('>
                                      spids: [737 743]
                                    )
                                  )
                                }
                              spids: [735]
                            )
                          ]
                          spids: [735]
                        )
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {($ VSub_QMark '$?')}
                        )
                      ]
                    )
                  ]
                  spids: [16777215 732]
                )
              ]
              spids: [16777215 753]
            )
            (C {(eval)} {(DQ ($ VSub_DollarName '$GIT_EDITOR'))} {(SQ <'"$@"'>)})
          ]
          spids: [714]
        )
      spids: [710 713]
    )
    (command.FuncDef
      name: git_pager
      body: 
        (command.BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-t)} {(1)})]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:GIT_PAGER spids:[789])
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [(C {(git)} {(var)} {(GIT_PAGER)})]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [790 796]
                              )
                            }
                          spids: [789]
                        )
                      ]
                      spids: [789]
                    )
                  ]
                  spids: [16777215 786]
                )
              ]
              else_action: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:GIT_PAGER spids:[802])
                      op: Equal
                      rhs: {(cat)}
                      spids: [802]
                    )
                  ]
                  spids: [802]
                )
              ]
              spids: [799 806]
            )
            (command.ForEach
              iter_name: vardef
              iter_words: [
                {(Lit_Other '@') (Lit_Other '@') (PAGER_ENV) (Lit_Other '@') (Lit_Other '@')}
              ]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:var spids:[825])
                          op: Equal
                          rhs: 
                            {
                              (word_part.BracedVarSub
                                token: <VSub_Name vardef>
                                suffix_op: 
                                  (suffix_op.StringUnary
                                    op_id: VOp1_DPercent
                                    arg_word: {('=*')}
                                  )
                                spids: [826 830]
                              )
                            }
                          spids: [825]
                        )
                      ]
                      spids: [825]
                    )
                    (C {(eval)} 
                      {
                        (DQ (': ') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\"'>) 
                          (word_part.EscapedLiteralPart
                            token: <Lit_EscapedChar '\\$'>
                          ) ('{') ($ VSub_DollarName '$vardef') ('}') (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\"'>) 
                          (' && export ') ($ VSub_DollarName '$var')
                        )
                      }
                    )
                  ]
                  spids: [822 848]
                )
              spids: [814 16777215]
            )
            (C {(eval)} {(DQ ($ VSub_DollarName '$GIT_PAGER'))} {(SQ <'"$@"'>)})
          ]
          spids: [774]
        )
      spids: [770 773]
    )
    (command.FuncDef
      name: sane_grep
      body: 
        (command.BraceGroup
          children: [
            (command.SimpleCommand
              words: [
                {(grep)}
                {(Lit_Other '@') (Lit_Other '@') (SANE_TEXT_GREP) (Lit_Other '@') (Lit_Other '@')}
                {(DQ ($ VSub_At '$@'))}
              ]
              more_env: [
                (env_pair name:GREP_OPTIONS val:(word.EmptyWord) spids:[873])
                (env_pair name:LC_ALL val:{(C)} spids:[875])
              ]
            )
          ]
          spids: [870]
        )
      spids: [865 869]
    )
    (command.FuncDef
      name: sane_egrep
      body: 
        (command.BraceGroup
          children: [
            (command.SimpleCommand
              words: [
                {(egrep)}
                {(Lit_Other '@') (Lit_Other '@') (SANE_TEXT_GREP) (Lit_Other '@') (Lit_Other '@')}
                {(DQ ($ VSub_At '$@'))}
              ]
              more_env: [
                (env_pair name:GREP_OPTIONS val:(word.EmptyWord) spids:[901])
                (env_pair name:LC_ALL val:{(C)} spids:[903])
              ]
            )
          ]
          spids: [898]
        )
      spids: [893 897]
    )
    (command.FuncDef
      name: is_bare_repository
      body: 
        (command.BraceGroup
          children: [(C {(git)} {(rev-parse)} {(--is-bare-repository)})]
          spids: [926]
        )
      spids: [921 925]
    )
    (command.FuncDef
      name: cd_to_toplevel
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DAmp Op_DPipe]
              children: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:cdup spids:[946])
                      op: Equal
                      rhs: 
                        {
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [(C {(git)} {(rev-parse)} {(--show-toplevel)})]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [947 953]
                          )
                        }
                      spids: [946]
                    )
                  ]
                  spids: [946]
                )
                (C {(cd)} {(DQ ($ VSub_DollarName '$cdup'))})
                (command.BraceGroup
                  children: [
                    (command.SimpleCommand
                      words: [
                        {(gettextln)}
                        {
                          (DQ ('Cannot chdir to ') 
                            (word_part.EscapedLiteralPart
                              token: <Lit_EscapedChar '\\$'>
                            ) ('cdup, the toplevel of the working tree')
                          )
                        }
                      ]
                      redirects: [(redir.Redir op:<Redir_GreatAnd '>&'> fd:16777215 arg_word:{(2)})]
                    )
                    (command.ControlFlow
                      token: <ControlFlow_Exit exit>
                      arg_word: {(1)}
                    )
                  ]
                  spids: [966]
                )
              ]
            )
          ]
          spids: [943]
        )
      spids: [938 942]
    )
    (command.FuncDef
      name: require_work_tree_exists
      body: 
        (command.BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (C {(test)} 
                      {
                        (DQ (z) 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [(C {(git)} {(rev-parse)} {(--is-bare-repository)})]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [1005 1011]
                          )
                        )
                      } {(KW_Bang '!') (Lit_Other '=')} {(zfalse)}
                    )
                  ]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:program_name spids:[1023])
                          op: Equal
                          rhs: {($ VSub_Number '$0')}
                          spids: [1023]
                        )
                      ]
                      spids: [1023]
                    )
                    (C {(die)} 
                      {
                        (DQ 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(gettext)} 
                                    {
                                      (DQ ('fatal: ') 
                                        (word_part.EscapedLiteralPart
                                          token: <Lit_EscapedChar '\\$'>
                                        ) ('program_name cannot be used without a working tree.')
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [1030 1038]
                          )
                        )
                      }
                    )
                  ]
                  spids: [16777215 1020]
                )
              ]
              spids: [16777215 1042]
            )
          ]
          spids: [996]
        )
      spids: [991 995]
    )
    (command.FuncDef
      name: require_work_tree
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(test)} 
                  {
                    (DQ 
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [
                              (command.SimpleCommand
                                words: [{(git)} {(rev-parse)} {(--is-inside-work-tree)}]
                                redirects: [
                                  (redir.Redir
                                    op: <Redir_Great '2>'>
                                    fd: 2
                                    arg_word: {(/dev/null)}
                                  )
                                ]
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [1058 1067]
                      )
                    )
                  } {(Lit_Other '=')} {(true)}
                )
                (command.BraceGroup
                  children: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:program_name spids:[1079])
                          op: Equal
                          rhs: {($ VSub_Number '$0')}
                          spids: [1079]
                        )
                      ]
                      spids: [1079]
                    )
                    (C {(die)} 
                      {
                        (DQ 
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(gettext)} 
                                    {
                                      (DQ ('fatal: ') 
                                        (word_part.EscapedLiteralPart
                                          token: <Lit_EscapedChar '\\$'>
                                        ) ('program_name cannot be used without a working tree.')
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [1086 1094]
                          )
                        )
                      }
                    )
                  ]
                  spids: [1076]
                )
              ]
            )
          ]
          spids: [1052]
        )
      spids: [1047 1051]
    )
    (command.FuncDef
      name: require_clean_work_tree
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (command.SimpleCommand
                  words: [{(git)} {(rev-parse)} {(--verify)} {(HEAD)}]
                  redirects: [(redir.Redir op:<Redir_Great '>'> fd:16777215 arg_word:{(/dev/null)})]
                )
                (command.ControlFlow token:<ControlFlow_Exit exit> arg_word:{(1)})
              ]
            )
            (C {(git)} {(update-index)} {(-q)} {(--ignore-submodules)} {(--refresh)})
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:err spids:[1140])
                  op: Equal
                  rhs: {(0)}
                  spids: [1140]
                )
              ]
              spids: [1140]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Pipeline
                      children: [(C {(git)} {(diff-files)} {(--quiet)} {(--ignore-submodules)})]
                      negated: T
                    )
                  ]
                  action: [
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:action spids:[1161])
                          op: Equal
                          rhs: {($ VSub_Number '$1')}
                          spids: [1161]
                        )
                      ]
                      spids: [1161]
                    )
                    (command.Case
                      to_match: {(DQ ($ VSub_DollarName '$action'))}
                      arms: [
                        (case_arm
                          pat_list: [{(rebase)}]
                          action: [
                            (command.SimpleCommand
                              words: [{(gettextln)} {(DQ ('Cannot rebase: You have unstaged changes.'))}]
                              redirects: [
                                (redir.Redir
                                  op: <Redir_GreatAnd '>&'>
                                  fd: 16777215
                                  arg_word: {(2)}
                                )
                              ]
                            )
                          ]
                          spids: [1174 1175 1188 16777215]
                        )
                        (case_arm
                          pat_list: [{(DQ ('rewrite branches'))}]
                          action: [
                            (command.SimpleCommand
                              words: [
                                {(gettextln)}
                                {(DQ ('Cannot rewrite branches: You have unstaged changes.'))}
                              ]
                              redirects: [
                                (redir.Redir
                                  op: <Redir_GreatAnd '>&'>
                                  fd: 16777215
                                  arg_word: {(2)}
                                )
                              ]
                            )
                          ]
                          spids: [1191 1194 1207 16777215]
                        )
                        (case_arm
                          pat_list: [{(DQ ('pull with rebase'))}]
                          action: [
                            (command.SimpleCommand
                              words: [
                                {(gettextln)}
                                {(DQ ('Cannot pull with rebase: You have unstaged changes.'))}
                              ]
                              redirects: [
                                (redir.Redir
                                  op: <Redir_GreatAnd '>&'>
                                  fd: 16777215
                                  arg_word: {(2)}
                                )
                              ]
                            )
                          ]
                          spids: [1210 1213 1226 16777215]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other '*')}]
                          action: [
                            (command.SimpleCommand
                              words: [
                                {(eval_gettextln)}
                                {
                                  (DQ ('Cannot ') 
                                    (word_part.EscapedLiteralPart
                                      token: <Lit_EscapedChar '\\$'>
                                    ) ('action: You have unstaged changes.')
                                  )
                                }
                              ]
                              redirects: [
                                (redir.Redir
                                  op: <Redir_GreatAnd '>&'>
                                  fd: 16777215
                                  arg_word: {(2)}
                                )
                              ]
                            )
                          ]
                          spids: [1229 1230 1245 16777215]
                        )
                      ]
                      spids: [1165 1171 1248]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:err spids:[1251])
                          op: Equal
                          rhs: {(1)}
                          spids: [1251]
                        )
                      ]
                      spids: [1251]
                    )
                  ]
                  spids: [16777215 1158]
                )
              ]
              spids: [16777215 1255]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Pipeline
                      children: [
                        (C {(git)} {(diff-index)} {(--cached)} {(--quiet)} {(--ignore-submodules)} {(HEAD)} 
                          {(--)}
                        )
                      ]
                      negated: T
                    )
                  ]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [(C {(test)} {($ VSub_DollarName '$err')} {(Lit_Other '=')} {(0)})]
                          action: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:action spids:[1295])
                                  op: Equal
                                  rhs: {($ VSub_Number '$1')}
                                  spids: [1295]
                                )
                              ]
                              spids: [1295]
                            )
                            (command.Case
                              to_match: {(DQ ($ VSub_DollarName '$action'))}
                              arms: [
                                (case_arm
                                  pat_list: [{(rebase)}]
                                  action: [
                                    (command.SimpleCommand
                                      words: [
                                        {(gettextln)}
                                        {
                                          (DQ 
                                            (
'Cannot rebase: Your index contains uncommitted changes.'
                                            )
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (redir.Redir
                                          op: <Redir_GreatAnd '>&'>
                                          fd: 16777215
                                          arg_word: {(2)}
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [1308 1309 1322 16777215]
                                )
                                (case_arm
                                  pat_list: [{(DQ ('pull with rebase'))}]
                                  action: [
                                    (command.SimpleCommand
                                      words: [
                                        {(gettextln)}
                                        {
                                          (DQ 
                                            (
'Cannot pull with rebase: Your index contains uncommitted changes.'
                                            )
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (redir.Redir
                                          op: <Redir_GreatAnd '>&'>
                                          fd: 16777215
                                          arg_word: {(2)}
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [1325 1328 1341 16777215]
                                )
                                (case_arm
                                  pat_list: [{(Lit_Other '*')}]
                                  action: [
                                    (command.SimpleCommand
                                      words: [
                                        {(eval_gettextln)}
                                        {
                                          (DQ ('Cannot ') 
                                            (word_part.EscapedLiteralPart
                                              token: <Lit_EscapedChar '\\$'>
                                            ) ('action: Your index contains uncommitted changes.')
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (redir.Redir
                                          op: <Redir_GreatAnd '>&'>
                                          fd: 16777215
                                          arg_word: {(2)}
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [1344 1345 1360 16777215]
                                )
                              ]
                              spids: [1299 1305 1363]
                            )
                          ]
                          spids: [16777215 1292]
                        )
                      ]
                      else_action: [
                        (command.SimpleCommand
                          words: [
                            {(gettextln)}
                            {(DQ ('Additionally, your index contains uncommitted changes.'))}
                          ]
                          redirects: [(redir.Redir op:<Redir_GreatAnd '>&'> fd:16777215 arg_word:{(2)})]
                        )
                      ]
                      spids: [1366 1379]
                    )
                    (command.Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:err spids:[1382])
                          op: Equal
                          rhs: {(1)}
                          spids: [1382]
                        )
                      ]
                      spids: [1382]
                    )
                  ]
                  spids: [16777215 1278]
                )
              ]
              spids: [16777215 1386]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {($ VSub_DollarName '$err')} {(Lit_Other '=')} {(1)})]
                  action: [
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(-n)} {(DQ ($ VSub_Number '$2'))})
                        (command.SimpleCommand
                          words: [{(echo)} {(DQ ($ VSub_Number '$2'))}]
                          redirects: [(redir.Redir op:<Redir_GreatAnd '>&'> fd:16777215 arg_word:{(2)})]
                        )
                      ]
                    )
                    (command.ControlFlow
                      token: <ControlFlow_Exit exit>
                      arg_word: {(1)}
                    )
                  ]
                  spids: [16777215 1401]
                )
              ]
              spids: [16777215 1429]
            )
          ]
          spids: [1108]
        )
      spids: [1103 1107]
    )
    (command.FuncDef
      name: pick_ident_script
      body: 
        (command.BraceGroup
          children: [
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [(C {(test)} {($ VSub_Pound '$#')} {(-gt)} {(0)})]
              body: 
                (command.DoGroup
                  children: [
                    (command.Sentence
                      child: 
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:lid spids:[1483])
                              op: Equal
                              rhs: {($ VSub_Number '$1')}
                              spids: [1483]
                            )
                          ]
                          spids: [1483]
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (C {(shift)})
                    (command.Sentence
                      child: 
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:uid spids:[1490])
                              op: Equal
                              rhs: {($ VSub_Number '$1')}
                              spids: [1490]
                            )
                          ]
                          spids: [1490]
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (C {(shift)})
                    (C {(printf)} {(SQ <'%s'>)} 
                      {
                        (DQ ('\n') ('\t\t/^') ($ VSub_DollarName '$lid') (' /{\n') ("\t\t\ts/'/'") 
                          (word_part.EscapedLiteralPart
                            token: <Lit_EscapedChar '\\\\'>
                          ) (word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\\\'>) ("''/g\n") ('\t\t\th\n') ('\t\t\ts/^') 
                          ($ VSub_DollarName '$lid') (' ')
                        ) (SQ <'\\([^<]*\\) <[^>]*> .*$/\\1/'>) 
                        (DQ ('\n') ('\t\t\ts/.*/GIT_') (${ VSub_Name uid) ("_NAME='&'/p\n") ('\n') 
                          ('\t\t\tg\n') ('\t\t\ts/^') ($ VSub_DollarName '$lid') (' ')
                        ) (SQ <'[^<]* <\\([^>]*\\)> .*$/\\1/'>) 
                        (DQ ('\n') ('\t\t\ts/.*/GIT_') (${ VSub_Name uid) ("_EMAIL='&'/p\n") ('\n') 
                          ('\t\t\tg\n') ('\t\t\ts/^') ($ VSub_DollarName '$lid') (' ')
                        ) (SQ <'[^<]* <[^>]*> \\(.*\\)$/@\\1/'>) 
                        (DQ ('\n') ('\t\t\ts/.*/GIT_') (${ VSub_Name uid) ("_DATE='&'/p\n") ('\t\t}\n') 
                          ('\t\t')
                        )
                      }
                    )
                  ]
                  spids: [1480 1564]
                )
            )
            (C {(echo)} {(SQ <'/^$/q'>)})
          ]
          spids: [1466]
        )
      spids: [1461 1465]
    )
    (command.FuncDef
      name: parse_ident_from_commit
      body: 
        (command.BraceGroup
          children: [
            (command.SimpleCommand
              words: [
                {(sed)}
                {(-ne)}
                {
                  (DQ 
                    (word_part.CommandSubPart
                      command_list: 
                        (command.CommandList
                          children: [(C {(pick_ident_script)} {(DQ ($ VSub_At '$@'))})]
                        )
                      left_token: <Left_CommandSub '$('>
                      spids: [1601 1607]
                    )
                  )
                }
              ]
              more_env: [
                (env_pair name:LANG val:{(C)} spids:[1590])
                (env_pair name:LC_ALL val:{(C)} spids:[1593])
              ]
            )
          ]
          spids: [1587]
        )
      spids: [1582 1586]
    )
    (command.FuncDef
      name: get_author_ident_from_commit
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:encoding spids:[1627])
                  op: Equal
                  rhs: 
                    {
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [
                              (command.AndOr
                                ops: [Op_DPipe]
                                children: [
                                  (C {(git)} {(config)} {(i18n.commitencoding)})
                                  (C {(echo)} {(UTF-8)})
                                ]
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [1628 1640]
                      )
                    }
                  spids: [1627]
                )
              ]
              spids: [1627]
            )
            (command.Pipeline
              children: [
                (C {(git)} {(show)} {(-s)} {(--pretty) (Lit_Other '=') (raw)} 
                  {(--encoding) (Lit_Other '=') (DQ ($ VSub_DollarName '$encoding'))} {(DQ ($ VSub_Number '$1'))} {(--)}
                )
                (C {(parse_ident_from_commit)} {(author)} {(AUTHOR)})
              ]
              negated: F
            )
          ]
          spids: [1624]
        )
      spids: [1619 1623]
    )
    (command.FuncDef
      name: clear_local_git_env
      body: 
        (command.BraceGroup
          children: [
            (C {(unset)} 
              {
                (word_part.CommandSubPart
                  command_list: 
                    (command.CommandList
                      children: [(C {(git)} {(rev-parse)} {(--local-env-vars)})]
                    )
                  left_token: <Left_CommandSub '$('>
                  spids: [1695 1701]
                )
              }
            )
          ]
          spids: [1690]
        )
      spids: [1686 1689]
    )
    (command.FuncDef
      name: create_virtual_base
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:sz0 spids:[1719])
                  op: Equal
                  rhs: 
                    {
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [
                              (command.SimpleCommand
                                words: [{(wc)} {(-c)}]
                                redirects: [
                                  (redir.Redir
                                    op: <Redir_Less '<'>
                                    fd: 16777215
                                    arg_word: {(DQ ($ VSub_Number '$1'))}
                                  )
                                ]
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [1720 1729]
                      )
                    }
                  spids: [1719]
                )
              ]
              spids: [1719]
            )
            (command.Pipeline
              children: [
                (C {(Lit_Other '@') (Lit_Other '@') (DIFF) (Lit_Other '@') (Lit_Other '@')} {(-u)} 
                  {(-La/) (DQ ($ VSub_Number '$1'))} {(-Lb/) (DQ ($ VSub_Number '$1'))} {(DQ ($ VSub_Number '$1'))} {(DQ ($ VSub_Number '$2'))}
                )
                (C {(git)} {(apply)} {(--no-add)})
              ]
              negated: F
            )
            (command.Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:sz1 spids:[1767])
                  op: Equal
                  rhs: 
                    {
                      (word_part.CommandSubPart
                        command_list: 
                          (command.CommandList
                            children: [
                              (command.SimpleCommand
                                words: [{(wc)} {(-c)}]
                                redirects: [
                                  (redir.Redir
                                    op: <Redir_Less '<'>
                                    fd: 16777215
                                    arg_word: {(DQ ($ VSub_Number '$1'))}
                                  )
                                ]
                              )
                            ]
                          )
                        left_token: <Left_CommandSub '$('>
                        spids: [1768 1777]
                      )
                    }
                  spids: [1767]
                )
              ]
              spids: [1767]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (command.SimpleCommand
                  words: [
                    {(expr)}
                    {($ VSub_DollarName '$sz0')}
                    {(word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\<'>)}
                    {($ VSub_DollarName '$sz1')}
                    {(word_part.EscapedLiteralPart token:<Lit_EscapedChar '\\*'>)}
                    {(2)}
                  ]
                  redirects: [(redir.Redir op:<Redir_Great '>'> fd:16777215 arg_word:{(/dev/null)})]
                )
                (command.SimpleCommand
                  words: [{(Lit_Other ':')}]
                  redirects: [
                    (redir.Redir
                      op: <Redir_Great '>'>
                      fd: 16777215
                      arg_word: {(DQ ($ VSub_Number '$1'))}
                    )
                  ]
                )
              ]
            )
          ]
          spids: [1716]
        )
      spids: [1712 1715]
    )
    (command.Case
      to_match: 
        {
          (word_part.CommandSubPart
            command_list: (command.CommandList children:[(C {(uname)} {(-s)})])
            left_token: <Left_CommandSub '$('>
            spids: [1822 1826]
          )
        }
      arms: [
        (case_arm
          pat_list: [{(Lit_Other '*') (MINGW) (Lit_Other '*')}]
          action: [
            (command.FuncDef
              name: sort
              body: 
                (command.BraceGroup
                  children: [(C {(/usr/bin/sort)} {(DQ ($ VSub_At '$@'))})]
                  spids: [1845]
                )
              spids: [1840 1844]
            )
            (command.FuncDef
              name: find
              body: 
                (command.BraceGroup
                  children: [(C {(/usr/bin/find)} {(DQ ($ VSub_At '$@'))})]
                  spids: [1863]
                )
              spids: [1858 1862]
            )
            (command.FuncDef
              name: pwd
              body: (command.BraceGroup children:[(C {(builtin)} {(pwd)} {(-W)})] spids:[1885])
              spids: [1880 1884]
            )
            (command.FuncDef
              name: is_absolute_path
              body: 
                (command.BraceGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ VSub_Number '$1'))}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(Lit_Other '[') (/) 
                              (word_part.EscapedLiteralPart
                                token: <Lit_EscapedChar '\\\\'>
                              ) (Lit_Other ']') (Lit_Other '*')
                            }
                            {(Lit_Other '[') (A-Za-z) (Lit_Other ']') (Lit_Other ':') (Lit_Other '*')}
                          ]
                          action: [
                            (command.ControlFlow
                              token: <ControlFlow_Return return>
                              arg_word: {(0)}
                            )
                          ]
                          spids: [1915 1928 1935 16777215]
                        )
                      ]
                      spids: [1906 1912 1938]
                    )
                    (command.ControlFlow
                      token: <ControlFlow_Return return>
                      arg_word: {(1)}
                    )
                  ]
                  spids: [1903]
                )
              spids: [1898 1902]
            )
          ]
          spids: [1830 1833 1949 16777215]
        )
        (case_arm
          pat_list: [{(Lit_Other '*')}]
          action: [
            (command.FuncDef
              name: is_absolute_path
              body: 
                (command.BraceGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ VSub_Number '$1'))}
                      arms: [
                        (case_arm
                          pat_list: [{(/) (Lit_Other '*')}]
                          action: [
                            (command.ControlFlow
                              token: <ControlFlow_Return return>
                              arg_word: {(0)}
                            )
                          ]
                          spids: [1972 1974 1981 16777215]
                        )
                      ]
                      spids: [1963 1969 1984]
                    )
                    (command.ControlFlow
                      token: <ControlFlow_Return return>
                      arg_word: {(1)}
                    )
                  ]
                  spids: [1960]
                )
              spids: [1955 1959]
            )
          ]
          spids: [1951 1952 16777215 1994]
        )
      ]
      spids: [1820 1828 1994]
    )
    (command.FuncDef
      name: git_dir_init
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:GIT_DIR spids:[2011])
                      op: Equal
                      rhs: 
                        {
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [(C {(git)} {(rev-parse)} {(--git-dir)})]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [2012 2018]
                          )
                        }
                      spids: [2011]
                    )
                  ]
                  spids: [2011]
                )
                (command.ControlFlow token:<ControlFlow_Exit exit>)
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (C {(Lit_Other '[')} {(-z)} {(DQ ($ VSub_DollarName '$SUBDIRECTORY_OK'))} 
                      {(Lit_Other ']')}
                    )
                  ]
                  action: [
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(test)} {(-z)} 
                          {
                            (DQ 
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [(C {(git)} {(rev-parse)} {(--show-cdup)})]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [2046 2052]
                              )
                            )
                          }
                        )
                        (command.BraceGroup
                          children: [
                            (command.Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:exit spids:[2060])
                                  op: Equal
                                  rhs: {($ VSub_QMark '$?')}
                                  spids: [2060]
                                )
                              ]
                              spids: [2060]
                            )
                            (command.SimpleCommand
                              words: [
                                {(gettextln)}
                                {
                                  (DQ 
                                    (
'You need to run this command from the toplevel of the working tree.'
                                    )
                                  )
                                }
                              ]
                              redirects: [
                                (redir.Redir
                                  op: <Redir_GreatAnd '>&'>
                                  fd: 16777215
                                  arg_word: {(2)}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Exit exit>
                              arg_word: {($ VSub_DollarName '$exit')}
                            )
                          ]
                          spids: [2057]
                        )
                      ]
                    )
                  ]
                  spids: [16777215 2038]
                )
              ]
              spids: [16777215 2082]
            )
            (command.AndOr
              ops: [Op_DAmp Op_DPipe]
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$GIT_DIR'))})
                (command.Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:GIT_DIR spids:[2095])
                      op: Equal
                      rhs: 
                        {
                          (word_part.CommandSubPart
                            command_list: 
                              (command.CommandList
                                children: [
                                  (command.AndOr
                                    ops: [Op_DAmp]
                                    children: [
                                      (C {(cd)} {(DQ ($ VSub_DollarName '$GIT_DIR'))})
                                      (C {(pwd)})
                                    ]
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub '$('>
                            spids: [2096 2106]
                          )
                        }
                      spids: [2095]
                    )
                  ]
                  spids: [2095]
                )
                (command.BraceGroup
                  children: [
                    (command.SimpleCommand
                      words: [
                        {(gettextln)}
                        {(DQ ('Unable to determine absolute path of git directory'))}
                      ]
                      redirects: [(redir.Redir op:<Redir_GreatAnd '>&'> fd:16777215 arg_word:{(2)})]
                    )
                    (command.ControlFlow
                      token: <ControlFlow_Exit exit>
                      arg_word: {(1)}
                    )
                  ]
                  spids: [2110]
                )
              ]
            )
            (C {(Lit_Other ':')} 
              {
                (DQ 
                  (word_part.BracedVarSub
                    token: <VSub_Name GIT_OBJECT_DIRECTORY>
                    suffix_op: 
                      (suffix_op.StringUnary
                        op_id: VTest_Equals
                        arg_word: 
                          {
                            (DQ 
                              (word_part.CommandSubPart
                                command_list: 
                                  (command.CommandList
                                    children: [(C {(git)} {(rev-parse)} {(--git-path)} {(objects)})]
                                  )
                                left_token: <Left_CommandSub '$('>
                                spids: [2138 2146]
                              )
                            )
                          }
                      )
                    spids: [2134 2148]
                  )
                )
              }
            )
          ]
          spids: [2008]
        )
      spids: [2003 2007]
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$NONGIT_OK'))})]
          action: [(C {(git_dir_init)})]
          spids: [16777215 2164]
        )
      ]
      spids: [16777215 2169]
    )
    (command.FuncDef
      name: peel_committish
      body: 
        (command.BraceGroup
          children: [
            (command.Case
              to_match: {(DQ ($ VSub_Number '$1'))}
              arms: [
                (case_arm
                  pat_list: [{(Lit_Other ':') (/) (Lit_Other '*')}]
                  action: [
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (command.Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:peeltmp spids:[2195])
                              op: Equal
                              rhs: 
                                {
                                  (word_part.CommandSubPart
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(git)} {(rev-parse)} {(--verify)} 
                                            {(DQ ($ VSub_Number '$1'))}
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub '$('>
                                    spids: [2196 2206]
                                  )
                                }
                              spids: [2195]
                            )
                          ]
                          spids: [2195]
                        )
                        (C {(git)} {(rev-parse)} {(--verify)} {(DQ (${ VSub_Name peeltmp) ('^0'))})
                      ]
                    )
                  ]
                  spids: [2189 2192 2225 16777215]
                )
                (case_arm
                  pat_list: [{(Lit_Other '*')}]
                  action: [(C {(git)} {(rev-parse)} {(--verify)} {(DQ (${ VSub_Number 1) ('^0'))})]
                  spids: [2228 2229 2246 16777215]
                )
              ]
              spids: [2180 2186 2249]
            )
          ]
          spids: [2177]
        )
      spids: [2172 2176]
    )
  ]
)