(command.CommandList
  children: [
    (C {<.>} {<git-sh-i18n>})
    (C {<unset>} {<CDPATH>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:IFS)
          op: assign_op.Equal
          rhs: {(SQ <' \t\n'>)}
          spids: [47]
        )
      ]
    )
    (command.ShFunction
      name: git_broken_path_fix
      body: 
        (BraceGroup
          children: [
            (command.Case
              to_match: {(DQ <':'> ($ Id.VSub_DollarName '$PATH') <':'>)}
              arms: [
                (case_arm
                  pat_list: [
                    {<Id.Lit_Star '*'> <Id.Lit_Colon ':'> ($ Id.VSub_Number '$1') <Id.Lit_Colon ':'> 
                      <Id.Lit_Star '*'>
                    }
                  ]
                  action: [(C {<Id.Lit_Colon ':'>} {<ok>})]
                  spids: [72 77 83 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:PATH)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (command.CommandList
                                    children: [
                                      (command.ShAssignment
                                        pairs: [
                                          (assign_pair
                                            lhs: (sh_lhs_expr.Name name:SANE_TOOL_PATH)
                                            op: assign_op.Equal
                                            rhs: {(DQ ($ Id.VSub_Number '$1'))}
                                            spids: [94]
                                          )
                                        ]
                                      )
                                      (command.ShAssignment
                                        pairs: [
                                          (assign_pair
                                            lhs: (sh_lhs_expr.Name name:IFS)
                                            op: assign_op.Equal
                                            rhs: {<Id.Lit_Colon ':'>}
                                            spids: [100]
                                          )
                                          (assign_pair
                                            lhs: (sh_lhs_expr.Name name:path)
                                            op: assign_op.Equal
                                            rhs: (word.Empty)
                                            spids: [103]
                                          )
                                          (assign_pair
                                            lhs: (sh_lhs_expr.Name name:sep)
                                            op: assign_op.Equal
                                            rhs: (word.Empty)
                                            spids: [105]
                                          )
                                        ]
                                      )
                                      (C {<set>} {<x>} {($ Id.VSub_DollarName '$PATH')})
                                      (C {<shift>})
                                      (command.ForEach
                                        iter_name: elem
                                        do_arg_iter: T
                                        body: 
                                          (command.DoGroup
                                            children: [
                                              (command.Case
                                                to_match: 
                                                  {
                                                    (DQ ($ Id.VSub_DollarName '$SANE_TOOL_PATH') <':'> 
                                                      ($ Id.VSub_DollarName '$elem')
                                                    )
                                                  }
                                                arms: [
                                                  (case_arm
                                                    pat_list: [
                                                      {<Id.Lit_QMark '?'> <Id.Lit_Star '*'> 
                                                        <Id.Lit_Colon ':'> <'/bin'>
                                                      }
                                                      {<Id.Lit_QMark '?'> <Id.Lit_Star '*'> 
                                                        <Id.Lit_Colon ':'> <'/usr/bin'>
                                                      }
                                                    ]
                                                    action: [
                                                      (command.ShAssignment
                                                        pairs: [
                                                          (assign_pair
                                                            lhs: (sh_lhs_expr.Name name:path)
                                                            op: assign_op.Equal
                                                            rhs: 
                                                              {
                                                                (DQ ($ Id.VSub_DollarName '$path') 
                                                                  ($ Id.VSub_DollarName '$sep') ($ Id.VSub_DollarName '$SANE_TOOL_PATH')
                                                                )
                                                              }
                                                            spids: [152]
                                                          )
                                                        ]
                                                      )
                                                      (command.ShAssignment
                                                        pairs: [
                                                          (assign_pair
                                                            lhs: (sh_lhs_expr.Name name:sep)
                                                            op: assign_op.Equal
                                                            rhs: {<Id.Lit_Colon ':'>}
                                                            spids: [160]
                                                          )
                                                        ]
                                                      )
                                                      (command.ShAssignment
                                                        pairs: [
                                                          (assign_pair
                                                            lhs: 
                                                              (sh_lhs_expr.Name
                                                                name: SANE_TOOL_PATH
                                                              )
                                                            op: assign_op.Equal
                                                            rhs: (word.Empty)
                                                            spids: [164]
                                                          )
                                                        ]
                                                      )
                                                    ]
                                                    spids: [137 149 -1 167]
                                                  )
                                                ]
                                              )
                                              (command.ShAssignment
                                                pairs: [
                                                  (assign_pair
                                                    lhs: (sh_lhs_expr.Name name:path)
                                                    op: assign_op.Equal
                                                    rhs: 
                                                      {
                                                        (DQ ($ Id.VSub_DollarName '$path') 
                                                          ($ Id.VSub_DollarName '$sep') ($ Id.VSub_DollarName '$elem')
                                                        )
                                                      }
                                                    spids: [170]
                                                  )
                                                ]
                                              )
                                              (command.ShAssignment
                                                pairs: [
                                                  (assign_pair
                                                    lhs: (sh_lhs_expr.Name name:sep)
                                                    op: assign_op.Equal
                                                    rhs: {<Id.Lit_Colon ':'>}
                                                    spids: [178]
                                                  )
                                                ]
                                              )
                                            ]
                                          )
                                      )
                                      (C {<echo>} {(DQ ($ Id.VSub_DollarName '$path'))})
                                    ]
                                  )
                              )
                            }
                          spids: [90]
                        )
                      ]
                    )
                  ]
                  spids: [86 87 195 -1]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: die
      body: (BraceGroup children:[(C {<die_with_status>} {<1>} {(DQ ($ Id.VSub_At '$@'))})])
    )
    (command.ShFunction
      name: die_with_status
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:status)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$1')}
                  spids: [234]
                )
              ]
            )
            (C {<shift>})
            (command.Simple
              words: [{<printf>} {(SQ <'%s\\n'>)} {(DQ ($ Id.VSub_Star '$*'))}]
              redirects: [(redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
              do_fork: T
            )
            (command.ControlFlow
              token: <Id.ControlFlow_Exit exit>
              arg_word: {(DQ ($ Id.VSub_DollarName '$status'))}
            )
          ]
        )
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:GIT_QUIET)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [264]
        )
      ]
    )
    (command.ShFunction
      name: say
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [(C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$GIT_QUIET'))})]
                    )
                  action: [(C {<printf>} {(SQ <'%s\\n'>)} {(DQ ($ Id.VSub_Star '$*'))})]
                  spids: [275 286]
                )
              ]
            )
          ]
        )
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.Sentence
                  child: (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$OPTIONS_SPEC'))})
                  terminator: <Id.Op_Semi _>
                )
              ]
            )
          action: [
            (command.ShFunction
              name: usage
              body: 
                (BraceGroup
                  children: [
                    (C {(DQ ($ Id.VSub_Number '$0'))} {<-h>})
                    (command.ControlFlow
                      token: <Id.ControlFlow_Exit exit>
                      arg_word: {<1>}
                    )
                  ]
                )
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:parseopt_extra)
                  op: assign_op.Equal
                  rhs: (word.Empty)
                  spids: [342]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {<-n>} {(DQ ($ Id.VSub_DollarName '$OPTIONS_KEEPDASHDASH'))} 
                  {<Id.Lit_RBracket ']'>}
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:parseopt_extra)
                      op: assign_op.Equal
                      rhs: {(DQ <--keep-dashdash>)}
                      spids: [358]
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<Id.Lit_LBracket '['>} {<-n>} {(DQ ($ Id.VSub_DollarName '$OPTIONS_STUCKLONG'))} 
                  {<Id.Lit_RBracket ']'>}
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:parseopt_extra)
                      op: assign_op.Equal
                      rhs: {(DQ ($ Id.VSub_DollarName '$parseopt_extra') <' --stuck-long'>)}
                      spids: [377]
                    )
                  ]
                )
              ]
            )
            (C {<eval>} 
              {
                (DQ 
                  (command_sub
                    left_token: <Id.Left_DollarParen '$('>
                    child: 
                      (command.AndOr
                        ops: [Id.Op_DPipe]
                        children: [
                          (command.Pipeline
                            children: [
                              (C {<echo>} {(DQ ($ Id.VSub_DollarName '$OPTIONS_SPEC'))})
                              (C {<git>} {<rev-parse>} {<--parseopt>} 
                                {($ Id.VSub_DollarName '$parseopt_extra')} {<-->} {(DQ ($ Id.VSub_At '$@'))}
                              )
                            ]
                            negated: F
                          )
                          (C {<echo>} {<Id.ControlFlow_Exit exit>} {($ Id.VSub_QMark '$?')})
                        ]
                      )
                  )
                )
              }
            )
          ]
          spids: [305 316]
        )
      ]
      else_action: [
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name name:dashless)
              op: assign_op.Equal
              rhs: 
                {
                  (command_sub
                    left_token: <Id.Left_DollarParen '$('>
                    child: 
                      (command.Pipeline
                        children: [
                          (C {<basename>} {<-->} {(DQ ($ Id.VSub_Number '$0'))})
                          (C {<sed>} {<-e>} {(SQ <'s/-/ /'>)})
                        ]
                        negated: F
                      )
                  )
                }
              spids: [430]
            )
          ]
        )
        (command.ShFunction
          name: usage
          body: 
            (BraceGroup
              children: [
                (C {<die>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (C {<eval_gettext>} 
                            {
                              (DQ <'usage: '> 
                                (word_part.EscapedLiteral
                                  token: <Id.Lit_EscapedChar '\\$'>
                                ) <'dashless '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <USAGE>
                              )
                            }
                          )
                      )
                    )
                  }
                )
              ]
            )
        )
        (command.If
          arms: [
            (if_arm
              cond: 
                (condition.Shell
                  commands: [
                    (C {<Id.Lit_LBracket '['>} {<-z>} {(DQ ($ Id.VSub_DollarName '$LONG_USAGE'))} 
                      {<Id.Lit_RBracket ']'>}
                    )
                  ]
                )
              action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:LONG_USAGE)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (DQ 
                            (command_sub
                              left_token: <Id.Left_DollarParen '$('>
                              child: 
                                (C {<eval_gettext>} 
                                  {
                                    (DQ <'usage: '> 
                                      (word_part.EscapedLiteral
                                        token: <Id.Lit_EscapedChar '\\$'>
                                      ) <'dashless '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <USAGE>
                                    )
                                  }
                                )
                            )
                          )
                        }
                      spids: [496]
                    )
                  ]
                )
              ]
              spids: [480 493]
            )
          ]
          else_action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:LONG_USAGE)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ 
                        (command_sub
                          left_token: <Id.Left_DollarParen '$('>
                          child: 
                            (C {<eval_gettext>} 
                              {
                                (DQ <'usage: '> 
                                  (word_part.EscapedLiteral
                                    token: <Id.Lit_EscapedChar '\\$'>
                                  ) <'dashless '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'USAGE\n'> <'\n'> 
                                  ($ Id.VSub_DollarName '$LONG_USAGE')
                                )
                              }
                            )
                        )
                      )
                    }
                  spids: [515]
                )
              ]
            )
          ]
        )
        (command.Case
          to_match: {(DQ ($ Id.VSub_Number '$1'))}
          arms: [
            (case_arm
              pat_list: [{<-h>}]
              action: [
                (C {<echo>} {(DQ ($ Id.VSub_DollarName '$LONG_USAGE'))})
                (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
              ]
              spids: [546 547 -1 560]
            )
          ]
        )
      ]
    )
    (command.ShFunction
      name: set_reflog_action
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (C {<Id.Lit_LBracket '['>} {<-z>} 
                          {
                            (DQ 
                              (braced_var_sub
                                token: <Id.VSub_Name GIT_REFLOG_ACTION>
                                suffix_op: 
                                  (suffix_op.Unary
                                    tok: <Id.VTest_ColonPlus ':+'>
                                    arg_word: {<set>}
                                  )
                              )
                            )
                          } {<Id.Lit_RBracket ']'>}
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:GIT_REFLOG_ACTION)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_Star '$*'))}
                          spids: [694]
                        )
                      ]
                    )
                    (C {<export>} {<GIT_REFLOG_ACTION>})
                  ]
                  spids: [674 691]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: git_editor
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (C {<test>} {<-z>} 
                          {
                            (DQ 
                              (braced_var_sub
                                token: <Id.VSub_Name GIT_EDITOR>
                                suffix_op: 
                                  (suffix_op.Unary
                                    tok: <Id.VTest_ColonPlus ':+'>
                                    arg_word: {<set>}
                                  )
                              )
                            )
                          }
                        )
                      ]
                    )
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:GIT_EDITOR)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (DQ 
                                    (command_sub
                                      left_token: <Id.Left_DollarParen '$('>
                                      child: (C {<git>} {<Id.KW_Var var>} {<GIT_EDITOR>})
                                    )
                                  )
                                }
                              spids: [735]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                          arg_word: {($ Id.VSub_QMark '$?')}
                        )
                      ]
                    )
                  ]
                  spids: [717 732]
                )
              ]
            )
            (C {<eval>} {(DQ ($ Id.VSub_DollarName '$GIT_EDITOR'))} {(SQ <'"$@"'>)})
          ]
        )
    )
    (command.ShFunction
      name: git_pager
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: (condition.Shell commands:[(C {<test>} {<-t>} {<1>})])
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:GIT_PAGER)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: (C {<git>} {<Id.KW_Var var>} {<GIT_PAGER>})
                              )
                            }
                          spids: [789]
                        )
                      ]
                    )
                  ]
                  spids: [777 786]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:GIT_PAGER)
                      op: assign_op.Equal
                      rhs: {<cat>}
                      spids: [802]
                    )
                  ]
                )
              ]
            )
            (command.ForEach
              iter_name: vardef
              iter_words: [
                {<Id.Lit_At '@'> <Id.Lit_Splice '@PAGER_ENV'> <Id.Lit_At '@'> <Id.Lit_At '@'>}
              ]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:var)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (braced_var_sub
                                token: <Id.VSub_Name vardef>
                                suffix_op: 
                                  (suffix_op.Unary
                                    tok: <Id.VOp1_DPercent '%%'>
                                    arg_word: {<'='> <Id.Lit_Other '*'>}
                                  )
                              )
                            }
                          spids: [824]
                        )
                      ]
                    )
                    (C {<eval>} 
                      {
                        (DQ <': '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) 
                          (word_part.EscapedLiteral
                            token: <Id.Lit_EscapedChar '\\$'>
                          ) <'{'> ($ Id.VSub_DollarName '$vardef') <'}'> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\"'>) 
                          <' && export '> ($ Id.VSub_DollarName '$var')
                        )
                      }
                    )
                  ]
                )
            )
            (C {<eval>} {(DQ ($ Id.VSub_DollarName '$GIT_PAGER'))} {(SQ <'"$@"'>)})
          ]
        )
    )
    (command.ShFunction
      name: sane_grep
      body: 
        (BraceGroup
          children: [
            (command.Simple
              words: [
                {<grep>}
                {<Id.Lit_At '@'> <Id.Lit_Splice '@SANE_TEXT_GREP'> <Id.Lit_At '@'> <Id.Lit_At '@'>}
                {(DQ ($ Id.VSub_At '$@'))}
              ]
              more_env: [
                (env_pair name:GREP_OPTIONS val:(word.Empty) spids:[873])
                (env_pair name:LC_ALL val:{<C>} spids:[875])
              ]
              do_fork: T
            )
          ]
        )
    )
    (command.ShFunction
      name: sane_egrep
      body: 
        (BraceGroup
          children: [
            (command.Simple
              words: [
                {<egrep>}
                {<Id.Lit_At '@'> <Id.Lit_Splice '@SANE_TEXT_GREP'> <Id.Lit_At '@'> <Id.Lit_At '@'>}
                {(DQ ($ Id.VSub_At '$@'))}
              ]
              more_env: [
                (env_pair name:GREP_OPTIONS val:(word.Empty) spids:[900])
                (env_pair name:LC_ALL val:{<C>} spids:[902])
              ]
              do_fork: T
            )
          ]
        )
    )
    (command.ShFunction
      name: is_bare_repository
      body: (BraceGroup children:[(C {<git>} {<rev-parse>} {<--is-bare-repository>})])
    )
    (command.ShFunction
      name: cd_to_toplevel
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DPipe]
              children: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:cdup)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: (C {<git>} {<rev-parse>} {<--show-toplevel>})
                          )
                        }
                      spids: [944]
                    )
                  ]
                )
                (C {<cd>} {(DQ ($ Id.VSub_DollarName '$cdup'))})
                (BraceGroup
                  children: [
                    (command.Simple
                      words: [
                        {<gettextln>}
                        {
                          (DQ <'Cannot chdir to '> 
                            (word_part.EscapedLiteral
                              token: <Id.Lit_EscapedChar '\\$'>
                            ) <'cdup, the toplevel of the working tree'>
                          )
                        }
                      ]
                      redirects: [(redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
                      do_fork: T
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Exit exit>
                      arg_word: {<1>}
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: require_work_tree_exists
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (C {<test>} 
                          {
                            (DQ <z> 
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: (C {<git>} {<rev-parse>} {<--is-bare-repository>})
                              )
                            )
                          } {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<zfalse>}
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:program_name)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_Number '$0')}
                          spids: [1021]
                        )
                      ]
                    )
                    (C {<die>} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (C {<gettext>} 
                                {
                                  (DQ <'fatal: '> 
                                    (word_part.EscapedLiteral
                                      token: <Id.Lit_EscapedChar '\\$'>
                                    ) <'program_name cannot be used without a working tree.'>
                                  )
                                }
                              )
                          )
                        )
                      }
                    )
                  ]
                  spids: [997 1018]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: require_work_tree
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<test>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (command.Simple
                            words: [{<git>} {<rev-parse>} {<--is-inside-work-tree>}]
                            redirects: [
                              (redir
                                op: <Id.Redir_Great '2>'>
                                loc: (redir_loc.Fd fd:2)
                                arg: {<'/dev/null'>}
                              )
                            ]
                            do_fork: T
                          )
                      )
                    )
                  } {<Id.Lit_Equals '='>} {<true>}
                )
                (BraceGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:program_name)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_Number '$0')}
                          spids: [1077]
                        )
                      ]
                    )
                    (C {<die>} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (C {<gettext>} 
                                {
                                  (DQ <'fatal: '> 
                                    (word_part.EscapedLiteral
                                      token: <Id.Lit_EscapedChar '\\$'>
                                    ) <'program_name cannot be used without a working tree.'>
                                  )
                                }
                              )
                          )
                        )
                      }
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: require_clean_work_tree
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.Simple
                  words: [{<git>} {<rev-parse>} {<--verify>} {<HEAD>}]
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {<'/dev/null'>}
                    )
                  ]
                  do_fork: T
                )
                (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{<1>})
              ]
            )
            (C {<git>} {<update-index>} {<-q>} {<--ignore-submodules>} {<--refresh>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:err)
                  op: assign_op.Equal
                  rhs: {<0>}
                  spids: [1138]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Pipeline
                          children: [(C {<git>} {<diff-files>} {<--quiet>} {<--ignore-submodules>})]
                          negated: T
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:action)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_Number '$1')}
                          spids: [1159]
                        )
                      ]
                    )
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_DollarName '$action'))}
                      arms: [
                        (case_arm
                          pat_list: [{<rebase>}]
                          action: [
                            (command.Simple
                              words: [{<gettextln>} {(DQ <'Cannot rebase: You have unstaged changes.'>)}]
                              redirects: [
                                (redir
                                  op: <Id.Redir_GreatAnd '>&'>
                                  loc: (redir_loc.Fd fd:1)
                                  arg: {<2>}
                                )
                              ]
                              do_fork: T
                            )
                          ]
                          spids: [1172 1173 1186 -1]
                        )
                        (case_arm
                          pat_list: [{(DQ <'rewrite branches'>)}]
                          action: [
                            (command.Simple
                              words: [
                                {<gettextln>}
                                {(DQ <'Cannot rewrite branches: You have unstaged changes.'>)}
                              ]
                              redirects: [
                                (redir
                                  op: <Id.Redir_GreatAnd '>&'>
                                  loc: (redir_loc.Fd fd:1)
                                  arg: {<2>}
                                )
                              ]
                              do_fork: T
                            )
                          ]
                          spids: [1189 1192 1205 -1]
                        )
                        (case_arm
                          pat_list: [{(DQ <'pull with rebase'>)}]
                          action: [
                            (command.Simple
                              words: [
                                {<gettextln>}
                                {(DQ <'Cannot pull with rebase: You have unstaged changes.'>)}
                              ]
                              redirects: [
                                (redir
                                  op: <Id.Redir_GreatAnd '>&'>
                                  loc: (redir_loc.Fd fd:1)
                                  arg: {<2>}
                                )
                              ]
                              do_fork: T
                            )
                          ]
                          spids: [1208 1211 1224 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [
                            (command.Simple
                              words: [
                                {<eval_gettextln>}
                                {
                                  (DQ <'Cannot '> 
                                    (word_part.EscapedLiteral
                                      token: <Id.Lit_EscapedChar '\\$'>
                                    ) <'action: You have unstaged changes.'>
                                  )
                                }
                              ]
                              redirects: [
                                (redir
                                  op: <Id.Redir_GreatAnd '>&'>
                                  loc: (redir_loc.Fd fd:1)
                                  arg: {<2>}
                                )
                              ]
                              do_fork: T
                            )
                          ]
                          spids: [1227 1228 1243 -1]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:err)
                          op: assign_op.Equal
                          rhs: {<1>}
                          spids: [1249]
                        )
                      ]
                    )
                  ]
                  spids: [1143 1156]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Pipeline
                          children: [
                            (C {<git>} {<diff-index>} {<--cached>} {<--quiet>} {<--ignore-submodules>} 
                              {<HEAD>} {<-->}
                            )
                          ]
                          negated: T
                        )
                      ]
                    )
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (C {<test>} {($ Id.VSub_DollarName '$err')} {<Id.Lit_Equals '='>} {<0>})
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:action)
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_Number '$1')}
                                  spids: [1293]
                                )
                              ]
                            )
                            (command.Case
                              to_match: {(DQ ($ Id.VSub_DollarName '$action'))}
                              arms: [
                                (case_arm
                                  pat_list: [{<rebase>}]
                                  action: [
                                    (command.Simple
                                      words: [
                                        {<gettextln>}
                                        {
                                          (DQ 
                                            <
'Cannot rebase: Your index contains uncommitted changes.'
                                            >
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (redir
                                          op: <Id.Redir_GreatAnd '>&'>
                                          loc: (redir_loc.Fd fd:1)
                                          arg: {<2>}
                                        )
                                      ]
                                      do_fork: T
                                    )
                                  ]
                                  spids: [1306 1307 1320 -1]
                                )
                                (case_arm
                                  pat_list: [{(DQ <'pull with rebase'>)}]
                                  action: [
                                    (command.Simple
                                      words: [
                                        {<gettextln>}
                                        {
                                          (DQ 
                                            <
'Cannot pull with rebase: Your index contains uncommitted changes.'
                                            >
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (redir
                                          op: <Id.Redir_GreatAnd '>&'>
                                          loc: (redir_loc.Fd fd:1)
                                          arg: {<2>}
                                        )
                                      ]
                                      do_fork: T
                                    )
                                  ]
                                  spids: [1323 1326 1339 -1]
                                )
                                (case_arm
                                  pat_list: [{<Id.Lit_Star '*'>}]
                                  action: [
                                    (command.Simple
                                      words: [
                                        {<eval_gettextln>}
                                        {
                                          (DQ <'Cannot '> 
                                            (word_part.EscapedLiteral
                                              token: <Id.Lit_EscapedChar '\\$'>
                                            ) <'action: Your index contains uncommitted changes.'>
                                          )
                                        }
                                      ]
                                      redirects: [
                                        (redir
                                          op: <Id.Redir_GreatAnd '>&'>
                                          loc: (redir_loc.Fd fd:1)
                                          arg: {<2>}
                                        )
                                      ]
                                      do_fork: T
                                    )
                                  ]
                                  spids: [1342 1343 1358 -1]
                                )
                              ]
                            )
                          ]
                          spids: [1279 1290]
                        )
                      ]
                      else_action: [
                        (command.Simple
                          words: [
                            {<gettextln>}
                            {(DQ <'Additionally, your index contains uncommitted changes.'>)}
                          ]
                          redirects: [
                            (redir
                              op: <Id.Redir_GreatAnd '>&'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<2>}
                            )
                          ]
                          do_fork: T
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:err)
                          op: assign_op.Equal
                          rhs: {<1>}
                          spids: [1380]
                        )
                      ]
                    )
                  ]
                  spids: [1257 1276]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (C {<test>} {($ Id.VSub_DollarName '$err')} {<Id.Lit_Equals '='>} {<1>})
                      ]
                    )
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<test>} {<-n>} {(DQ ($ Id.VSub_Number '$2'))})
                        (command.Simple
                          words: [{<echo>} {(DQ ($ Id.VSub_Number '$2'))}]
                          redirects: [
                            (redir
                              op: <Id.Redir_GreatAnd '>&'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<2>}
                            )
                          ]
                          do_fork: T
                        )
                      ]
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Exit exit>
                      arg_word: {<1>}
                    )
                  ]
                  spids: [1388 1399]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: pick_ident_script
      body: 
        (BraceGroup
          children: [
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: (condition.Shell commands:[(C {<test>} {($ Id.VSub_Pound '$#')} {<-gt>} {<0>})])
              body: 
                (command.DoGroup
                  children: [
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:lid)
                              op: assign_op.Equal
                              rhs: {($ Id.VSub_Number '$1')}
                              spids: [1481]
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (C {<shift>})
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:uid)
                              op: assign_op.Equal
                              rhs: {($ Id.VSub_Number '$1')}
                              spids: [1488]
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (C {<shift>})
                    (C {<printf>} {(SQ <'%s'>)} 
                      {
                        (DQ <'\n'> <'\t\t/^'> ($ Id.VSub_DollarName '$lid') <' /{\n'> <'\t\t\ts/\'/\''> 
                          (word_part.EscapedLiteral
                            token: <Id.Lit_EscapedChar '\\\\'>
                          ) (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\\\'>) <'\'\'/g\n'> <'\t\t\th\n'> <'\t\t\ts/^'> 
                          ($ Id.VSub_DollarName '$lid') <' '>
                        ) (SQ <'\\([^<]*\\) <[^>]*> .*$/\\1/'>) 
                        (DQ <'\n'> <'\t\t\ts/.*/GIT_'> (${ Id.VSub_Name uid) <'_NAME=\'&\'/p\n'> <'\n'> 
                          <'\t\t\tg\n'> <'\t\t\ts/^'> ($ Id.VSub_DollarName '$lid') <' '>
                        ) (SQ <'[^<]* <\\([^>]*\\)> .*$/\\1/'>) 
                        (DQ <'\n'> <'\t\t\ts/.*/GIT_'> (${ Id.VSub_Name uid) <'_EMAIL=\'&\'/p\n'> <'\n'> 
                          <'\t\t\tg\n'> <'\t\t\ts/^'> ($ Id.VSub_DollarName '$lid') <' '>
                        ) (SQ <'[^<]* <[^>]*> \\(.*\\)$/@\\1/'>) 
                        (DQ <'\n'> <'\t\t\ts/.*/GIT_'> (${ Id.VSub_Name uid) <'_DATE=\'&\'/p\n'> 
                          <'\t\t}\n'> <'\t\t'>
                        )
                      }
                    )
                  ]
                )
            )
            (C {<echo>} {(SQ <'/^$/q'>)})
          ]
        )
    )
    (command.ShFunction
      name: parse_ident_from_commit
      body: 
        (BraceGroup
          children: [
            (command.Simple
              words: [
                {<sed>}
                {<-ne>}
                {
                  (DQ 
                    (command_sub
                      left_token: <Id.Left_DollarParen '$('>
                      child: (C {<pick_ident_script>} {(DQ ($ Id.VSub_At '$@'))})
                    )
                  )
                }
              ]
              more_env: [
                (env_pair name:LANG val:{<C>} spids:[1588])
                (env_pair name:LC_ALL val:{<C>} spids:[1591])
              ]
              do_fork: T
            )
          ]
        )
    )
    (command.ShFunction
      name: get_author_ident_from_commit
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:encoding)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (command.AndOr
                            ops: [Id.Op_DPipe]
                            children: [
                              (C {<git>} {<config>} {<i18n.commitencoding>})
                              (C {<echo>} {<UTF-8>})
                            ]
                          )
                      )
                    }
                  spids: [1625]
                )
              ]
            )
            (command.Pipeline
              children: [
                (C {<git>} {<show>} {<-s>} {<--pretty> <Id.Lit_Equals '='> <raw>} 
                  {<--encoding> <Id.Lit_Equals '='> (DQ ($ Id.VSub_DollarName '$encoding'))} {(DQ ($ Id.VSub_Number '$1'))} {<-->}
                )
                (C {<parse_ident_from_commit>} {<author>} {<AUTHOR>})
              ]
              negated: F
            )
          ]
        )
    )
    (command.ShFunction
      name: clear_local_git_env
      body: 
        (BraceGroup
          children: [
            (C {<unset>} 
              {
                (command_sub
                  left_token: <Id.Left_DollarParen '$('>
                  child: (C {<git>} {<rev-parse>} {<--local-env-vars>})
                )
              }
            )
          ]
        )
    )
    (command.ShFunction
      name: create_virtual_base
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:sz0)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (command.Simple
                            words: [{<wc>} {<-c>}]
                            redirects: [
                              (redir
                                op: <Id.Redir_Less '<'>
                                loc: (redir_loc.Fd fd:0)
                                arg: {(DQ ($ Id.VSub_Number '$1'))}
                              )
                            ]
                            do_fork: T
                          )
                      )
                    }
                  spids: [1717]
                )
              ]
            )
            (command.Pipeline
              children: [
                (C {<Id.Lit_At '@'> <Id.Lit_Splice '@DIFF'> <Id.Lit_At '@'> <Id.Lit_At '@'>} {<-u>} 
                  {<'-La/'> (DQ ($ Id.VSub_Number '$1'))} {<'-Lb/'> (DQ ($ Id.VSub_Number '$1'))} {(DQ ($ Id.VSub_Number '$1'))} {(DQ ($ Id.VSub_Number '$2'))}
                )
                (C {<git>} {<apply>} {<--no-add>})
              ]
              negated: F
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:sz1)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (command.Simple
                            words: [{<wc>} {<-c>}]
                            redirects: [
                              (redir
                                op: <Id.Redir_Less '<'>
                                loc: (redir_loc.Fd fd:0)
                                arg: {(DQ ($ Id.VSub_Number '$1'))}
                              )
                            ]
                            do_fork: T
                          )
                      )
                    }
                  spids: [1764]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.Simple
                  words: [
                    {<expr>}
                    {($ Id.VSub_DollarName '$sz0')}
                    {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\<'>)}
                    {($ Id.VSub_DollarName '$sz1')}
                    {(word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\*'>)}
                    {<2>}
                  ]
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {<'/dev/null'>}
                    )
                  ]
                  do_fork: T
                )
                (command.Simple
                  words: [{<Id.Lit_Colon ':'>}]
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '>'>
                      loc: (redir_loc.Fd fd:1)
                      arg: {(DQ ($ Id.VSub_Number '$1'))}
                    )
                  ]
                  do_fork: T
                )
              ]
            )
          ]
        )
    )
    (command.Case
      to_match: {(command_sub left_token:<Id.Left_DollarParen '$('> child:(C {<uname>} {<-s>}))}
      arms: [
        (case_arm
          pat_list: [{<Id.Lit_Star '*'> <MINGW> <Id.Lit_Star '*'>}]
          action: [
            (command.ShFunction
              name: sort
              body: (BraceGroup children:[(C {<'/usr/bin/sort'>} {(DQ ($ Id.VSub_At '$@'))})])
            )
            (command.ShFunction
              name: find
              body: (BraceGroup children:[(C {<'/usr/bin/find'>} {(DQ ($ Id.VSub_At '$@'))})])
            )
            (command.ShFunction
              name: pwd
              body: (BraceGroup children:[(C {<builtin>} {<pwd>} {<-W>})])
            )
            (command.ShFunction
              name: is_absolute_path
              body: 
                (BraceGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_Number '$1'))}
                      arms: [
                        (case_arm
                          pat_list: [
                            {<Id.Lit_LBracket '['> <'/'> 
                              (word_part.EscapedLiteral
                                token: <Id.Lit_EscapedChar '\\\\'>
                              ) <Id.Lit_RBracket ']'> <Id.Lit_Star '*'>
                            }
                            {<Id.Lit_LBracket '['> <A-Za-z> <Id.Lit_RBracket ']'> <Id.Lit_Colon ':'> 
                              <Id.Lit_Star '*'>
                            }
                          ]
                          action: [
                            (command.ControlFlow
                              token: <Id.ControlFlow_Return return>
                              arg_word: {<0>}
                            )
                          ]
                          spids: [1912 1925 1932 -1]
                        )
                      ]
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<1>}
                    )
                  ]
                )
            )
          ]
          spids: [1827 1830 1946 -1]
        )
        (case_arm
          pat_list: [{<Id.Lit_Star '*'>}]
          action: [
            (command.ShFunction
              name: is_absolute_path
              body: 
                (BraceGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_Number '$1'))}
                      arms: [
                        (case_arm
                          pat_list: [{<'/'> <Id.Lit_Star '*'>}]
                          action: [
                            (command.ControlFlow
                              token: <Id.ControlFlow_Return return>
                              arg_word: {<0>}
                            )
                          ]
                          spids: [1969 1971 1978 -1]
                        )
                      ]
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {<1>}
                    )
                  ]
                )
            )
          ]
          spids: [1948 1949 -1 1991]
        )
      ]
    )
    (command.ShFunction
      name: git_dir_init
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:GIT_DIR)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: (C {<git>} {<rev-parse>} {<--git-dir>})
                          )
                        }
                      spids: [2008]
                    )
                  ]
                )
                (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (C {<Id.Lit_LBracket '['>} {<-z>} 
                          {(DQ ($ Id.VSub_DollarName '$SUBDIRECTORY_OK'))} {<Id.Lit_RBracket ']'>}
                        )
                      ]
                    )
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<test>} {<-z>} 
                          {
                            (DQ 
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: (C {<git>} {<rev-parse>} {<--show-cdup>})
                              )
                            )
                          }
                        )
                        (BraceGroup
                          children: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:exit)
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_QMark '$?')}
                                  spids: [2057]
                                )
                              ]
                            )
                            (command.Simple
                              words: [
                                {<gettextln>}
                                {
                                  (DQ 
                                    <
'You need to run this command from the toplevel of the working tree.'
                                    >
                                  )
                                }
                              ]
                              redirects: [
                                (redir
                                  op: <Id.Redir_GreatAnd '>&'>
                                  loc: (redir_loc.Fd fd:1)
                                  arg: {<2>}
                                )
                              ]
                              do_fork: T
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Exit exit>
                              arg_word: {($ Id.VSub_DollarName '$exit')}
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [2022 2035]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DPipe]
              children: [
                (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$GIT_DIR'))})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:GIT_DIR)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (command.AndOr
                                ops: [Id.Op_DAmp]
                                children: [
                                  (C {<cd>} {(DQ ($ Id.VSub_DollarName '$GIT_DIR'))})
                                  (C {<pwd>})
                                ]
                              )
                          )
                        }
                      spids: [2092]
                    )
                  ]
                )
                (BraceGroup
                  children: [
                    (command.Simple
                      words: [
                        {<gettextln>}
                        {(DQ <'Unable to determine absolute path of git directory'>)}
                      ]
                      redirects: [(redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
                      do_fork: T
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Exit exit>
                      arg_word: {<1>}
                    )
                  ]
                )
              ]
            )
            (C {<Id.Lit_Colon ':'>} 
              {
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name GIT_OBJECT_DIRECTORY>
                    suffix_op: 
                      (suffix_op.Unary
                        tok: <Id.VTest_Equals '='>
                        arg_word: 
                          {
                            (DQ 
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: (C {<git>} {<rev-parse>} {<--git-path>} {<objects>})
                              )
                            )
                          }
                      )
                  )
                )
              }
            )
          ]
        )
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [(C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$NONGIT_OK'))})]
            )
          action: [(C {<git_dir_init>})]
          spids: [2151 2161]
        )
      ]
    )
    (command.ShFunction
      name: peel_committish
      body: 
        (BraceGroup
          children: [
            (command.Case
              to_match: {(DQ ($ Id.VSub_Number '$1'))}
              arms: [
                (case_arm
                  pat_list: [{<Id.Lit_Colon ':'> <'/'> <Id.Lit_Star '*'>}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:peeltmp)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (C {<git>} {<rev-parse>} {<--verify>} {(DQ ($ Id.VSub_Number '$1'))})
                                  )
                                }
                              spids: [2192]
                            )
                          ]
                        )
                        (C {<git>} {<rev-parse>} {<--verify>} {(DQ (${ Id.VSub_Name peeltmp) <'^0'>)})
                      ]
                    )
                  ]
                  spids: [2186 2189 2222 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [(C {<git>} {<rev-parse>} {<--verify>} {(DQ (${ Id.VSub_Number 1) <'^0'>)})]
                  spids: [2225 2226 2243 -1]
                )
              ]
            )
          ]
        )
    )
  ]
)