(command.CommandList
  children: [
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'USAGE='> name:USAGE)
          op: assign_op.Equal
          rhs: {(SQ <'<start> <url> [<end>]'>)}
          spids: [16]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'LONG_USAGE='> name:LONG_USAGE)
          op: assign_op.Equal
          rhs: 
            {
              (SQ <'Summarizes the changes between two commits to the standard output,\n'> 
                <'and includes the given URL in the generated summary.'>
              )
            }
          spids: [21]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'SUBDIRECTORY_OK='> name:SUBDIRECTORY_OK)
          op: assign_op.Equal
          rhs: {(SQ <Yes>)}
          spids: [27]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: 
            (sh_lhs_expr.Name
              left: <Id.Lit_VarLike 'OPTIONS_KEEPDASHDASH='>
              name: OPTIONS_KEEPDASHDASH
            )
          op: assign_op.Equal
          rhs: (rhs_word.Empty)
          spids: [32]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'OPTIONS_STUCKLONG='> name:OPTIONS_STUCKLONG)
          op: assign_op.Equal
          rhs: (rhs_word.Empty)
          spids: [34]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'OPTIONS_SPEC='> name:OPTIONS_SPEC)
          op: assign_op.Equal
          rhs: 
            {
              (SQ <'git request-pull [options] start url [end]\n'> <'--\n'> 
                <'p    show patch text as well\n'>
              )
            }
          spids: [36]
        )
      ]
      redirects: []
    )
    (C {<.>} {<git-sh-setup>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'GIT_PAGER='> name:GIT_PAGER)
          op: assign_op.Equal
          rhs: (rhs_word.Empty)
          spids: [49]
        )
      ]
      redirects: []
    )
    (C {<export>} {<GIT_PAGER>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'patch='> name:patch)
          op: assign_op.Equal
          rhs: (rhs_word.Empty)
          spids: [56]
        )
      ]
      redirects: []
    )
    (command.WhileUntil
      keyword: <Id.KW_While while>
      cond: 
        (condition.Shell
          commands: [
            (command.Case
              to_match: {(DQ ($ Id.VSub_Pound '#'))}
              arms: [
                (case_arm
                  pat_list: [{<0>}]
                  action: [(command.ControlFlow token:<Id.ControlFlow_Break break>)]
                  spids: [68 69 73 -1]
                )
              ]
              redirects: []
            )
          ]
        )
      body: 
        (command.DoGroup
          children: [
            (command.Case
              to_match: {(DQ ($ Id.VSub_Number 1))}
              arms: [
                (case_arm
                  pat_list: [{<-p>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'patch='> name:patch)
                          op: assign_op.Equal
                          rhs: {<-p>}
                          spids: [93]
                        )
                      ]
                      redirects: []
                    )
                  ]
                  spids: [89 90 96 -1]
                )
                (case_arm
                  pat_list: [{<-->}]
                  action: [
                    (command.Sentence
                      child: (C {<shift>})
                      terminator: <Id.Op_Semi _>
                    )
                    (command.ControlFlow token:<Id.ControlFlow_Break break>)
                  ]
                  spids: [99 100 108 -1]
                )
                (case_arm
                  pat_list: [{<-> <Id.Lit_Star '*'>}]
                  action: [(C {<usage>})]
                  spids: [111 113 118 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [(command.ControlFlow token:<Id.ControlFlow_Break break>)]
                  spids: [121 122 127 -1]
                )
              ]
              redirects: []
            )
            (C {<shift>})
          ]
        )
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'base='> name:base)
          op: assign_op.Equal
          rhs: {($ Id.VSub_Number 1)}
          spids: [138]
        )
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'url='> name:url)
          op: assign_op.Equal
          rhs: {($ Id.VSub_Number 2)}
          spids: [141]
        )
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'status='> name:status)
          op: assign_op.Equal
          rhs: {<0>}
          spids: [144]
        )
      ]
      redirects: []
    )
    (command.AndOr
      ops: [Id.Op_DAmp Id.Op_DPipe]
      children: [
        (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName base))})
        (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName url))})
        (C {<usage>})
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'baserev='> name:baserev)
          op: assign_op.Equal
          rhs: 
            {
              (command_sub
                left_token: <Id.Left_DollarParen '$('>
                child: 
                  (C {<git>} {<rev-parse>} {<--verify>} {<--quiet>} 
                    {(DQ ($ Id.VSub_DollarName base)) <Id.Lit_Other '^'> <0>}
                  )
                right: <Id.Eof_RParen _>
              )
            }
          spids: [171]
        )
      ]
      redirects: []
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [(C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName baserev))})]
            )
          action: [(C {<die>} {(DQ <'fatal: Not a valid revision: '> ($ Id.VSub_DollarName base))})]
          spids: [188 198]
        )
      ]
      else_action: []
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'local='> name:local)
          op: assign_op.Equal
          rhs: 
            {
              (braced_var_sub
                left: <Id.Left_DollarBrace '${'>
                token: <Id.VSub_Number 3>
                var_name: 3
                suffix_op: 
                  (suffix_op.Unary
                    op: <Id.VOp1_Percent '%'>
                    arg_word: {<':'> <Id.Lit_Other '*'>}
                  )
                right: <Id.Right_DollarBrace '}'>
              )
            }
          spids: [226]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'local='> name:local)
          op: assign_op.Equal
          rhs: 
            {
              (braced_var_sub
                left: <Id.Left_DollarBrace '${'>
                token: <Id.VSub_Name local>
                var_name: local
                suffix_op: (suffix_op.Unary op:<Id.VTest_ColonHyphen _> arg_word:{<HEAD>})
                right: <Id.Right_DollarBrace '}'>
              )
            }
          spids: [234]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'remote='> name:remote)
          op: assign_op.Equal
          rhs: 
            {
              (braced_var_sub
                left: <Id.Left_DollarBrace '${'>
                token: <Id.VSub_Number 3>
                var_name: 3
                suffix_op: (suffix_op.Unary op:<Id.VOp1_Pound '#'> arg_word:{<Id.Lit_Other '*'> <':'>})
                right: <Id.Right_DollarBrace '}'>
              )
            }
          spids: [241]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'pretty_remote='> name:pretty_remote)
          op: assign_op.Equal
          rhs: 
            {
              (braced_var_sub
                left: <Id.Left_DollarBrace '${'>
                token: <Id.VSub_Name remote>
                var_name: remote
                suffix_op: 
                  (suffix_op.Unary
                    op: <Id.VOp1_Pound '#'>
                    arg_word: {<refs> <Id.Lit_Slash '/'>}
                  )
                right: <Id.Right_DollarBrace '}'>
              )
            }
          spids: [249]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'pretty_remote='> name:pretty_remote)
          op: assign_op.Equal
          rhs: 
            {
              (braced_var_sub
                left: <Id.Left_DollarBrace '${'>
                token: <Id.VSub_Name pretty_remote>
                var_name: pretty_remote
                suffix_op: 
                  (suffix_op.Unary
                    op: <Id.VOp1_Pound '#'>
                    arg_word: {<heads> <Id.Lit_Slash '/'>}
                  )
                right: <Id.Right_DollarBrace '}'>
              )
            }
          spids: [257]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'head='> name:head)
          op: assign_op.Equal
          rhs: 
            {
              (command_sub
                left_token: <Id.Left_DollarParen '$('>
                child: (C {<git>} {<symbolic-ref>} {<-q>} {(DQ ($ Id.VSub_DollarName local))})
                right: <Id.Eof_RParen _>
              )
            }
          spids: [265]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'head='> name:head)
          op: assign_op.Equal
          rhs: 
            {
              (braced_var_sub
                left: <Id.Left_DollarBrace '${'>
                token: <Id.VSub_Name head>
                var_name: head
                suffix_op: 
                  (suffix_op.Unary
                    op: <Id.VTest_ColonHyphen _>
                    arg_word: 
                      {
                        (command_sub
                          left_token: <Id.Left_DollarParen '$('>
                          child: 
                            (command.Pipeline
                              children: [
                                (C {<git>} {<show-ref>} {<--heads>} {<--tags>} 
                                  {(DQ ($ Id.VSub_DollarName local))}
                                )
                                (C {<cut>} {<-d> (SQ <' '>)} {<-f2>})
                              ]
                              negated: F
                              stderr_indices: []
                            )
                          right: <Id.Eof_RParen _>
                        )
                      }
                  )
                right: <Id.Right_DollarBrace '}'>
              )
            }
          spids: [278]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'head='> name:head)
          op: assign_op.Equal
          rhs: 
            {
              (braced_var_sub
                left: <Id.Left_DollarBrace '${'>
                token: <Id.VSub_Name head>
                var_name: head
                suffix_op: 
                  (suffix_op.Unary
                    op: <Id.VTest_ColonHyphen _>
                    arg_word: 
                      {
                        (command_sub
                          left_token: <Id.Left_DollarParen '$('>
                          child: 
                            (C {<git>} {<rev-parse>} {<--quiet>} {<--verify>} 
                              {(DQ ($ Id.VSub_DollarName local))}
                            )
                          right: <Id.Eof_RParen _>
                        )
                      }
                  )
                right: <Id.Right_DollarBrace '}'>
              )
            }
          spids: [308]
        )
      ]
      redirects: []
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName head))})
        (C {<die>} {(DQ <'fatal: Not a valid revision: '> ($ Id.VSub_DollarName local))})
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'headrev='> name:headrev)
          op: assign_op.Equal
          rhs: 
            {
              (command_sub
                left_token: <Id.Left_DollarParen '$('>
                child: 
                  (C {<git>} {<rev-parse>} {<--verify>} {<--quiet>} 
                    {(DQ ($ Id.VSub_DollarName head)) <Id.Lit_Other '^'> <0>}
                  )
                right: <Id.Eof_RParen _>
              )
            }
          spids: [355]
        )
      ]
      redirects: []
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName headrev))})
        (C {<die>} {(DQ <'fatal: Ambiguous revision: '> ($ Id.VSub_DollarName local))})
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'branch_name='> name:branch_name)
          op: assign_op.Equal
          rhs: 
            {
              (braced_var_sub
                left: <Id.Left_DollarBrace '${'>
                token: <Id.VSub_Name head>
                var_name: head
                suffix_op: 
                  (suffix_op.Unary
                    op: <Id.VOp1_Pound '#'>
                    arg_word: {<refs> <Id.Lit_Slash '/'> <heads> <Id.Lit_Slash '/'>}
                  )
                right: <Id.Right_DollarBrace '}'>
              )
            }
          spids: [393]
        )
      ]
      redirects: []
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.AndOr
                  ops: [Id.Op_DPipe]
                  children: [
                    (C {<test>} {(DQ <z> ($ Id.VSub_DollarName branch_name))} {<Id.Lit_Equals '='>} 
                      {(DQ <z> ($ Id.VSub_DollarName headref))}
                    )
                    (command.Pipeline
                      children: [
                        (command.Simple
                          words: [
                            {<git>}
                            {<config>}
                            {(DQ <branch.> ($ Id.VSub_DollarName branch_name) <.description>)}
                          ]
                          redirects: [
                            (redir
                              op: <Id.Redir_Great '>'>
                              loc: (redir_loc.Fd fd:1)
                              arg: {<'/dev/null'>}
                            )
                          ]
                          more_env: []
                          do_fork: T
                        )
                      ]
                      negated: T
                      stderr_indices: []
                    )
                  ]
                )
              ]
            )
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'branch_name='> name:branch_name)
                  op: assign_op.Equal
                  rhs: (rhs_word.Empty)
                  spids: [440]
                )
              ]
              redirects: []
            )
          ]
          spids: [403 437]
        )
      ]
      else_action: []
      redirects: []
    )
    (command.AndOr
      ops: [Id.Op_DPipe]
      children: [
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'merge_base='> name:merge_base)
              op: assign_op.Equal
              rhs: 
                {
                  (command_sub
                    left_token: <Id.Left_DollarParen '$('>
                    child: 
                      (C {<git>} {<merge-base>} {($ Id.VSub_DollarName baserev)} 
                        {($ Id.VSub_DollarName headrev)}
                      )
                    right: <Id.Eof_RParen _>
                  )
                }
              spids: [445]
            )
          ]
          redirects: []
        )
        (C {<die>} 
          {
            (DQ <'fatal: No commits in common between '> ($ Id.VSub_DollarName base) <' and '> 
              ($ Id.VSub_DollarName head)
            )
          }
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'find_matching_ref='> name:find_matching_ref)
          op: assign_op.Equal
          rhs: 
            {
              (SQ <'\n'> <'\tmy ($head,$headrev) = (@ARGV);\n'> <'\tmy ($found);\n'> <'\n'> 
                <'\twhile (<STDIN>) {\n'> <'\t\tchomp;\n'> <'\t\tmy ($sha1, $ref, $deref) = /^(\\S+)\\s+([^^]+)(\\S*)$/;\n'> 
                <'\t\tmy ($pattern);\n'> <'\t\tnext unless ($sha1 eq $headrev);\n'> <'\n'> <'\t\t$pattern="/$head\\$";\n'> 
                <'\t\tif ($ref eq $head) {\n'> <'\t\t\t$found = $ref;\n'> <'\t\t}\n'> <'\t\tif ($ref =~ /$pattern/) {\n'> <'\t\t\t$found = $ref;\n'> 
                <'\t\t}\n'> <'\t\tif ($sha1 eq $head) {\n'> <'\t\t\t$found = $sha1;\n'> <'\t\t}\n'> <'\t}\n'> <'\tif ($found) {\n'> 
                <'\t\tprint "$found\\n";\n'> <'\t}\n'>
              )
            }
          spids: [483]
        )
      ]
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'ref='> name:ref)
          op: assign_op.Equal
          rhs: 
            {
              (command_sub
                left_token: <Id.Left_DollarParen '$('>
                child: 
                  (command.Pipeline
                    children: [
                      (C {<git>} {<ls-remote>} {(DQ ($ Id.VSub_DollarName url))})
                      (C {<Id.Lit_At '@'> <Id.Lit_Splice '@PERL'> <Id.Lit_At '@'> <Id.Lit_At '@'>} 
                        {<-e>} {(DQ ($ Id.VSub_DollarName find_matching_ref))} 
                        {
                          (DQ 
                            (braced_var_sub
                              left: <Id.Left_DollarBrace '${'>
                              token: <Id.VSub_Name remote>
                              var_name: remote
                              suffix_op: 
                                (suffix_op.Unary
                                  op: <Id.VTest_ColonHyphen _>
                                  arg_word: {<HEAD>}
                                )
                              right: <Id.Right_DollarBrace '}'>
                            )
                          )
                        } {(DQ ($ Id.VSub_DollarName headrev))}
                      )
                    ]
                    negated: F
                    stderr_indices: []
                  )
                right: <Id.Eof_RParen _>
              )
            }
          spids: [512]
        )
      ]
      redirects: []
    )
    (command.If
      arms: [
        (if_arm
          cond: (condition.Shell commands:[(C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName ref))})])
          action: [
            (command.Simple
              words: [
                {<echo>}
                {
                  (DQ <'warn: No match for commit '> ($ Id.VSub_DollarName headrev) <' found at '> 
                    ($ Id.VSub_DollarName url)
                  )
                }
              ]
              redirects: [(redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
              more_env: []
              do_fork: T
            )
            (command.Simple
              words: [
                {<echo>}
                {
                  (DQ <'warn: Are you sure you pushed \''> 
                    (braced_var_sub
                      left: <Id.Left_DollarBrace '${'>
                      token: <Id.VSub_Name remote>
                      var_name: remote
                      suffix_op: (suffix_op.Unary op:<Id.VTest_ColonHyphen _> arg_word:{<HEAD>})
                      right: <Id.Right_DollarBrace '}'>
                    ) <'\' there?'>
                  )
                }
              ]
              redirects: [(redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
              more_env: []
              do_fork: T
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'status='> name:status)
                  op: assign_op.Equal
                  rhs: {<1>}
                  spids: [591]
                )
              ]
              redirects: []
            )
          ]
          spids: [549 559]
        )
      ]
      else_action: []
      redirects: []
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (C {<test>} {(DQ ($ Id.VSub_DollarName ref))} {<Id.Lit_Equals '='>} 
                  {(DQ <'refs/tags/'> ($ Id.VSub_DollarName pretty_remote))}
                )
              ]
            )
          action: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'pretty_remote='> name:pretty_remote)
                  op: assign_op.Equal
                  rhs: {<'tags/'> ($ Id.VSub_DollarName pretty_remote)}
                  spids: [618]
                )
              ]
              redirects: []
            )
          ]
          spids: [600 615]
        )
      ]
      else_action: []
      redirects: []
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'url='> name:url)
          op: assign_op.Equal
          rhs: 
            {
              (command_sub
                left_token: <Id.Left_DollarParen '$('>
                child: (C {<git>} {<ls-remote>} {<--get-url>} {(DQ ($ Id.VSub_DollarName url))})
                right: <Id.Eof_RParen _>
              )
            }
          spids: [625]
        )
      ]
      redirects: []
    )
    (command.AndOr
      ops: [Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp Id.Op_DPipe]
      children: [
        (C {<git>} {<show>} {<-s>} 
          {<--format> <Id.Lit_Equals '='> 
            (SQ <'The following changes since commit %H:\n'> <'\n'> <'  %s (%ci)\n'> <'\n'> 
              <'are available in the git repository at:\n'>
            )
          } {($ Id.VSub_DollarName merge_base)}
        )
        (C {<echo>} {(DQ <'  '> ($ Id.VSub_DollarName url) <' '> ($ Id.VSub_DollarName pretty_remote))})
        (C {<git>} {<show>} {<-s>} 
          {<--format> <Id.Lit_Equals '='> 
            (SQ <'\n'> <'for you to fetch changes up to %H:\n'> <'\n'> <'  %s (%ci)\n'> <'\n'> 
              <---------------------------------------------------------------->
            )
          } {($ Id.VSub_DollarName headrev)}
        )
        (command.If
          arms: [
            (if_arm
              cond: 
                (condition.Shell
                  commands: [
                    (C {<test>} 
                      {
                        (command_sub
                          left_token: <Id.Left_DollarParen '$('>
                          child: (C {<git>} {<cat-file>} {<-t>} {(DQ ($ Id.VSub_DollarName head))})
                          right: <Id.Eof_RParen _>
                        )
                      } {<Id.Lit_Equals '='>} {<tag>}
                    )
                  ]
                )
              action: [
                (command.Pipeline
                  children: [
                    (C {<git>} {<cat-file>} {<tag>} {(DQ ($ Id.VSub_DollarName head))})
                    (C {<sed>} {<-n>} {<-e>} {(SQ <'1,/^$/d'>)} {<-e>} {(SQ <'/^-----BEGIN PGP /q'>)} {<-e>} 
                      {<p>}
                    )
                  ]
                  negated: F
                  stderr_indices: []
                )
                (C {<echo>})
                (C {<echo>} {(DQ <---------------------------------------------------------------->)})
              ]
              spids: [692 712]
            )
          ]
          else_action: []
          redirects: []
        )
        (command.If
          arms: [
            (if_arm
              cond: 
                (condition.Shell
                  commands: [(C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName branch_name))})]
                )
              action: [
                (C {<echo>} 
                  {
                    (DQ <'(from the branch description for '> ($ Id.VSub_DollarName branch_name) 
                      <' local branch)'>
                    )
                  }
                )
                (C {<echo>})
                (C {<git>} {<config>} {(DQ <branch.> ($ Id.VSub_DollarName branch_name) <.description>)})
                (C {<echo>} {(DQ <---------------------------------------------------------------->)})
              ]
              spids: [763 773]
            )
          ]
          else_action: []
          redirects: []
        )
        (C {<git>} {<shortlog>} {<Id.Lit_Other '^'> ($ Id.VSub_DollarName baserev)} 
          {($ Id.VSub_DollarName headrev)}
        )
        (C {<git>} {<diff>} {<-M>} {<--stat>} {<--summary>} {($ Id.VSub_DollarName patch)} 
          {($ Id.VSub_DollarName merge_base) <..> ($ Id.VSub_DollarName headrev)}
        )
        (command.ShAssignment
          pairs: [
            (assign_pair
              lhs: (sh_lhs_expr.Name left:<Id.Lit_VarLike 'status='> name:status)
              op: assign_op.Equal
              rhs: {<1>}
              spids: [839]
            )
          ]
          redirects: []
        )
      ]
    )
    (command.ControlFlow token:<Id.ControlFlow_Exit exit> arg_word:{($ Id.VSub_DollarName status)})
  ]
)