(command.CommandList
  children: [
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:__git_printf_supports_v)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [289]
        )
      ]
    )
    (command.Simple
      words: [{<printf>} {<-v>} {<__git_printf_supports_v>} {<-->} {(SQ <'%s'>)} {<yes>}]
      redirects: [
        (redir op:<Id.Redir_Great '>'> loc:(redir_loc.Fd fd:1) arg:{<'/dev/null'>})
        (redir op:<Id.Redir_GreatAnd '2>&'> loc:(redir_loc.Fd fd:2) arg:{<1>})
      ]
      do_fork: T
    )
    (command.ShFunction
      name: __git_ps1_show_upstream
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<key>} {<value>})
            (C {<local>} {<svn_remote>} {<svn_url_pattern>} {<count>} {<n>})
            (C {<local>} {<Id.Lit_VarLike 'upstream='> <git>} {<Id.Lit_VarLike 'legacy='> (DQ )} 
              {<Id.Lit_VarLike 'verbose='> (DQ )} {<Id.Lit_VarLike 'name='> (DQ )}
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:svn_remote)
                  op: assign_op.Equal
                  rhs: {(sh_array_literal left:<Id.Op_LParen _>)}
                  spids: [363]
                )
              ]
            )
            (C {<local>} 
              {<Id.Lit_VarLike 'output='> 
                (DQ 
                  (command_sub
                    left_token: <Id.Left_DollarParen '$('>
                    child: 
                      (command.Pipeline
                        children: [
                          (command.Simple
                            words: [
                              {<git>}
                              {<config>}
                              {<-z>}
                              {<--get-regexp>}
                              {(SQ <'^(svn-remote\\..*\\.url|bash\\.showupstream)$'>)}
                            ]
                            redirects: [
                              (redir
                                op: <Id.Redir_Great '2>'>
                                loc: (redir_loc.Fd fd:2)
                                arg: {<'/dev/null'>}
                              )
                            ]
                            do_fork: T
                          )
                          (C {<tr>} {(SQ <'\\0\\n'>)} {(SQ <'\\n '>)})
                        ]
                        negated: F
                      )
                  )
                )
              }
            )
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: 
                (condition.Shell
                  commands: [
                    (command.Sentence
                      child: (C {<read>} {<-r>} {<key>} {<value>})
                      terminator: <Id.Op_Semi _>
                    )
                  ]
                )
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_DollarName '$key'))}
                      arms: [
                        (case_arm
                          pat_list: [{<bash.showupstream>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:GIT_PS1_SHOWUPSTREAM)
                                  op: assign_op.Equal
                                  rhs: {(DQ ($ Id.VSub_DollarName '$value'))}
                                  spids: [434]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (command.DBracket
                                              expr: 
                                                (bool_expr.Unary
                                                  op_id: Id.BoolUnary_z
                                                  child: {(DQ (${ Id.VSub_Name GIT_PS1_SHOWUPSTREAM))}
                                                )
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:p)
                                          op: assign_op.Equal
                                          rhs: {(DQ )}
                                          spids: [458]
                                        )
                                      ]
                                    )
                                    (command.ControlFlow
                                      token: <Id.ControlFlow_Return return>
                                    )
                                  ]
                                  spids: [440 455]
                                )
                              ]
                            )
                          ]
                          spids: [430 431 469 -1]
                        )
                        (case_arm
                          pat_list: [{<svn-remote.> <Id.Lit_Star '*'> <.url>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: 
                                    (sh_lhs_expr.IndexedName
                                      name: svn_remote
                                      index: 
                                        {
                                          (word_part.ArithSub
                                            anode: 
                                              (arith_expr.Binary
                                                op_id: Id.Arith_Plus
                                                left: 
                                                  {
                                                    (braced_var_sub
                                                      token: <Id.VSub_Name svn_remote>
                                                      prefix_op: (Id.VSub_Pound)
                                                      bracket_op: 
                                                        (bracket_op.WholeArray
                                                          op_id: Id.Lit_At
                                                        )
                                                    )
                                                  }
                                                right: {<Id.Lit_Digits 1>}
                                              )
                                          )
                                        }
                                    )
                                  op: assign_op.Equal
                                  rhs: {(DQ ($ Id.VSub_DollarName '$value'))}
                                  spids: [478]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:svn_url_pattern)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ ($ Id.VSub_DollarName '$svn_url_pattern') 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\\\'>
                                        ) <'|'> ($ Id.VSub_DollarName '$value')
                                      )
                                    }
                                  spids: [514]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:upstream)
                                  op: assign_op.Equal
                                  rhs: {<svn> <Id.Lit_Other '+'> <git>}
                                  spids: [523]
                                )
                              ]
                            )
                          ]
                          spids: [472 475 532 -1]
                        )
                      ]
                    )
                  ]
                )
              redirects: [
                (redir
                  op: <Id.Redir_TLess '<<<'>
                  loc: (redir_loc.Fd fd:0)
                  arg: {(DQ ($ Id.VSub_DollarName '$output'))}
                )
              ]
            )
            (command.ForEach
              iter_name: option
              iter_words: [{(${ Id.VSub_Name GIT_PS1_SHOWUPSTREAM)}]
              do_arg_iter: F
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_DollarName '$option'))}
                      arms: [
                        (case_arm
                          pat_list: [{<git>} {<svn>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:upstream)
                                  op: assign_op.Equal
                                  rhs: {(DQ ($ Id.VSub_DollarName '$option'))}
                                  spids: [580]
                                )
                              ]
                            )
                          ]
                          spids: [575 578 585 -1]
                        )
                        (case_arm
                          pat_list: [{<verbose>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:verbose)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [591]
                                )
                              ]
                            )
                          ]
                          spids: [588 589 594 -1]
                        )
                        (case_arm
                          pat_list: [{<legacy>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:legacy)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [600]
                                )
                              ]
                            )
                          ]
                          spids: [597 598 603 -1]
                        )
                        (case_arm
                          pat_list: [{<name>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:name)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [609]
                                )
                              ]
                            )
                          ]
                          spids: [606 607 612 -1]
                        )
                      ]
                    )
                  ]
                )
            )
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName '$upstream'))}
              arms: [
                (case_arm
                  pat_list: [{<git>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:upstream)
                          op: assign_op.Equal
                          rhs: {(DQ <'@{upstream}'>)}
                          spids: [638]
                        )
                      ]
                    )
                  ]
                  spids: [635 636 643 -1]
                )
                (case_arm
                  pat_list: [{<svn> <Id.Lit_Star '*'>}]
                  action: [
                    (C {<local>} {<-a>} {<svn_upstream>})
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:svn_upstream)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (sh_array_literal
                                left: <Id.Op_LParen _>
                                words: [
                                  {
                                    (command_sub
                                      left_token: <Id.Left_DollarParen '$('>
                                      child: 
                                        (command.Simple
                                          words: [
                                            {<git>}
                                            {<log>}
                                            {<--first-parent>}
                                            {<-1>}
                                            {<--grep> <Id.Lit_Equals '='> 
                                              (DQ <'^git-svn-id: '> <Id.Lit_BadBackslash '\\'> <'('> 
                                                (braced_var_sub
                                                  token: <Id.VSub_Name svn_url_pattern>
                                                  suffix_op: 
                                                    (suffix_op.Unary
                                                      tok: <Id.VOp1_Pound '#'>
                                                      arg_word: 
                                                        {<Id.Lit_Other '?'> <Id.Lit_Other '?'>}
                                                    )
                                                ) <Id.Lit_BadBackslash '\\'> <')'>
                                              )
                                            }
                                          ]
                                          redirects: [
                                            (redir
                                              op: <Id.Redir_Great '2>'>
                                              loc: (redir_loc.Fd fd:2)
                                              arg: {<'/dev/null'>}
                                            )
                                          ]
                                          do_fork: T
                                        )
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [666]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_ne
                                          left: {<0>}
                                          right: 
                                            {
                                              (braced_var_sub
                                                token: <Id.VSub_Name svn_upstream>
                                                prefix_op: (Id.VSub_Pound)
                                                bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                                              )
                                            }
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:svn_upstream)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (braced_var_sub
                                        token: <Id.VSub_Name svn_upstream>
                                        bracket_op: 
                                          (bracket_op.ArrayIndex
                                            expr: 
                                              (arith_expr.Binary
                                                op_id: Id.Arith_Minus
                                                left: 
                                                  {
                                                    (braced_var_sub
                                                      token: <Id.VSub_Name svn_upstream>
                                                      prefix_op: (Id.VSub_Pound)
                                                      bracket_op: 
                                                        (bracket_op.WholeArray
                                                          op_id: Id.Lit_At
                                                        )
                                                    )
                                                  }
                                                right: {<Id.Lit_Digits 2>}
                                              )
                                          )
                                      )
                                    }
                                  spids: [723]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:svn_upstream)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (braced_var_sub
                                        token: <Id.VSub_Name svn_upstream>
                                        suffix_op: 
                                          (suffix_op.Unary
                                            tok: <Id.VOp1_Percent '%'>
                                            arg_word: {<Id.Lit_Other '@'> <Id.Lit_Other '*'>}
                                          )
                                      )
                                    }
                                  spids: [742]
                                )
                              ]
                            )
                            (C {<local>} 
                              {<Id.Lit_VarLike 'n_stop='> 
                                (DQ 
                                  (braced_var_sub
                                    token: <Id.VSub_Name svn_remote>
                                    prefix_op: (Id.VSub_Pound)
                                    bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                                  )
                                )
                              }
                            )
                            (command.ForExpr
                              init: 
                                (arith_expr.BinaryAssign
                                  op_id: Id.Arith_Equal
                                  left: <Id.Lit_ArithVarLike n>
                                  right: {<Id.Lit_Digits 1>}
                                )
                              cond: 
                                (arith_expr.Binary
                                  op_id: Id.Arith_LessEqual
                                  left: <Id.Lit_ArithVarLike n>
                                  right: <Id.Lit_ArithVarLike n_stop>
                                )
                              update: 
                                (arith_expr.UnaryAssign
                                  op_id: Id.Node_PostDPlus
                                  child: <Id.Lit_ArithVarLike n>
                                )
                              body: 
                                (command.DoGroup
                                  children: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:svn_upstream)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (braced_var_sub
                                                token: <Id.VSub_Name svn_upstream>
                                                suffix_op: 
                                                  (suffix_op.Unary
                                                    tok: <Id.VOp1_Pound '#'>
                                                    arg_word: 
                                                      {
                                                        (braced_var_sub
                                                          token: <Id.VSub_Name svn_remote>
                                                          bracket_op: 
                                                            (bracket_op.ArrayIndex
                                                              expr: {($ Id.VSub_DollarName '$n')}
                                                            )
                                                        )
                                                      }
                                                  )
                                              )
                                            }
                                          spids: [789]
                                        )
                                      ]
                                    )
                                  ]
                                )
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (command.DBracket
                                              expr: 
                                                (bool_expr.Unary
                                                  op_id: Id.BoolUnary_z
                                                  child: {(DQ ($ Id.VSub_DollarName '$svn_upstream'))}
                                                )
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:upstream)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (braced_var_sub
                                                token: <Id.VSub_Name GIT_SVN_ID>
                                                suffix_op: 
                                                  (suffix_op.Unary
                                                    tok: <Id.VTest_ColonHyphen ':-'>
                                                    arg_word: {<git-svn>}
                                                  )
                                              )
                                            }
                                          spids: [826]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [806 819]
                                )
                              ]
                              else_action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:upstream)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (braced_var_sub
                                            token: <Id.VSub_Name svn_upstream>
                                            suffix_op: 
                                              (suffix_op.Unary
                                                tok: <Id.VOp1_Pound '#'>
                                                arg_word: {<Id.Lit_Slash '/'>}
                                              )
                                          )
                                        }
                                      spids: [837]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                          spids: [701 720]
                        )
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobEqual
                                          left: {(DQ <'svn+git'>)}
                                          right: {(DQ ($ Id.VSub_DollarName '$upstream'))}
                                        )
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:upstream)
                                  op: assign_op.Equal
                                  rhs: {(DQ <'@{upstream}'>)}
                                  spids: [868]
                                )
                              ]
                            )
                          ]
                          spids: [848 865]
                        )
                      ]
                    )
                  ]
                  spids: [646 648 877 -1]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_z
                                  child: {(DQ ($ Id.VSub_DollarName '$legacy'))}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:count)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (command_sub
                                  left_token: <Id.Left_DollarParen '$('>
                                  child: 
                                    (command.Simple
                                      words: [
                                        {<git>}
                                        {<rev-list>}
                                        {<--count>}
                                        {<--left-right>}
                                        {(DQ ($ Id.VSub_DollarName '$upstream')) <...HEAD>}
                                      ]
                                      redirects: [
                                        (redir
                                          op: <Id.Redir_Great '2>'>
                                          loc: (redir_loc.Fd fd:2)
                                          arg: {<'/dev/null'>}
                                        )
                                      ]
                                      do_fork: T
                                    )
                                )
                              )
                            }
                          spids: [904]
                        )
                      ]
                    )
                  ]
                  spids: [888 901]
                )
              ]
              else_action: [
                (C {<local>} {<commits>})
                (command.If
                  arms: [
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:commits)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (command_sub
                                          left_token: <Id.Left_DollarParen '$('>
                                          child: 
                                            (command.Simple
                                              words: [
                                                {<git>}
                                                {<rev-list>}
                                                {<--left-right>}
                                                {(DQ ($ Id.VSub_DollarName '$upstream')) <...HEAD>}
                                              ]
                                              redirects: [
                                                (redir
                                                  op: <Id.Redir_Great '2>'>
                                                  loc: (redir_loc.Fd fd:2)
                                                  arg: {<'/dev/null'>}
                                                )
                                              ]
                                              do_fork: T
                                            )
                                        )
                                      )
                                    }
                                  spids: [942]
                                )
                              ]
                            )
                          ]
                        )
                      action: [
                        (C {<local>} {<commit>} {<Id.Lit_VarLike 'behind='> <0>} 
                          {<Id.Lit_VarLike 'ahead='> <0>}
                        )
                        (command.ForEach
                          iter_name: commit
                          iter_words: [{($ Id.VSub_DollarName '$commits')}]
                          do_arg_iter: F
                          body: 
                            (command.DoGroup
                              children: [
                                (command.Case
                                  to_match: {(DQ ($ Id.VSub_DollarName '$commit'))}
                                  arms: [
                                    (case_arm
                                      pat_list: [{(DQ <'<'>) <Id.Lit_Star '*'>}]
                                      action: [
                                        (command.DParen
                                          child: 
                                            (arith_expr.UnaryAssign
                                              op_id: Id.Node_PostDPlus
                                              child: <Id.Lit_ArithVarLike behind>
                                            )
                                        )
                                      ]
                                      spids: [997 1001 1009 -1]
                                    )
                                    (case_arm
                                      pat_list: [{<Id.Lit_Star '*'>}]
                                      action: [
                                        (command.DParen
                                          child: 
                                            (arith_expr.UnaryAssign
                                              op_id: Id.Node_PostDPlus
                                              child: <Id.Lit_ArithVarLike ahead>
                                            )
                                        )
                                      ]
                                      spids: [1012 1013 1021 -1]
                                    )
                                  ]
                                )
                              ]
                            )
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:count)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (DQ ($ Id.VSub_DollarName '$behind') <'\t'> 
                                    ($ Id.VSub_DollarName '$ahead')
                                  )
                                }
                              spids: [1030]
                            )
                          ]
                        )
                      ]
                      spids: [940 962]
                    )
                  ]
                  else_action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:count)
                          op: assign_op.Equal
                          rhs: {(DQ )}
                          spids: [1041]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_z
                                  child: {(DQ ($ Id.VSub_DollarName '$verbose'))}
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_DollarName '$count'))}
                      arms: [
                        (case_arm
                          pat_list: [{(DQ )}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:p)
                                  op: assign_op.Equal
                                  rhs: {(DQ )}
                                  spids: [1090]
                                )
                              ]
                            )
                          ]
                          spids: [1082 1084 1094 -1]
                        )
                        (case_arm
                          pat_list: [{(DQ <'0\t0'>)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:p)
                                  op: assign_op.Equal
                                  rhs: {(DQ <'='>)}
                                  spids: [1106]
                                )
                              ]
                            )
                          ]
                          spids: [1097 1100 1111 -1]
                        )
                        (case_arm
                          pat_list: [{(DQ <'0\t'>) <Id.Lit_Star '*'>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:p)
                                  op: assign_op.Equal
                                  rhs: {(DQ <'>'>)}
                                  spids: [1124]
                                )
                              ]
                            )
                          ]
                          spids: [1114 1118 1129 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'> (DQ <'\t0'>)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:p)
                                  op: assign_op.Equal
                                  rhs: {(DQ <'<'>)}
                                  spids: [1142]
                                )
                              ]
                            )
                          ]
                          spids: [1132 1136 1147 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:p)
                                  op: assign_op.Equal
                                  rhs: {(DQ <'<>'>)}
                                  spids: [1157]
                                )
                              ]
                            )
                          ]
                          spids: [1150 1151 1162 -1]
                        )
                      ]
                    )
                  ]
                  spids: [1057 1070]
                )
              ]
              else_action: [
                (command.Case
                  to_match: {(DQ ($ Id.VSub_DollarName '$count'))}
                  arms: [
                    (case_arm
                      pat_list: [{(DQ )}]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:p)
                              op: assign_op.Equal
                              rhs: {(DQ )}
                              spids: [1188]
                            )
                          ]
                        )
                      ]
                      spids: [1180 1182 1192 -1]
                    )
                    (case_arm
                      pat_list: [{(DQ <'0\t0'>)}]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:p)
                              op: assign_op.Equal
                              rhs: {(DQ <' u='>)}
                              spids: [1204]
                            )
                          ]
                        )
                      ]
                      spids: [1195 1198 1209 -1]
                    )
                    (case_arm
                      pat_list: [{(DQ <'0\t'>) <Id.Lit_Star '*'>}]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:p)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (DQ <' u+'> 
                                    (braced_var_sub
                                      token: <Id.VSub_Name count>
                                      suffix_op: 
                                        (suffix_op.Unary
                                          tok: <Id.VOp1_Pound '#'>
                                          arg_word: {<'0\t'>}
                                        )
                                    )
                                  )
                                }
                              spids: [1222]
                            )
                          ]
                        )
                      ]
                      spids: [1212 1216 1232 -1]
                    )
                    (case_arm
                      pat_list: [{<Id.Lit_Star '*'> (DQ <'\t0'>)}]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:p)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (DQ <' u-'> 
                                    (braced_var_sub
                                      token: <Id.VSub_Name count>
                                      suffix_op: 
                                        (suffix_op.Unary
                                          tok: <Id.VOp1_Percent '%'>
                                          arg_word: {<'\t0'>}
                                        )
                                    )
                                  )
                                }
                              spids: [1245]
                            )
                          ]
                        )
                      ]
                      spids: [1235 1239 1255 -1]
                    )
                    (case_arm
                      pat_list: [{<Id.Lit_Star '*'>}]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:p)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (DQ <' u+'> 
                                    (braced_var_sub
                                      token: <Id.VSub_Name count>
                                      suffix_op: 
                                        (suffix_op.Unary
                                          tok: <Id.VOp1_Pound '#'>
                                          arg_word: {<Id.Lit_Other '*'> <'\t'>}
                                        )
                                    ) <-> 
                                    (braced_var_sub
                                      token: <Id.VSub_Name count>
                                      suffix_op: 
                                        (suffix_op.Unary
                                          tok: <Id.VOp1_Percent '%'>
                                          arg_word: {<'\t'> <Id.Lit_Other '*'>}
                                        )
                                    )
                                  )
                                }
                              spids: [1265]
                            )
                          ]
                        )
                      ]
                      spids: [1258 1259 1283 -1]
                    )
                  ]
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (command.Sentence
                              child: 
                                (command.DBracket
                                  expr: 
                                    (bool_expr.LogicalAnd
                                      left: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_n
                                          child: {(DQ ($ Id.VSub_DollarName '$count'))}
                                        )
                                      right: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_n
                                          child: {(DQ ($ Id.VSub_DollarName '$name'))}
                                        )
                                    )
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:__git_ps1_upstream_name)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (command.Simple
                                        words: [
                                          {<git>}
                                          {<rev-parse>}
                                          {<--abbrev-ref>}
                                          {(DQ ($ Id.VSub_DollarName '$upstream'))}
                                        ]
                                        redirects: [
                                          (redir
                                            op: <Id.Redir_Great '2>'>
                                            loc: (redir_loc.Fd fd:2)
                                            arg: {<'/dev/null'>}
                                          )
                                        ]
                                        do_fork: T
                                      )
                                  )
                                }
                              spids: [1313]
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.Sentence
                                      child: 
                                        (command.AndOr
                                          ops: [Id.Op_DAmp]
                                          children: [
                                            (C {<Id.Lit_LBracket '['>} 
                                              {($ Id.VSub_DollarName '$pcmode')} {<Id.Lit_Equals '='>} {<yes>} {<Id.Lit_RBracket ']'>}
                                            )
                                            (C {<Id.Lit_LBracket '['>} 
                                              {($ Id.VSub_DollarName '$ps1_expanded')} {<Id.Lit_Equals '='>} {<yes>} {<Id.Lit_RBracket ']'>}
                                            )
                                          ]
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                )
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:p)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (DQ ($ Id.VSub_DollarName '$p') <' '> 
                                            (word_part.EscapedLiteral
                                              token: <Id.Lit_EscapedChar '\\$'>
                                            ) <'{__git_ps1_upstream_name}'>
                                          )
                                        }
                                      spids: [1360]
                                    )
                                  ]
                                )
                              ]
                              spids: [1332 1357]
                            )
                          ]
                          else_action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:p)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ ($ Id.VSub_DollarName '$p') <' '> 
                                        (${ Id.VSub_Name __git_ps1_upstream_name)
                                      )
                                    }
                                  spids: [1372]
                                )
                              ]
                            )
                            (C {<unset>} {<__git_ps1_upstream_name>})
                          ]
                        )
                      ]
                      spids: [1289 1310]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: __git_ps1_colorize_gitstring
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Unary
                                  op_id: Id.BoolUnary_n
                                  child: 
                                    {
                                      (braced_var_sub
                                        token: <Id.VSub_Name ZSH_VERSION>
                                        suffix_op: (suffix_op.Unary tok:<Id.VTest_Hyphen -> arg_word:{})
                                      )
                                    }
                                )
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<local>} {<Id.Lit_VarLike 'c_red='> (SQ <'%F{red}'>)})
                    (C {<local>} {<Id.Lit_VarLike 'c_green='> (SQ <'%F{green}'>)})
                    (C {<local>} {<Id.Lit_VarLike 'c_lblue='> (SQ <'%F{blue}'>)})
                    (C {<local>} {<Id.Lit_VarLike 'c_clear='> (SQ <'%f'>)})
                  ]
                  spids: [1424 1438]
                )
              ]
              else_action: [
                (C {<local>} {<Id.Lit_VarLike 'c_red='> (SQ <'\\[\\e[31m\\]'>)})
                (C {<local>} {<Id.Lit_VarLike 'c_green='> (SQ <'\\[\\e[32m\\]'>)})
                (C {<local>} {<Id.Lit_VarLike 'c_lblue='> (SQ <'\\[\\e[1;34m\\]'>)})
                (C {<local>} {<Id.Lit_VarLike 'c_clear='> (SQ <'\\[\\e[0m\\]'>)})
              ]
            )
            (C {<local>} {<Id.Lit_VarLike 'bad_color='> ($ Id.VSub_DollarName '$c_red')})
            (C {<local>} {<Id.Lit_VarLike 'ok_color='> ($ Id.VSub_DollarName '$c_green')})
            (C {<local>} {<Id.Lit_VarLike 'flags_color='> (DQ ($ Id.VSub_DollarName '$c_lblue'))})
            (C {<local>} {<Id.Lit_VarLike 'branch_color='> (DQ )})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {($ Id.VSub_DollarName '$detached')} 
                              {<Id.Lit_Equals '='>} {<no>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:branch_color)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_DollarName '$ok_color'))}
                          spids: [1563]
                        )
                      ]
                    )
                  ]
                  spids: [1547 1560]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:branch_color)
                      op: assign_op.Equal
                      rhs: {(DQ ($ Id.VSub_DollarName '$bad_color'))}
                      spids: [1572]
                    )
                  ]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:c)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$branch_color') ($ Id.VSub_DollarName '$c'))}
                  spids: [1581]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:z)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$c_clear') ($ Id.VSub_DollarName '$z'))}
                  spids: [1589]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$w'))} 
                              {<Id.Lit_Equals '='>} {(DQ <'*'>)} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:w)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_DollarName '$bad_color') ($ Id.VSub_DollarName '$w'))}
                          spids: [1616]
                        )
                      ]
                    )
                  ]
                  spids: [1596 1613]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {<-n>} {(DQ ($ Id.VSub_DollarName '$i'))} 
                              {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:i)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_DollarName '$ok_color') ($ Id.VSub_DollarName '$i'))}
                          spids: [1642]
                        )
                      ]
                    )
                  ]
                  spids: [1626 1639]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {<-n>} {(DQ ($ Id.VSub_DollarName '$s'))} 
                              {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:s)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_DollarName '$flags_color') ($ Id.VSub_DollarName '$s'))}
                          spids: [1668]
                        )
                      ]
                    )
                  ]
                  spids: [1652 1665]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {<-n>} {(DQ ($ Id.VSub_DollarName '$u'))} 
                              {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:u)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_DollarName '$bad_color') ($ Id.VSub_DollarName '$u'))}
                          spids: [1694]
                        )
                      ]
                    )
                  ]
                  spids: [1678 1691]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:r)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_DollarName '$c_clear') ($ Id.VSub_DollarName '$r'))}
                  spids: [1704]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: __git_eread
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'f='> (DQ ($ Id.VSub_Number '$1'))})
            (C {<shift>})
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<test>} {<-r>} {(DQ ($ Id.VSub_DollarName '$f'))})
                (command.Simple
                  words: [{<read>} {(DQ ($ Id.VSub_At '$@'))}]
                  redirects: [
                    (redir
                      op: <Id.Redir_Less '<'>
                      loc: (redir_loc.Fd fd:0)
                      arg: {(DQ ($ Id.VSub_DollarName '$f'))}
                    )
                  ]
                  do_fork: T
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: __git_ps1
      body: 
        (BraceGroup
          children: [
            (C {<local>} {<Id.Lit_VarLike 'exit='> ($ Id.VSub_QMark '$?')})
            (C {<local>} {<Id.Lit_VarLike 'pcmode='> <no>})
            (C {<local>} {<Id.Lit_VarLike 'detached='> <no>})
            (C {<local>} {<Id.Lit_VarLike 'ps1pc_start='> (SQ <'\\u@\\h:\\w '>)})
            (C {<local>} {<Id.Lit_VarLike 'ps1pc_end='> (SQ <'\\$ '>)})
            (C {<local>} {<Id.Lit_VarLike 'printf_format='> (SQ <' (%s)'>)})
            (command.Case
              to_match: {(DQ ($ Id.VSub_Pound '$#'))}
              arms: [
                (case_arm
                  pat_list: [{<2>} {<3>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:pcmode)
                          op: assign_op.Equal
                          rhs: {<yes>}
                          spids: [1858]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:ps1pc_start)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_Number '$1'))}
                          spids: [1862]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:ps1pc_end)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_Number '$2'))}
                          spids: [1868]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:printf_format)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Number 3>
                                  suffix_op: 
                                    (suffix_op.Unary
                                      tok: <Id.VTest_ColonHyphen ':-'>
                                      arg_word: {($ Id.VSub_DollarName '$printf_format')}
                                    )
                                )
                              )
                            }
                          spids: [1874]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:PS1)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ ($ Id.VSub_DollarName '$ps1pc_start') 
                                ($ Id.VSub_DollarName '$ps1pc_end')
                              )
                            }
                          spids: [1896]
                        )
                      ]
                    )
                  ]
                  spids: [1853 1856 1903 -1]
                )
                (case_arm
                  pat_list: [{<0>} {<1>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:printf_format)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Number 1>
                                  suffix_op: 
                                    (suffix_op.Unary
                                      tok: <Id.VTest_ColonHyphen ':-'>
                                      arg_word: {($ Id.VSub_DollarName '$printf_format')}
                                    )
                                )
                              )
                            }
                          spids: [1911]
                        )
                      ]
                    )
                  ]
                  spids: [1906 1909 1921 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {($ Id.VSub_DollarName '$exit')}
                    )
                  ]
                  spids: [1924 1925 1932 -1]
                )
              ]
            )
            (C {<local>} {<Id.Lit_VarLike 'ps1_expanded='> <yes>})
            (command.AndOr
              ops: [Id.Op_DPipe Id.Op_DPipe]
              children: [
                (C {<Id.Lit_LBracket '['>} {<-z>} 
                  {
                    (DQ 
                      (braced_var_sub
                        token: <Id.VSub_Name ZSH_VERSION>
                        suffix_op: (suffix_op.Unary tok:<Id.VTest_Hyphen -> arg_word:(word.Empty))
                      )
                    )
                  } {<Id.Lit_RBracket ']'>}
                )
                (command.DBracket
                  expr: (bool_expr.Unary op_id:Id.BoolUnary_o child:{<PROMPT_SUBST>})
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:ps1_expanded)
                      op: assign_op.Equal
                      rhs: {<no>}
                      spids: [2102]
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe Id.Op_DPipe]
              children: [
                (C {<Id.Lit_LBracket '['>} {<-z>} 
                  {
                    (DQ 
                      (braced_var_sub
                        token: <Id.VSub_Name BASH_VERSION>
                        suffix_op: (suffix_op.Unary tok:<Id.VTest_Hyphen -> arg_word:(word.Empty))
                      )
                    )
                  } {<Id.Lit_RBracket ']'>}
                )
                (C {<shopt>} {<-q>} {<promptvars>})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:ps1_expanded)
                      op: assign_op.Equal
                      rhs: {<no>}
                      spids: [2129]
                    )
                  ]
                )
              ]
            )
            (C {<local>} {<repo_info>} {<rev_parse_exit_code>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:repo_info)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ 
                        (command_sub
                          left_token: <Id.Left_DollarParen '$('>
                          child: 
                            (command.Simple
                              words: [
                                {<git>}
                                {<rev-parse>}
                                {<--git-dir>}
                                {<--is-inside-git-dir>}
                                {<--is-bare-repository>}
                                {<--is-inside-work-tree>}
                                {<--short>}
                                {<HEAD>}
                              ]
                              redirects: [
                                (redir
                                  op: <Id.Redir_Great '2>'>
                                  loc: (redir_loc.Fd fd:2)
                                  arg: {<'/dev/null'>}
                                )
                              ]
                              do_fork: T
                            )
                        )
                      )
                    }
                  spids: [2141]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:rev_parse_exit_code)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_QMark '$?'))}
                  spids: [2170]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {<-z>} {(DQ ($ Id.VSub_DollarName '$repo_info'))} 
                              {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {($ Id.VSub_DollarName '$exit')}
                    )
                  ]
                  spids: [2177 2190]
                )
              ]
            )
            (C {<local>} {<Id.Lit_VarLike 'short_sha='> (DQ )})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} 
                              {(DQ ($ Id.VSub_DollarName '$rev_parse_exit_code'))} {<Id.Lit_Equals '='>} {(DQ <0>)} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:short_sha)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name repo_info>
                                  suffix_op: 
                                    (suffix_op.Unary
                                      tok: <Id.VOp1_DPound '##'>
                                      arg_word: 
                                        {<Id.Lit_Other '*'> 
                                          (single_quoted
                                            left: <Id.Left_DollarSingleQuote '$\''>
                                            tokens: [<Id.Char_OneChar '\\n'>]
                                            multiline: F
                                          )
                                        }
                                    )
                                )
                              )
                            }
                          spids: [2229]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:repo_info)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name repo_info>
                                  suffix_op: 
                                    (suffix_op.Unary
                                      tok: <Id.VOp1_Percent '%'>
                                      arg_word: 
                                        {
                                          (single_quoted
                                            left: <Id.Left_DollarSingleQuote '$\''>
                                            tokens: [<Id.Char_OneChar '\\n'>]
                                            multiline: F
                                          ) <Id.Lit_Other '*'>
                                        }
                                    )
                                )
                              )
                            }
                          spids: [2242]
                        )
                      ]
                    )
                  ]
                  spids: [2209 2226]
                )
              ]
            )
            (C {<local>} 
              {<Id.Lit_VarLike 'inside_worktree='> 
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name repo_info>
                    suffix_op: 
                      (suffix_op.Unary
                        tok: <Id.VOp1_DPound '##'>
                        arg_word: 
                          {<Id.Lit_Other '*'> 
                            (single_quoted
                              left: <Id.Left_DollarSingleQuote '$\''>
                              tokens: [<Id.Char_OneChar '\\n'>]
                              multiline: F
                            )
                          }
                      )
                  )
                )
              }
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:repo_info)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ 
                        (braced_var_sub
                          token: <Id.VSub_Name repo_info>
                          suffix_op: 
                            (suffix_op.Unary
                              tok: <Id.VOp1_Percent '%'>
                              arg_word: 
                                {
                                  (single_quoted
                                    left: <Id.Left_DollarSingleQuote '$\''>
                                    tokens: [<Id.Char_OneChar '\\n'>]
                                    multiline: F
                                  ) <Id.Lit_Other '*'>
                                }
                            )
                        )
                      )
                    }
                  spids: [2273]
                )
              ]
            )
            (C {<local>} 
              {<Id.Lit_VarLike 'bare_repo='> 
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name repo_info>
                    suffix_op: 
                      (suffix_op.Unary
                        tok: <Id.VOp1_DPound '##'>
                        arg_word: 
                          {<Id.Lit_Other '*'> 
                            (single_quoted
                              left: <Id.Left_DollarSingleQuote '$\''>
                              tokens: [<Id.Char_OneChar '\\n'>]
                              multiline: F
                            )
                          }
                      )
                  )
                )
              }
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:repo_info)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (DQ 
                        (braced_var_sub
                          token: <Id.VSub_Name repo_info>
                          suffix_op: 
                            (suffix_op.Unary
                              tok: <Id.VOp1_Percent '%'>
                              arg_word: 
                                {
                                  (single_quoted
                                    left: <Id.Left_DollarSingleQuote '$\''>
                                    tokens: [<Id.Char_OneChar '\\n'>]
                                    multiline: F
                                  ) <Id.Lit_Other '*'>
                                }
                            )
                        )
                      )
                    }
                  spids: [2301]
                )
              ]
            )
            (C {<local>} 
              {<Id.Lit_VarLike 'inside_gitdir='> 
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name repo_info>
                    suffix_op: 
                      (suffix_op.Unary
                        tok: <Id.VOp1_DPound '##'>
                        arg_word: 
                          {<Id.Lit_Other '*'> 
                            (single_quoted
                              left: <Id.Left_DollarSingleQuote '$\''>
                              tokens: [<Id.Char_OneChar '\\n'>]
                              multiline: F
                            )
                          }
                      )
                  )
                )
              }
            )
            (C {<local>} 
              {<Id.Lit_VarLike 'g='> 
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name repo_info>
                    suffix_op: 
                      (suffix_op.Unary
                        tok: <Id.VOp1_Percent '%'>
                        arg_word: 
                          {
                            (single_quoted
                              left: <Id.Left_DollarSingleQuote '$\''>
                              tokens: [<Id.Char_OneChar '\\n'>]
                              multiline: F
                            ) <Id.Lit_Other '*'>
                          }
                      )
                  )
                )
              }
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.AndOr
                          ops: [Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp]
                          children: [
                            (C {<Id.Lit_LBracket '['>} {(DQ <true>)} {<Id.Lit_Equals '='>} 
                              {(DQ ($ Id.VSub_DollarName '$inside_worktree'))} {<Id.Lit_RBracket ']'>}
                            )
                            (C {<Id.Lit_LBracket '['>} {<-n>} 
                              {
                                (DQ 
                                  (braced_var_sub
                                    token: <Id.VSub_Name GIT_PS1_HIDE_IF_PWD_IGNORED>
                                    suffix_op: (suffix_op.Unary tok:<Id.VTest_Hyphen -> arg_word:(word.Empty))
                                  )
                                )
                              } {<Id.Lit_RBracket ']'>}
                            )
                            (C {<Id.Lit_LBracket '['>} 
                              {
                                (DQ 
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: (C {<git>} {<config>} {<--bool>} {<bash.hideIfPwdIgnored>})
                                  )
                                )
                              } {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ <false>)} {<Id.Lit_RBracket ']'>}
                            )
                            (C {<git>} {<check-ignore>} {<-q>} {<.>})
                          ]
                        )
                      ]
                    )
                  action: [
                    (command.ControlFlow
                      token: <Id.ControlFlow_Return return>
                      arg_word: {($ Id.VSub_DollarName '$exit')}
                    )
                  ]
                  spids: [2345 2415]
                )
              ]
            )
            (C {<local>} {<Id.Lit_VarLike 'r='> (DQ )})
            (C {<local>} {<Id.Lit_VarLike 'b='> (DQ )})
            (C {<local>} {<Id.Lit_VarLike 'step='> (DQ )})
            (C {<local>} {<Id.Lit_VarLike 'total='> (DQ )})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {<-d>} 
                              {(DQ ($ Id.VSub_DollarName '$g') <'/rebase-merge'>)} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (C {<__git_eread>} {(DQ ($ Id.VSub_DollarName '$g') <'/rebase-merge/head-name'>)} 
                      {<b>}
                    )
                    (C {<__git_eread>} {(DQ ($ Id.VSub_DollarName '$g') <'/rebase-merge/msgnum'>)} 
                      {<step>}
                    )
                    (C {<__git_eread>} {(DQ ($ Id.VSub_DollarName '$g') <'/rebase-merge/end'>)} 
                      {<total>}
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<Id.Lit_LBracket '['>} {<-f>} 
                                      {(DQ ($ Id.VSub_DollarName '$g') <'/rebase-merge/interactive'>)} {<Id.Lit_RBracket ']'>}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:r)
                                  op: assign_op.Equal
                                  rhs: {(DQ <'|REBASE-i'>)}
                                  spids: [2519]
                                )
                              ]
                            )
                          ]
                          spids: [2502 2516]
                        )
                      ]
                      else_action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:r)
                              op: assign_op.Equal
                              rhs: {(DQ <'|REBASE-m'>)}
                              spids: [2528]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [2455 2469]
                )
              ]
              else_action: [
                (command.If
                  arms: [
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (command.Sentence
                              child: 
                                (C {<Id.Lit_LBracket '['>} {<-d>} 
                                  {(DQ ($ Id.VSub_DollarName '$g') <'/rebase-apply'>)} {<Id.Lit_RBracket ']'>}
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                      action: [
                        (C {<__git_eread>} {(DQ ($ Id.VSub_DollarName '$g') <'/rebase-apply/next'>)} 
                          {<step>}
                        )
                        (C {<__git_eread>} {(DQ ($ Id.VSub_DollarName '$g') <'/rebase-apply/last'>)} 
                          {<total>}
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.Sentence
                                      child: 
                                        (C {<Id.Lit_LBracket '['>} {<-f>} 
                                          {
                                            (DQ ($ Id.VSub_DollarName '$g') <'/rebase-apply/rebasing'>)
                                          } {<Id.Lit_RBracket ']'>}
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                )
                              action: [
                                (C {<__git_eread>} 
                                  {(DQ ($ Id.VSub_DollarName '$g') <'/rebase-apply/head-name'>)} {<b>}
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:r)
                                      op: assign_op.Equal
                                      rhs: {(DQ <'|REBASE'>)}
                                      spids: [2604]
                                    )
                                  ]
                                )
                              ]
                              spids: [2577 2591]
                            )
                            (if_arm
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.Sentence
                                      child: 
                                        (C {<Id.Lit_LBracket '['>} {<-f>} 
                                          {
                                            (DQ ($ Id.VSub_DollarName '$g') <'/rebase-apply/applying'>)
                                          } {<Id.Lit_RBracket ']'>}
                                        )
                                      terminator: <Id.Op_Semi _>
                                    )
                                  ]
                                )
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:r)
                                      op: assign_op.Equal
                                      rhs: {(DQ <'|AM'>)}
                                      spids: [2627]
                                    )
                                  ]
                                )
                              ]
                              spids: [2610 2624]
                            )
                          ]
                          else_action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:r)
                                  op: assign_op.Equal
                                  rhs: {(DQ <'|AM/REBASE'>)}
                                  spids: [2636]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                      spids: [2540 2554]
                    )
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (command.Sentence
                              child: 
                                (C {<Id.Lit_LBracket '['>} {<-f>} 
                                  {(DQ ($ Id.VSub_DollarName '$g') <'/MERGE_HEAD'>)} {<Id.Lit_RBracket ']'>}
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:r)
                              op: assign_op.Equal
                              rhs: {(DQ <'|MERGING'>)}
                              spids: [2662]
                            )
                          ]
                        )
                      ]
                      spids: [2645 2659]
                    )
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (command.Sentence
                              child: 
                                (C {<Id.Lit_LBracket '['>} {<-f>} 
                                  {(DQ ($ Id.VSub_DollarName '$g') <'/CHERRY_PICK_HEAD'>)} {<Id.Lit_RBracket ']'>}
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:r)
                              op: assign_op.Equal
                              rhs: {(DQ <'|CHERRY-PICKING'>)}
                              spids: [2685]
                            )
                          ]
                        )
                      ]
                      spids: [2668 2682]
                    )
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (command.Sentence
                              child: 
                                (C {<Id.Lit_LBracket '['>} {<-f>} 
                                  {(DQ ($ Id.VSub_DollarName '$g') <'/REVERT_HEAD'>)} {<Id.Lit_RBracket ']'>}
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:r)
                              op: assign_op.Equal
                              rhs: {(DQ <'|REVERTING'>)}
                              spids: [2708]
                            )
                          ]
                        )
                      ]
                      spids: [2691 2705]
                    )
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (command.Sentence
                              child: 
                                (C {<Id.Lit_LBracket '['>} {<-f>} 
                                  {(DQ ($ Id.VSub_DollarName '$g') <'/BISECT_LOG'>)} {<Id.Lit_RBracket ']'>}
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:r)
                              op: assign_op.Equal
                              rhs: {(DQ <'|BISECTING'>)}
                              spids: [2731]
                            )
                          ]
                        )
                      ]
                      spids: [2714 2728]
                    )
                  ]
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (command.Sentence
                              child: 
                                (C {<Id.Lit_LBracket '['>} {<-n>} {(DQ ($ Id.VSub_DollarName '$b'))} 
                                  {<Id.Lit_RBracket ']'>}
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                      action: [(C {<Id.Lit_Colon ':'>})]
                      spids: [2741 2754]
                    )
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (command.Sentence
                              child: 
                                (C {<Id.Lit_LBracket '['>} {<-h>} 
                                  {(DQ ($ Id.VSub_DollarName '$g') <'/HEAD'>)} {<Id.Lit_RBracket ']'>}
                                )
                              terminator: <Id.Op_Semi _>
                            )
                          ]
                        )
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:b)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (DQ 
                                    (command_sub
                                      left_token: <Id.Left_DollarParen '$('>
                                      child: 
                                        (command.Simple
                                          words: [{<git>} {<symbolic-ref>} {<HEAD>}]
                                          redirects: [
                                            (redir
                                              op: <Id.Redir_Great '2>'>
                                              loc: (redir_loc.Fd fd:2)
                                              arg: {<'/dev/null'>}
                                            )
                                          ]
                                          do_fork: T
                                        )
                                    )
                                  )
                                }
                              spids: [2781]
                            )
                          ]
                        )
                      ]
                      spids: [2760 2774]
                    )
                  ]
                  else_action: [
                    (C {<local>} {<Id.Lit_VarLike 'head='> (DQ )})
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (command.Pipeline
                                      children: [
                                        (C {<__git_eread>} {(DQ ($ Id.VSub_DollarName '$g') <'/HEAD'>)} 
                                          {<head>}
                                        )
                                      ]
                                      negated: T
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.ControlFlow
                              token: <Id.ControlFlow_Return return>
                              arg_word: {($ Id.VSub_DollarName '$exit')}
                            )
                          ]
                          spids: [2806 2820]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:b)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ 
                                (braced_var_sub
                                  token: <Id.VSub_Name head>
                                  suffix_op: 
                                    (suffix_op.Unary
                                      tok: <Id.VOp1_Pound '#'>
                                      arg_word: {<'ref: '>}
                                    )
                                )
                              )
                            }
                          spids: [2835]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<Id.Lit_LBracket '['>} {(DQ ($ Id.VSub_DollarName '$head'))} 
                                      {<Id.Lit_Equals '='>} {(DQ ($ Id.VSub_DollarName '$b'))} {<Id.Lit_RBracket ']'>}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:detached)
                                  op: assign_op.Equal
                                  rhs: {<yes>}
                                  spids: [2865]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:b)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (DQ 
                                            (command_sub
                                              left_token: <Id.Left_DollarParen '$('>
                                              child: 
                                                (command.Case
                                                  to_match: 
                                                    {
                                                      (DQ 
                                                        (braced_var_sub
                                                          token: 
                                                            <Id.VSub_Name GIT_PS1_DESCRIBE_STYLE>
                                                          suffix_op: 
                                                            (suffix_op.Unary
                                                              tok: <Id.VTest_Hyphen ->
                                                              arg_word: (word.Empty)
                                                            )
                                                        )
                                                      )
                                                    }
                                                  arms: [
                                                    (case_arm
                                                      pat_list: [{<contains>}]
                                                      action: [
                                                        (C {<git>} {<describe>} {<--contains>} {<HEAD>})
                                                      ]
                                                      spids: [2886 2888 2899 -1]
                                                    )
                                                    (case_arm
                                                      pat_list: [{<branch>}]
                                                      action: [
                                                        (C {<git>} {<describe>} {<--contains>} {<--all>} 
                                                          {<HEAD>}
                                                        )
                                                      ]
                                                      spids: [2902 2904 2917 -1]
                                                    )
                                                    (case_arm
                                                      pat_list: [{<describe>}]
                                                      action: [(C {<git>} {<describe>} {<HEAD>})]
                                                      spids: [2920 2922 2931 -1]
                                                    )
                                                    (case_arm
                                                      pat_list: [{<Id.Lit_Star '*'>} {<default>}]
                                                      action: [
                                                        (C {<git>} {<describe>} {<--tags>} 
                                                          {<--exact-match>} {<HEAD>}
                                                        )
                                                      ]
                                                      spids: [2934 2940 2953 -1]
                                                    )
                                                  ]
                                                  redirects: [
                                                    (redir
                                                      op: <Id.Redir_Great '2>'>
                                                      loc: (redir_loc.Fd fd:2)
                                                      arg: {<'/dev/null'>}
                                                    )
                                                  ]
                                                )
                                            )
                                          )
                                        }
                                      spids: [2869]
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:b)
                                      op: assign_op.Equal
                                      rhs: {(DQ ($ Id.VSub_DollarName '$short_sha') <...>)}
                                      spids: [2967]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:b)
                                  op: assign_op.Equal
                                  rhs: {(DQ <'('> ($ Id.VSub_DollarName '$b') <')'>)}
                                  spids: [2974]
                                )
                              ]
                            )
                          ]
                          spids: [2845 2862]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<Id.Lit_LBracket '['>} {<-n>} {(DQ ($ Id.VSub_DollarName '$step'))} 
                                  {<Id.Lit_RBracket ']'>}
                                )
                                (C {<Id.Lit_LBracket '['>} {<-n>} {(DQ ($ Id.VSub_DollarName '$total'))} 
                                  {<Id.Lit_RBracket ']'>}
                                )
                              ]
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:r)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ ($ Id.VSub_DollarName '$r') <' '> ($ Id.VSub_DollarName '$step') <'/'> 
                                ($ Id.VSub_DollarName '$total')
                              )
                            }
                          spids: [3020]
                        )
                      ]
                    )
                  ]
                  spids: [2992 3017]
                )
              ]
            )
            (C {<local>} {<Id.Lit_VarLike 'w='> (DQ )})
            (C {<local>} {<Id.Lit_VarLike 'i='> (DQ )})
            (C {<local>} {<Id.Lit_VarLike 's='> (DQ )})
            (C {<local>} {<Id.Lit_VarLike 'u='> (DQ )})
            (C {<local>} {<Id.Lit_VarLike 'c='> (DQ )})
            (C {<local>} {<Id.Lit_VarLike 'p='> (DQ )})
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {(DQ <true>)} {<Id.Lit_Equals '='>} 
                              {(DQ ($ Id.VSub_DollarName '$inside_gitdir'))} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<Id.Lit_LBracket '['>} {(DQ <true>)} {<Id.Lit_Equals '='>} 
                                      {(DQ ($ Id.VSub_DollarName '$bare_repo'))} {<Id.Lit_RBracket ']'>}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:c)
                                  op: assign_op.Equal
                                  rhs: {(DQ <'BARE:'>)}
                                  spids: [3117]
                                )
                              ]
                            )
                          ]
                          spids: [3097 3114]
                        )
                      ]
                      else_action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:b)
                              op: assign_op.Equal
                              rhs: {(DQ <'GIT_DIR!'>)}
                              spids: [3126]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [3077 3094]
                )
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {(DQ <true>)} {<Id.Lit_Equals '='>} 
                              {(DQ ($ Id.VSub_DollarName '$inside_worktree'))} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.AndOr
                                  ops: [Id.Op_DAmp]
                                  children: [
                                    (C {<Id.Lit_LBracket '['>} {<-n>} 
                                      {
                                        (DQ 
                                          (braced_var_sub
                                            token: <Id.VSub_Name GIT_PS1_SHOWDIRTYSTATE>
                                            suffix_op: (suffix_op.Unary tok:<Id.VTest_Hyphen -> arg_word:(word.Empty))
                                          )
                                        )
                                      } {<Id.Lit_RBracket ']'>}
                                    )
                                    (C {<Id.Lit_LBracket '['>} 
                                      {
                                        (DQ 
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            child: 
                                              (C {<git>} {<config>} {<--bool>} {<bash.showDirtyState>})
                                          )
                                        )
                                      } {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ <false>)} {<Id.Lit_RBracket ']'>}
                                    )
                                  ]
                                )
                              ]
                            )
                          action: [
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (C {<git>} {<diff>} {<--no-ext-diff>} {<--quiet>})
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:w)
                                      op: assign_op.Equal
                                      rhs: {(DQ <'*'>)}
                                      spids: [3210]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (C {<git>} {<diff>} {<--no-ext-diff>} {<--cached>} {<--quiet>})
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:i)
                                      op: assign_op.Equal
                                      rhs: {(DQ <'+'>)}
                                      spids: [3228]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Sentence
                                          child: 
                                            (command.AndOr
                                              ops: [Id.Op_DAmp]
                                              children: [
                                                (C {<Id.Lit_LBracket '['>} {<-z>} 
                                                  {(DQ ($ Id.VSub_DollarName '$short_sha'))} {<Id.Lit_RBracket ']'>}
                                                )
                                                (C {<Id.Lit_LBracket '['>} {<-z>} 
                                                  {(DQ ($ Id.VSub_DollarName '$i'))} {<Id.Lit_RBracket ']'>}
                                                )
                                              ]
                                            )
                                          terminator: <Id.Op_Semi _>
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:i)
                                          op: assign_op.Equal
                                          rhs: {(DQ <'#'>)}
                                          spids: [3262]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [3234 3259]
                                )
                              ]
                            )
                          ]
                          spids: [3155 3197]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.AndOr
                                  ops: [Id.Op_DAmp]
                                  children: [
                                    (C {<Id.Lit_LBracket '['>} {<-n>} 
                                      {
                                        (DQ 
                                          (braced_var_sub
                                            token: <Id.VSub_Name GIT_PS1_SHOWSTASHSTATE>
                                            suffix_op: (suffix_op.Unary tok:<Id.VTest_Hyphen -> arg_word:(word.Empty))
                                          )
                                        )
                                      } {<Id.Lit_RBracket ']'>}
                                    )
                                    (command.Simple
                                      words: [
                                        {<git>}
                                        {<rev-parse>}
                                        {<--verify>}
                                        {<--quiet>}
                                        {<'refs/stash'>}
                                      ]
                                      redirects: [
                                        (redir
                                          op: <Id.Redir_Great '>'>
                                          loc: (redir_loc.Fd fd:1)
                                          arg: {<'/dev/null'>}
                                        )
                                      ]
                                      do_fork: T
                                    )
                                  ]
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:s)
                                  op: assign_op.Equal
                                  rhs: {(DQ <Id.Lit_Dollar '$'>)}
                                  spids: [3309]
                                )
                              ]
                            )
                          ]
                          spids: [3274 3306]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.AndOr
                                  ops: [Id.Op_DAmp Id.Op_DAmp]
                                  children: [
                                    (C {<Id.Lit_LBracket '['>} {<-n>} 
                                      {
                                        (DQ 
                                          (braced_var_sub
                                            token: <Id.VSub_Name GIT_PS1_SHOWUNTRACKEDFILES>
                                            suffix_op: (suffix_op.Unary tok:<Id.VTest_Hyphen -> arg_word:(word.Empty))
                                          )
                                        )
                                      } {<Id.Lit_RBracket ']'>}
                                    )
                                    (C {<Id.Lit_LBracket '['>} 
                                      {
                                        (DQ 
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            child: 
                                              (C {<git>} {<config>} {<--bool>} 
                                                {<bash.showUntrackedFiles>}
                                              )
                                          )
                                        )
                                      } {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ <false>)} {<Id.Lit_RBracket ']'>}
                                    )
                                    (command.Simple
                                      words: [
                                        {<git>}
                                        {<ls-files>}
                                        {<--others>}
                                        {<--exclude-standard>}
                                        {<--directory>}
                                        {<--no-empty-directory>}
                                        {<--error-unmatch>}
                                        {<-->}
                                        {(SQ <':/*'>)}
                                      ]
                                      redirects: [
                                        (redir
                                          op: <Id.Redir_Great '>'>
                                          loc: (redir_loc.Fd fd:1)
                                          arg: {<'/dev/null'>}
                                        )
                                        (redir
                                          op: <Id.Redir_Great '2>'>
                                          loc: (redir_loc.Fd fd:2)
                                          arg: {<'/dev/null'>}
                                        )
                                      ]
                                      do_fork: T
                                    )
                                  ]
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:u)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ <'%'> 
                                        (braced_var_sub
                                          token: <Id.VSub_Name ZSH_VERSION>
                                          suffix_op: 
                                            (suffix_op.Unary
                                              tok: <Id.VTest_Plus '+'>
                                              arg_word: {<Id.Lit_Percent '%'>}
                                            )
                                        )
                                      )
                                    }
                                  spids: [3393]
                                )
                              ]
                            )
                          ]
                          spids: [3319 3390]
                        )
                      ]
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<Id.Lit_LBracket '['>} {<-n>} 
                                      {
                                        (DQ 
                                          (braced_var_sub
                                            token: <Id.VSub_Name GIT_PS1_SHOWUPSTREAM>
                                            suffix_op: (suffix_op.Unary tok:<Id.VTest_Hyphen -> arg_word:(word.Empty))
                                          )
                                        )
                                      } {<Id.Lit_RBracket ']'>}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [(C {<__git_ps1_show_upstream>})]
                          spids: [3408 3424]
                        )
                      ]
                    )
                  ]
                  spids: [3135 3152]
                )
              ]
            )
            (C {<local>} 
              {<Id.Lit_VarLike 'z='> 
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name GIT_PS1_STATESEPARATOR>
                    suffix_op: (suffix_op.Unary tok:<Id.VTest_Hyphen -> arg_word:{(DQ <' '>)})
                  )
                )
              }
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<Id.Lit_LBracket '['>} {($ Id.VSub_DollarName '$pcmode')} 
                                  {<Id.Lit_Equals '='>} {<yes>} {<Id.Lit_RBracket ']'>}
                                )
                                (C {<Id.Lit_LBracket '['>} {<-n>} 
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: <Id.VSub_Name GIT_PS1_SHOWCOLORHINTS>
                                        suffix_op: (suffix_op.Unary tok:<Id.VTest_Hyphen -> arg_word:(word.Empty))
                                      )
                                    )
                                  } {<Id.Lit_RBracket ']'>}
                                )
                              ]
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<__git_ps1_colorize_gitstring>})]
                  spids: [3456 3484]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:b)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (braced_var_sub
                        token: <Id.VSub_Name b>
                        suffix_op: 
                          (suffix_op.Unary
                            tok: <Id.VOp1_DPound '##'>
                            arg_word: {<refs> <Id.Lit_Slash '/'> <heads> <Id.Lit_Slash '/'>}
                          )
                      )
                    }
                  spids: [3494]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<Id.Lit_LBracket '['>} {($ Id.VSub_DollarName '$pcmode')} 
                                  {<Id.Lit_Equals '='>} {<yes>} {<Id.Lit_RBracket ']'>}
                                )
                                (C {<Id.Lit_LBracket '['>} {($ Id.VSub_DollarName '$ps1_expanded')} 
                                  {<Id.Lit_Equals '='>} {<yes>} {<Id.Lit_RBracket ']'>}
                                )
                              ]
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:__git_ps1_branch_name)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName '$b')}
                          spids: [3533]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:b)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) 
                                <'{__git_ps1_branch_name}'>
                              )
                            }
                          spids: [3537]
                        )
                      ]
                    )
                  ]
                  spids: [3505 3530]
                )
              ]
            )
            (C {<local>} 
              {<Id.Lit_VarLike 'f='> 
                (DQ ($ Id.VSub_DollarName '$w') ($ Id.VSub_DollarName '$i') ($ Id.VSub_DollarName '$s') 
                  ($ Id.VSub_DollarName '$u')
                )
              }
            )
            (C {<local>} 
              {<Id.Lit_VarLike 'gitstring='> 
                (DQ ($ Id.VSub_DollarName '$c') ($ Id.VSub_DollarName '$b') 
                  (braced_var_sub
                    token: <Id.VSub_Name f>
                    suffix_op: 
                      (suffix_op.Unary
                        tok: <Id.VTest_ColonPlus ':+'>
                        arg_word: {($ Id.VSub_DollarName '$z') ($ Id.VSub_DollarName '$f')}
                      )
                  ) ($ Id.VSub_DollarName '$r') ($ Id.VSub_DollarName '$p')
                )
              }
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (C {<Id.Lit_LBracket '['>} {($ Id.VSub_DollarName '$pcmode')} 
                              {<Id.Lit_Equals '='>} {<yes>} {<Id.Lit_RBracket ']'>}
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.Sentence
                                  child: 
                                    (C {<Id.Lit_LBracket '['>} 
                                      {
                                        (DQ 
                                          (braced_var_sub
                                            token: <Id.VSub_Name __git_printf_supports_v>
                                            suffix_op: (suffix_op.Unary tok:<Id.VTest_Hyphen -> arg_word:(word.Empty))
                                          )
                                        )
                                      } {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<yes>} {<Id.Lit_RBracket ']'>}
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:gitstring)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (C {<printf>} {<-->} 
                                            {(DQ ($ Id.VSub_DollarName '$printf_format'))} {(DQ ($ Id.VSub_DollarName '$gitstring'))}
                                          )
                                      )
                                    }
                                  spids: [3615]
                                )
                              ]
                            )
                          ]
                          spids: [3593 3612]
                        )
                      ]
                      else_action: [
                        (C {<printf>} {<-v>} {<gitstring>} {<-->} 
                          {(DQ ($ Id.VSub_DollarName '$printf_format'))} {(DQ ($ Id.VSub_DollarName '$gitstring'))}
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:PS1)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (DQ ($ Id.VSub_DollarName '$ps1pc_start') 
                                ($ Id.VSub_DollarName '$gitstring') ($ Id.VSub_DollarName '$ps1pc_end')
                              )
                            }
                          spids: [3654]
                        )
                      ]
                    )
                  ]
                  spids: [3577 3590]
                )
              ]
              else_action: [
                (C {<printf>} {<-->} {(DQ ($ Id.VSub_DollarName '$printf_format'))} 
                  {(DQ ($ Id.VSub_DollarName '$gitstring'))}
                )
              ]
            )
            (command.ControlFlow
              token: <Id.ControlFlow_Return return>
              arg_word: {($ Id.VSub_DollarName '$exit')}
            )
          ]
        )
    )
  ]
)