(command.CommandList
  children: [
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:dashless)
          op: assign_op.Equal
          rhs: 
            {
              (command_sub
                left_token: <Id.Left_DollarParen '$('>
                child: 
                  (command.Pipeline
                    children: [
                      (C {<basename>} {(DQ ($ Id.VSub_Number '$0'))})
                      (C {<sed>} {<-e>} {(SQ <'s/-/ /'>)})
                    ]
                    negated: F
                  )
              )
            }
          spids: [16]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:USAGE)
          op: assign_op.Equal
          rhs: 
            {
              (DQ 
                <
'[--quiet] add [-b <branch>] [-f|--force] [--name <name>] [--reference <repository>] [--] <repository> [<path>]\n'
                > <'   or: '> ($ Id.VSub_DollarName '$dashless') 
                <' [--quiet] status [--cached] [--recursive] [--] [<path>...]\n'> <'   or: '> ($ Id.VSub_DollarName '$dashless') <' [--quiet] init [--] [<path>...]\n'> <'   or: '> 
                ($ Id.VSub_DollarName '$dashless') <' [--quiet] deinit [-f|--force] (--all| [--] <path>...)\n'> <'   or: '> 
                ($ Id.VSub_DollarName '$dashless') 
                <
' [--quiet] update [--init] [--remote] [-N|--no-fetch] [-f|--force] [--checkout|--merge|--rebase] [--[no-]recommend-shallow] [--reference <repository>] [--recursive] [--] [<path>...]\n'
                > <'   or: '> ($ Id.VSub_DollarName '$dashless') 
                <
' [--quiet] summary [--cached|--files] [--summary-limit <n>] [commit] [--] [<path>...]\n'
                > <'   or: '> ($ Id.VSub_DollarName '$dashless') <' [--quiet] foreach [--recursive] <command>\n'> 
                <'   or: '> ($ Id.VSub_DollarName '$dashless') <' [--quiet] sync [--recursive] [--] [<path>...]'>
              )
            }
          spids: [35]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:OPTIONS_SPEC)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [61]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:SUBDIRECTORY_OK)
          op: assign_op.Equal
          rhs: {<Yes>}
          spids: [63]
        )
      ]
    )
    (C {<.>} {<git-sh-setup>})
    (C {<.>} {<git-parse-remote>})
    (C {<require_work_tree>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:wt_prefix)
          op: assign_op.Equal
          rhs: 
            {
              (command_sub
                left_token: <Id.Left_DollarParen '$('>
                child: (C {<git>} {<rev-parse>} {<--show-prefix>})
              )
            }
          spids: [76]
        )
      ]
    )
    (C {<cd_to_toplevel>})
    (C {<Id.Lit_Colon ':'>} 
      {
        (braced_var_sub
          token: <Id.VSub_Name GIT_ALLOW_PROTOCOL>
          suffix_op: (suffix_op.Unary tok:<Id.VTest_Equals '='> arg_word:{<'file:git:http:https:ssh'>})
        )
      }
    )
    (C {<export>} {<GIT_ALLOW_PROTOCOL>})
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:command)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [119]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:branch)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [121]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:force)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [123]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:reference)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [125]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:cached)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [127]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:recursive)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [129]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:init)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [131]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:files)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [133]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:remote)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [135]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:nofetch)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [137]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:update)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [139]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:prefix)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [141]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:custom_name)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [143]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:depth)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [145]
        )
      ]
    )
    (command.ShAssignment
      pairs: [
        (assign_pair
          lhs: (sh_lhs_expr.Name name:progress)
          op: assign_op.Equal
          rhs: (word.Empty)
          spids: [147]
        )
      ]
    )
    (command.ShFunction
      name: die_if_unmatched
      body: 
        (BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (C {<test>} {(DQ ($ Id.VSub_Number '$1'))} {<Id.Lit_Equals '='>} 
                          {(DQ <'#unmatched'>)}
                        )
                      ]
                    )
                  action: [
                    (command.ControlFlow
                      token: <Id.ControlFlow_Exit exit>
                      arg_word: 
                        {
                          (braced_var_sub
                            token: <Id.VSub_Number 2>
                            suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonHyphen ':-'> arg_word:{<1>})
                          )
                        }
                    )
                  ]
                  spids: [158 173]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: get_submodule_config
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:name)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_Number '$1'))}
                  spids: [237]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:option)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_Number '$2'))}
                  spids: [243]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:default)
                  op: assign_op.Equal
                  rhs: {(DQ ($ Id.VSub_Number '$3'))}
                  spids: [249]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:value)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (C {<git>} {<config>} 
                            {<submodule.> (DQ ($ Id.VSub_DollarName '$name')) <.> 
                              (DQ ($ Id.VSub_DollarName '$option'))
                            }
                          )
                      )
                    }
                  spids: [255]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [(C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$value'))})]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:value)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<git>} {<config>} {<-f>} {<.gitmodules>} 
                                    {<submodule.> (DQ ($ Id.VSub_DollarName '$name')) <.> 
                                      (DQ ($ Id.VSub_DollarName '$option'))
                                    }
                                  )
                              )
                            }
                          spids: [286]
                        )
                      ]
                    )
                  ]
                  spids: [272 283]
                )
              ]
            )
            (C {<printf>} {(SQ <'%s'>)} 
              {
                (DQ 
                  (braced_var_sub
                    token: <Id.VSub_Name value>
                    suffix_op: 
                      (suffix_op.Unary
                        tok: <Id.VTest_ColonHyphen ':-'>
                        arg_word: {($ Id.VSub_DollarName '$default')}
                      )
                  )
                )
              }
            )
          ]
        )
    )
    (command.ShFunction
      name: isnumber
      body: 
        (BraceGroup
          children: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:n)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (word_part.ArithSub
                            anode: 
                              (arith_expr.Binary
                                op_id: Id.Arith_Plus
                                left: {($ Id.VSub_Number '$1')}
                                right: {<Id.Lit_Digits 0>}
                              )
                          )
                        }
                      spids: [334]
                    )
                  ]
                  redirects: [
                    (redir
                      op: <Id.Redir_Great '2>'>
                      loc: (redir_loc.Fd fd:2)
                      arg: {<'/dev/null'>}
                    )
                  ]
                )
                (C {<test>} {(DQ ($ Id.VSub_DollarName '$n'))} {<Id.Lit_Equals '='>} 
                  {(DQ ($ Id.VSub_Number '$1'))}
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: sanitize_submodule_env
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:save_config)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_DollarName '$GIT_CONFIG_PARAMETERS')}
                  spids: [380]
                )
              ]
            )
            (C {<clear_local_git_env>})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:GIT_CONFIG_PARAMETERS)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_DollarName '$save_config')}
                  spids: [387]
                )
              ]
            )
            (C {<export>} {<GIT_CONFIG_PARAMETERS>})
          ]
        )
    )
    (command.ShFunction
      name: cmd_add
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:reference_path)
                  op: assign_op.Equal
                  rhs: (word.Empty)
                  spids: [430]
                )
              ]
            )
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: (condition.Shell commands:[(C {<test>} {($ Id.VSub_Pound '$#')} {<-ne>} {<0>})])
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_Number '$1'))}
                      arms: [
                        (case_arm
                          pat_list: [{<-b>} {<--branch>}]
                          action: [
                            (command.Case
                              to_match: {(DQ ($ Id.VSub_Number '$2'))}
                              arms: [
                                (case_arm
                                  pat_list: [{(SQ )}]
                                  action: [(C {<usage>})]
                                  spids: [472 474 478 -1]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:branch)
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_Number '$2')}
                                  spids: [483]
                                )
                              ]
                            )
                            (C {<shift>})
                          ]
                          spids: [456 461 490 -1]
                        )
                        (case_arm
                          pat_list: [{<-f>} {<--force>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:force)
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_Number '$1')}
                                  spids: [501]
                                )
                              ]
                            )
                          ]
                          spids: [493 498 505 -1]
                        )
                        (case_arm
                          pat_list: [{<-q>} {<--quiet>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:GIT_QUIET)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [514]
                                )
                              ]
                            )
                          ]
                          spids: [508 511 518 -1]
                        )
                        (case_arm
                          pat_list: [{<--reference>}]
                          action: [
                            (command.Case
                              to_match: {(DQ ($ Id.VSub_Number '$2'))}
                              arms: [
                                (case_arm
                                  pat_list: [{(SQ )}]
                                  action: [(C {<usage>})]
                                  spids: [533 535 539 -1]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:reference_path)
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_Number '$2')}
                                  spids: [544]
                                )
                              ]
                            )
                            (C {<shift>})
                          ]
                          spids: [521 522 551 -1]
                        )
                        (case_arm
                          pat_list: [{<--reference> <Id.Lit_Equals '='> <Id.Lit_Star '*'>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:reference_path)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (braced_var_sub
                                          token: <Id.VSub_Number 1>
                                          suffix_op: 
                                            (suffix_op.Unary
                                              tok: <Id.VOp1_Pound '#'>
                                              arg_word: {<'--reference='>}
                                            )
                                        )
                                      )
                                    }
                                  spids: [560]
                                )
                              ]
                            )
                          ]
                          spids: [554 557 570 -1]
                        )
                        (case_arm
                          pat_list: [{<--name>}]
                          action: [
                            (command.Case
                              to_match: {(DQ ($ Id.VSub_Number '$2'))}
                              arms: [
                                (case_arm
                                  pat_list: [{(SQ )}]
                                  action: [(C {<usage>})]
                                  spids: [585 587 591 -1]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:custom_name)
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_Number '$2')}
                                  spids: [596]
                                )
                              ]
                            )
                            (C {<shift>})
                          ]
                          spids: [573 574 603 -1]
                        )
                        (case_arm
                          pat_list: [{<--depth>}]
                          action: [
                            (command.Case
                              to_match: {(DQ ($ Id.VSub_Number '$2'))}
                              arms: [
                                (case_arm
                                  pat_list: [{(SQ )}]
                                  action: [(C {<usage>})]
                                  spids: [618 620 624 -1]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:depth)
                                  op: assign_op.Equal
                                  rhs: {(DQ <'--depth='> ($ Id.VSub_Number '$2'))}
                                  spids: [629]
                                )
                              ]
                            )
                            (C {<shift>})
                          ]
                          spids: [606 607 639 -1]
                        )
                        (case_arm
                          pat_list: [{<--depth> <Id.Lit_Equals '='> <Id.Lit_Star '*'>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:depth)
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_Number '$1')}
                                  spids: [648]
                                )
                              ]
                            )
                          ]
                          spids: [642 645 652 -1]
                        )
                        (case_arm
                          pat_list: [{<-->}]
                          action: [
                            (C {<shift>})
                            (command.ControlFlow
                              token: <Id.ControlFlow_Break break>
                            )
                          ]
                          spids: [655 656 665 -1]
                        )
                        (case_arm
                          pat_list: [{<-> <Id.Lit_Star '*'>}]
                          action: [(C {<usage>})]
                          spids: [668 670 676 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [(command.ControlFlow token:<Id.ControlFlow_Break break>)]
                          spids: [679 680 686 -1]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                )
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [(C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$reference_path'))})]
                    )
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<is_absolute_path>} {(DQ ($ Id.VSub_DollarName '$reference_path'))})
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:reference_path)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (DQ ($ Id.VSub_DollarName '$wt_prefix') 
                                    ($ Id.VSub_DollarName '$reference_path')
                                  )
                                }
                              spids: [722]
                            )
                          ]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:reference)
                          op: assign_op.Equal
                          rhs: {(DQ <'--reference='> ($ Id.VSub_DollarName '$reference_path'))}
                          spids: [730]
                        )
                      ]
                    )
                  ]
                  spids: [699 710]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:repo)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$1')}
                  spids: [741]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:sm_path)
                  op: assign_op.Equal
                  rhs: {($ Id.VSub_Number '$2')}
                  spids: [745]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$sm_path'))})
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:sm_path)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (command.Pipeline
                                    children: [
                                      (C {<printf>} {(SQ <'%s\\n'>)} 
                                        {(DQ ($ Id.VSub_DollarName '$repo'))}
                                      )
                                      (C {<sed>} {<-e>} {(SQ <'s|/$||'>)} {<-e>} {(SQ <'s|:*/*\\.git$||'>)} 
                                        {<-e>} {(SQ <'s|.*[/:]||g'>)}
                                      )
                                    ]
                                    negated: F
                                  )
                              )
                            }
                          spids: [764]
                        )
                      ]
                    )
                  ]
                  spids: [750 761]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.Sentence
                          child: 
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$repo'))})
                                (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$sm_path'))})
                              ]
                            )
                          terminator: <Id.Op_Semi _>
                        )
                      ]
                    )
                  action: [(C {<usage>})]
                  spids: [805 826]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<is_absolute_path>} {(DQ ($ Id.VSub_DollarName '$sm_path'))})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:sm_path)
                      op: assign_op.Equal
                      rhs: {(DQ ($ Id.VSub_DollarName '$wt_prefix') ($ Id.VSub_DollarName '$sm_path'))}
                      spids: [844]
                    )
                  ]
                )
              ]
            )
            (command.Case
              to_match: {(DQ ($ Id.VSub_DollarName '$repo'))}
              arms: [
                (case_arm
                  pat_list: [{<'./'> <Id.Lit_Star '*'>} {<'../'> <Id.Lit_Star '*'>}]
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$wt_prefix'))})
                        (C {<die>} 
                          {
                            (DQ 
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<gettext>} 
                                    {
                                      (DQ 
                                        <
'Relative path can only be used from the toplevel of the working tree'
                                        >
                                      )
                                    }
                                  )
                              )
                            )
                          }
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:realrepo)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (C {<git>} {<submodule--helper>} {<resolve-relative-url>} 
                                        {(DQ ($ Id.VSub_DollarName '$repo'))}
                                      )
                                  )
                                }
                              spids: [902]
                            )
                          ]
                        )
                        (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
                      ]
                    )
                  ]
                  spids: [865 870 920 -1]
                )
                (case_arm
                  pat_list: [
                    {<Id.Lit_Star '*'> <Id.Lit_Colon ':'> <Id.Lit_Star '*'>}
                    {<'/'> <Id.Lit_Star '*'>}
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:realrepo)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName '$repo')}
                          spids: [936]
                        )
                      ]
                    )
                  ]
                  spids: [923 929 940 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [
                    (C {<die>} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (C {<eval_gettext>} 
                                {
                                  (DQ <'repo URL: \''> 
                                    (word_part.EscapedLiteral
                                      token: <Id.Lit_EscapedChar '\\$'>
                                    ) <'repo\' must be absolute or begin with ./|../'>
                                  )
                                }
                              )
                          )
                        )
                      }
                    )
                  ]
                  spids: [943 944 962 -1]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:sm_path)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (command.Pipeline
                            children: [
                              (C {<printf>} {(SQ <'%s/\\n'>)} {(DQ ($ Id.VSub_DollarName '$sm_path'))})
                              (C {<sed>} {<-e>} 
                                {
                                  (SQ <'\n'> <'\t\t\ts|//*|/|g\n'> <'\t\t\ts|^\\(\\./\\)*||\n'> 
                                    <'\t\t\ts|/\\(\\./\\)*|/|g\n'> <'\t\t\t:start\n'> <'\t\t\ts|\\([^/]*\\)/\\.\\./||\n'> <'\t\t\ttstart\n'> <'\t\t\ts|/*$||\n'> <'\t\t'>
                                  )
                                }
                              )
                            ]
                            negated: F
                          )
                      )
                    }
                  spids: [977]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.Simple
                  words: [
                    {<git>}
                    {<ls-files>}
                    {<--error-unmatch>}
                    {(DQ ($ Id.VSub_DollarName '$sm_path'))}
                  ]
                  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
                )
                (C {<die>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (C {<eval_gettext>} 
                            {
                              (DQ <'\''> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) 
                                <'sm_path\' already exists in the index'>
                              )
                            }
                          )
                      )
                    )
                  }
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.AndOr
                          ops: [Id.Op_DAmp]
                          children: [
                            (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$force'))})
                            (command.Pipeline
                              children: [
                                (command.Simple
                                  words: [
                                    {<git>}
                                    {<add>}
                                    {<--dry-run>}
                                    {<--ignore-missing>}
                                    {(DQ ($ Id.VSub_DollarName '$sm_path'))}
                                  ]
                                  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
                                )
                              ]
                              negated: T
                            )
                          ]
                        )
                      ]
                    )
                  action: [
                    (command.Simple
                      words: [
                        {<eval_gettextln>}
                        {
                          (DQ <'The following path is ignored by one of your .gitignore files:\n'> 
                            (word_part.EscapedLiteral
                              token: <Id.Lit_EscapedChar '\\$'>
                            ) <'sm_path\n'> <'Use -f if you really want to add it.'>
                          )
                        }
                      ]
                      redirects: [(redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
                      do_fork: T
                    )
                    (command.ControlFlow
                      token: <Id.ControlFlow_Exit exit>
                      arg_word: {<1>}
                    )
                  ]
                  spids: [1046 1080]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [(C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$custom_name'))})]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:sm_name)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_DollarName '$custom_name'))}
                          spids: [1119]
                        )
                      ]
                    )
                  ]
                  spids: [1105 1116]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:sm_name)
                      op: assign_op.Equal
                      rhs: {(DQ ($ Id.VSub_DollarName '$sm_path'))}
                      spids: [1128]
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [(C {<test>} {<-e>} {(DQ ($ Id.VSub_DollarName '$sm_path'))})]
                    )
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [
                                (command.AndOr
                                  ops: [Id.Op_DPipe]
                                  children: [
                                    (C {<test>} {<-d>} 
                                      {(DQ ($ Id.VSub_DollarName '$sm_path')) <'/.git'>}
                                    )
                                    (C {<test>} {<-f>} 
                                      {(DQ ($ Id.VSub_DollarName '$sm_path')) <'/.git'>}
                                    )
                                  ]
                                )
                              ]
                            )
                          action: [
                            (C {<eval_gettextln>} 
                              {
                                (DQ <'Adding existing repo at \''> 
                                  (word_part.EscapedLiteral
                                    token: <Id.Lit_EscapedChar '\\$'>
                                  ) <'sm_path\' to the index'>
                                )
                              }
                            )
                          ]
                          spids: [1156 1179]
                        )
                      ]
                      else_action: [
                        (C {<die>} 
                          {
                            (DQ 
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<eval_gettext>} 
                                    {
                                      (DQ <'\''> 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\$'>
                                        ) <'sm_path\' already exists and is not a valid git repo'>
                                      )
                                    }
                                  )
                              )
                            )
                          }
                        )
                      ]
                    )
                  ]
                  spids: [1142 1153]
                )
              ]
              else_action: [
                (command.If
                  arms: [
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [
                            (C {<test>} {<-d>} {(DQ <'.git/modules/'> ($ Id.VSub_DollarName '$sm_name'))})
                          ]
                        )
                      action: [
                        (command.If
                          arms: [
                            (if_arm
                              cond: 
                                (condition.Shell
                                  commands: [(C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$force'))})]
                                )
                              action: [
                                (command.Simple
                                  words: [
                                    {<eval_gettextln>}
                                    {
                                      (DQ <'A git directory for \''> 
                                        (word_part.EscapedLiteral
                                          token: <Id.Lit_EscapedChar '\\$'>
                                        ) <'sm_name\' is found locally with remote(s):'>
                                      )
                                    }
                                  ]
                                  redirects: [
                                    (redir
                                      op: <Id.Redir_GreatAnd '>&'>
                                      loc: (redir_loc.Fd fd:1)
                                      arg: {<2>}
                                    )
                                  ]
                                  do_fork: T
                                )
                                (command.Pipeline
                                  children: [
                                    (command.Simple
                                      words: [{<git>} {<remote>} {<-v>}]
                                      more_env: [
                                        (env_pair
                                          name: GIT_DIR
                                          val: 
                                            {(DQ <'.git/modules/'> ($ Id.VSub_DollarName '$sm_name'))}
                                          spids: [1257]
                                        )
                                        (env_pair
                                          name: GIT_WORK_TREE
                                          val: {<.>}
                                          spids: [1263]
                                        )
                                      ]
                                      do_fork: T
                                    )
                                    (C {<grep>} {(SQ <'(fetch)'>)})
                                    (command.Simple
                                      words: [
                                        {<sed>}
                                        {<-e>}
                                        {<s> <Id.Lit_Comma ','> <Id.Lit_Other '^'> <Id.Lit_Comma ','> 
                                          (DQ <'  '>) <Id.Lit_Comma ','>
                                        }
                                        {<-e>}
                                        {<s> <Id.Lit_Comma ','> (SQ <' (fetch)'>) <Id.Lit_Comma ','> 
                                          <Id.Lit_Comma ','>
                                        }
                                      ]
                                      redirects: [
                                        (redir
                                          op: <Id.Redir_GreatAnd '>&'>
                                          loc: (redir_loc.Fd fd:1)
                                          arg: {<2>}
                                        )
                                      ]
                                      do_fork: T
                                    )
                                  ]
                                  negated: F
                                )
                                (C {<die>} 
                                  {
                                    (DQ 
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (C {<eval_gettextln>} 
                                            {
                                              (DQ 
                                                <
'If you want to reuse this local git directory instead of cloning again from\n'
                                                > <'  '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'realrepo\n'> 
                                                <
'use the \'--force\' option. If the local git directory is not the correct repo\n'
                                                > <'or you are unsure what this means choose another name with the \'--name\' option.'>
                                              )
                                            }
                                          )
                                      )
                                    )
                                  }
                                )
                              ]
                              spids: [1231 1242]
                            )
                          ]
                          else_action: [
                            (C {<eval_gettextln>} 
                              {
                                (DQ <'Reactivating local git directory for submodule \''> 
                                  (word_part.EscapedLiteral
                                    token: <Id.Lit_EscapedChar '\\$'>
                                  ) <'sm_name\'.'>
                                )
                              }
                            )
                          ]
                        )
                      ]
                      spids: [1216 1228]
                    )
                  ]
                )
                (command.AndOr
                  ops: [Id.Op_DPipe]
                  children: [
                    (C {<git>} {<submodule--helper>} {<clone>} 
                      {
                        (braced_var_sub
                          token: <Id.VSub_Name GIT_QUIET>
                          suffix_op: 
                            (suffix_op.Unary
                              tok: <Id.VTest_ColonPlus ':+'>
                              arg_word: {<--quiet>}
                            )
                        )
                      } {<--prefix>} {(DQ ($ Id.VSub_DollarName '$wt_prefix'))} {<--path>} 
                      {(DQ ($ Id.VSub_DollarName '$sm_path'))} {<--name>} {(DQ ($ Id.VSub_DollarName '$sm_name'))} {<--url>} {(DQ ($ Id.VSub_DollarName '$realrepo'))} 
                      {
                        (braced_var_sub
                          token: <Id.VSub_Name reference>
                          suffix_op: 
                            (suffix_op.Unary
                              tok: <Id.VTest_ColonPlus ':+'>
                              arg_word: {(DQ ($ Id.VSub_DollarName '$reference'))}
                            )
                        )
                      } 
                      {
                        (braced_var_sub
                          token: <Id.VSub_Name depth>
                          suffix_op: 
                            (suffix_op.Unary
                              tok: <Id.VTest_ColonPlus ':+'>
                              arg_word: {(DQ ($ Id.VSub_DollarName '$depth'))}
                            )
                        )
                      }
                    )
                    (command.ControlFlow token:<Id.ControlFlow_Exit exit>)
                  ]
                )
                (command.AndOr
                  ops: [Id.Op_DPipe]
                  children: [
                    (command.Subshell
                      child: 
                        (command.CommandList
                          children: [
                            (C {<sanitize_submodule_env>})
                            (command.AndOr
                              ops: [Id.Op_DAmp]
                              children: [
                                (C {<cd>} {(DQ ($ Id.VSub_DollarName '$sm_path'))})
                                (command.Case
                                  to_match: {(DQ ($ Id.VSub_DollarName '$branch'))}
                                  arms: [
                                    (case_arm
                                      pat_list: [{(SQ )}]
                                      action: [(C {<git>} {<checkout>} {<-f>} {<-q>})]
                                      spids: [1431 1433 1443 -1]
                                    )
                                    (case_arm
                                      pat_list: [{<Id.Lit_QMark '?'> <Id.Lit_Star '*'>}]
                                      action: [
                                        (C {<git>} {<checkout>} {<-f>} {<-q>} {<-B>} 
                                          {(DQ ($ Id.VSub_DollarName '$branch'))} {(DQ <'origin/'> ($ Id.VSub_DollarName '$branch'))}
                                        )
                                      ]
                                      spids: [1446 1448 1469 -1]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (C {<die>} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (C {<eval_gettext>} 
                                {
                                  (DQ <'Unable to checkout submodule \''> 
                                    (word_part.EscapedLiteral
                                      token: <Id.Lit_EscapedChar '\\$'>
                                    ) <'sm_path\''>
                                  )
                                }
                              )
                          )
                        )
                      }
                    )
                  ]
                )
              ]
            )
            (C {<git>} {<config>} {<submodule.> (DQ ($ Id.VSub_DollarName '$sm_name')) <.url>} 
              {(DQ ($ Id.VSub_DollarName '$realrepo'))}
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<git>} {<add>} {($ Id.VSub_DollarName '$force')} 
                  {(DQ ($ Id.VSub_DollarName '$sm_path'))}
                )
                (C {<die>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (C {<eval_gettext>} 
                            {
                              (DQ <'Failed to add submodule \''> 
                                (word_part.EscapedLiteral
                                  token: <Id.Lit_EscapedChar '\\$'>
                                ) <'sm_path\''>
                              )
                            }
                          )
                      )
                    )
                  }
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp Id.Op_DPipe]
              children: [
                (C {<git>} {<config>} {<-f>} {<.gitmodules>} 
                  {<submodule.> (DQ ($ Id.VSub_DollarName '$sm_name')) <.path>} {(DQ ($ Id.VSub_DollarName '$sm_path'))}
                )
                (C {<git>} {<config>} {<-f>} {<.gitmodules>} 
                  {<submodule.> (DQ ($ Id.VSub_DollarName '$sm_name')) <.url>} {(DQ ($ Id.VSub_DollarName '$repo'))}
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: 
                        (condition.Shell
                          commands: [(C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$branch'))})]
                        )
                      action: [
                        (C {<git>} {<config>} {<-f>} {<.gitmodules>} 
                          {<submodule.> (DQ ($ Id.VSub_DollarName '$sm_name')) <.branch>} {(DQ ($ Id.VSub_DollarName '$branch'))}
                        )
                      ]
                      spids: [1584 1595]
                    )
                  ]
                )
                (C {<git>} {<add>} {<--force>} {<.gitmodules>})
                (C {<die>} 
                  {
                    (DQ 
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (C {<eval_gettext>} 
                            {
                              (DQ <'Failed to register submodule \''> 
                                (word_part.EscapedLiteral
                                  token: <Id.Lit_EscapedChar '\\$'>
                                ) <'sm_path\''>
                              )
                            }
                          )
                      )
                    )
                  }
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: cmd_foreach
      body: 
        (BraceGroup
          children: [
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: (condition.Shell commands:[(C {<test>} {($ Id.VSub_Pound '$#')} {<-ne>} {<0>})])
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_Number '$1'))}
                      arms: [
                        (case_arm
                          pat_list: [{<-q>} {<--quiet>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:GIT_QUIET)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [1708]
                                )
                              ]
                            )
                          ]
                          spids: [1702 1705 1712 -1]
                        )
                        (case_arm
                          pat_list: [{<--recursive>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:recursive)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [1719]
                                )
                              ]
                            )
                          ]
                          spids: [1715 1716 1723 -1]
                        )
                        (case_arm
                          pat_list: [{<-> <Id.Lit_Star '*'>}]
                          action: [(C {<usage>})]
                          spids: [1726 1728 1734 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [(command.ControlFlow token:<Id.ControlFlow_Break break>)]
                          spids: [1737 1738 1744 -1]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                )
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:toplevel)
                  op: assign_op.Equal
                  rhs: {(command_sub left_token:<Id.Left_DollarParen '$('> child:(C {<pwd>}))}
                  spids: [1757]
                )
              ]
            )
            (command.Simple
              words: [{<exec>}]
              redirects: [(redir op:<Id.Redir_LessAnd '3<&'> loc:(redir_loc.Fd fd:3) arg:{<0>})]
              do_fork: T
            )
            (command.Pipeline
              children: [
                (BraceGroup
                  children: [
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<git>} {<submodule--helper>} {<list>} {<--prefix>} 
                          {(DQ ($ Id.VSub_DollarName '$wt_prefix'))}
                        )
                        (C {<echo>} {(DQ <'#unmatched'>)} {($ Id.VSub_QMark '$?')})
                      ]
                    )
                  ]
                )
                (command.WhileUntil
                  keyword: <Id.KW_While while>
                  cond: 
                    (condition.Shell
                      commands: [(C {<read>} {<mode>} {<sha1>} {<stage>} {<sm_path>})]
                    )
                  body: 
                    (command.DoGroup
                      children: [
                        (C {<die_if_unmatched>} {(DQ ($ Id.VSub_DollarName '$mode'))} 
                          {(DQ ($ Id.VSub_DollarName '$sha1'))}
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (C {<test>} {<-e>} 
                                      {(DQ ($ Id.VSub_DollarName '$sm_path')) <'/.git'>}
                                    )
                                  ]
                                )
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:displaypath)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            child: 
                                              (C {<git>} {<submodule--helper>} {<relative-path>} 
                                                {
                                                  (DQ ($ Id.VSub_DollarName '$prefix') 
                                                    ($ Id.VSub_DollarName '$sm_path')
                                                  )
                                                } {(DQ ($ Id.VSub_DollarName '$wt_prefix'))}
                                              )
                                          )
                                        }
                                      spids: [1853]
                                    )
                                  ]
                                )
                                (C {<say>} 
                                  {
                                    (DQ 
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (C {<eval_gettext>} 
                                            {
                                              (DQ <'Entering \''> 
                                                (word_part.EscapedLiteral
                                                  token: <Id.Lit_EscapedChar '\\$'>
                                                ) <'displaypath\''>
                                              )
                                            }
                                          )
                                      )
                                    )
                                  }
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:name)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            child: 
                                              (C {<git>} {<submodule--helper>} {<name>} 
                                                {(DQ ($ Id.VSub_DollarName '$sm_path'))}
                                              )
                                          )
                                        }
                                      spids: [1887]
                                    )
                                  ]
                                )
                                (command.AndOr
                                  ops: [Id.Op_DPipe]
                                  children: [
                                    (command.Subshell
                                      child: 
                                        (command.CommandList
                                          children: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:prefix)
                                                  op: assign_op.Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ Id.VSub_DollarName '$prefix') 
                                                        ($ Id.VSub_DollarName '$sm_path') <'/'>
                                                      )
                                                    }
                                                  spids: [1904]
                                                )
                                              ]
                                            )
                                            (C {<sanitize_submodule_env>})
                                            (command.AndOr
                                              ops: [Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp]
                                              children: [
                                                (C {<cd>} {(DQ ($ Id.VSub_DollarName '$sm_path'))})
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (sh_lhs_expr.Name name:sm_path)
                                                      op: assign_op.Equal
                                                      rhs: 
                                                        {
                                                          (command_sub
                                                            left_token: <Id.Left_DollarParen '$('>
                                                            child: 
                                                              (C {<git>} {<submodule--helper>} 
                                                                {<relative-path>} {(DQ ($ Id.VSub_DollarName '$sm_path'))} {(DQ ($ Id.VSub_DollarName '$wt_prefix'))}
                                                              )
                                                          )
                                                        }
                                                      spids: [1924]
                                                    )
                                                  ]
                                                )
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (sh_lhs_expr.Name name:path)
                                                      op: assign_op.Equal
                                                      rhs: {($ Id.VSub_DollarName '$sm_path')}
                                                      spids: [1948]
                                                    )
                                                  ]
                                                )
                                                (command.If
                                                  arms: [
                                                    (if_arm
                                                      cond: 
                                                        (condition.Shell
                                                          commands: [
                                                            (C {<test>} {($ Id.VSub_Pound '$#')} {<-eq>} 
                                                              {<1>}
                                                            )
                                                          ]
                                                        )
                                                      action: [
                                                        (C {<eval>} {(DQ ($ Id.VSub_Number '$1'))})
                                                      ]
                                                      spids: [1954 1965]
                                                    )
                                                  ]
                                                  else_action: [(C {(DQ ($ Id.VSub_At '$@'))})]
                                                )
                                                (command.If
                                                  arms: [
                                                    (if_arm
                                                      cond: 
                                                        (condition.Shell
                                                          commands: [
                                                            (C {<test>} {<-n>} 
                                                              {
                                                                (DQ 
                                                                  ($ Id.VSub_DollarName '$recursive')
                                                                )
                                                              }
                                                            )
                                                          ]
                                                        )
                                                      action: [
                                                        (C {<cmd_foreach>} {(DQ <--recursive>)} 
                                                          {(DQ ($ Id.VSub_At '$@'))}
                                                        )
                                                      ]
                                                      spids: [1988 1999]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      redirects: [
                                        (redir
                                          op: <Id.Redir_LessAnd '<&'>
                                          loc: (redir_loc.Fd fd:0)
                                          arg: {<3>}
                                        )
                                        (redir
                                          op: <Id.Redir_LessAnd '3<&'>
                                          loc: (redir_loc.Fd fd:3)
                                          arg: {<->}
                                        )
                                      ]
                                    )
                                    (C {<die>} 
                                      {
                                        (DQ 
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            child: 
                                              (C {<eval_gettext>} 
                                                {
                                                  (DQ <'Stopping at \''> 
                                                    (word_part.EscapedLiteral
                                                      token: <Id.Lit_EscapedChar '\\$'>
                                                    ) <'displaypath\'; script returned non-zero status.'>
                                                  )
                                                }
                                              )
                                          )
                                        )
                                      }
                                    )
                                  ]
                                )
                              ]
                              spids: [1838 1850]
                            )
                          ]
                        )
                      ]
                    )
                )
              ]
              negated: F
            )
          ]
        )
    )
    (command.ShFunction
      name: cmd_init
      body: 
        (BraceGroup
          children: [
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: (condition.Shell commands:[(C {<test>} {($ Id.VSub_Pound '$#')} {<-ne>} {<0>})])
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_Number '$1'))}
                      arms: [
                        (case_arm
                          pat_list: [{<-q>} {<--quiet>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:GIT_QUIET)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [2105]
                                )
                              ]
                            )
                          ]
                          spids: [2099 2102 2109 -1]
                        )
                        (case_arm
                          pat_list: [{<-->}]
                          action: [
                            (C {<shift>})
                            (command.ControlFlow
                              token: <Id.ControlFlow_Break break>
                            )
                          ]
                          spids: [2112 2113 2122 -1]
                        )
                        (case_arm
                          pat_list: [{<-> <Id.Lit_Star '*'>}]
                          action: [(C {<usage>})]
                          spids: [2125 2127 2133 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [(command.ControlFlow token:<Id.ControlFlow_Break break>)]
                          spids: [2136 2137 2143 -1]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                )
            )
            (C {<git>} 
              {
                (braced_var_sub
                  token: <Id.VSub_Name wt_prefix>
                  suffix_op: 
                    (suffix_op.Unary
                      tok: <Id.VTest_ColonPlus ':+'>
                      arg_word: {<'-C '> (DQ ($ Id.VSub_DollarName '$wt_prefix'))}
                    )
                )
              } {<submodule--helper>} {<init>} 
              {
                (braced_var_sub
                  token: <Id.VSub_Name GIT_QUIET>
                  suffix_op: (suffix_op.Unary tok:<Id.VTest_ColonPlus ':+'> arg_word:{<--quiet>})
                )
              } 
              {
                (braced_var_sub
                  token: <Id.VSub_Name prefix>
                  suffix_op: 
                    (suffix_op.Unary
                      tok: <Id.VTest_ColonPlus ':+'>
                      arg_word: {<'--prefix '> (DQ ($ Id.VSub_DollarName '$prefix'))}
                    )
                )
              } {(DQ ($ Id.VSub_At '$@'))}
            )
          ]
        )
    )
    (command.ShFunction
      name: cmd_deinit
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:deinit_all)
                  op: assign_op.Equal
                  rhs: (word.Empty)
                  spids: [2213]
                )
              ]
            )
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: (condition.Shell commands:[(C {<test>} {($ Id.VSub_Pound '$#')} {<-ne>} {<0>})])
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_Number '$1'))}
                      arms: [
                        (case_arm
                          pat_list: [{<-f>} {<--force>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:force)
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_Number '$1')}
                                  spids: [2245]
                                )
                              ]
                            )
                          ]
                          spids: [2239 2242 2249 -1]
                        )
                        (case_arm
                          pat_list: [{<-q>} {<--quiet>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:GIT_QUIET)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [2258]
                                )
                              ]
                            )
                          ]
                          spids: [2252 2255 2262 -1]
                        )
                        (case_arm
                          pat_list: [{<--all>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:deinit_all)
                                  op: assign_op.Equal
                                  rhs: {<t>}
                                  spids: [2269]
                                )
                              ]
                            )
                          ]
                          spids: [2265 2266 2273 -1]
                        )
                        (case_arm
                          pat_list: [{<-->}]
                          action: [
                            (C {<shift>})
                            (command.ControlFlow
                              token: <Id.ControlFlow_Break break>
                            )
                          ]
                          spids: [2276 2277 2286 -1]
                        )
                        (case_arm
                          pat_list: [{<-> <Id.Lit_Star '*'>}]
                          action: [(C {<usage>})]
                          spids: [2289 2291 2297 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [(command.ControlFlow token:<Id.ControlFlow_Break break>)]
                          spids: [2300 2301 2307 -1]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                )
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.AndOr
                          ops: [Id.Op_DAmp]
                          children: [
                            (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$deinit_all'))})
                            (C {<test>} {(DQ ($ Id.VSub_Pound '$#'))} {<-ne>} {<0>})
                          ]
                        )
                      ]
                    )
                  action: [
                    (command.Simple
                      words: [
                        {<echo>}
                        {
                          (DQ 
                            (command_sub
                              left_token: <Id.Left_DollarParen '$('>
                              child: (C {<eval_gettext>} {(DQ <'pathspec and --all are incompatible'>)})
                            )
                          )
                        }
                      ]
                      redirects: [(redir op:<Id.Redir_GreatAnd '>&'> loc:(redir_loc.Fd fd:1) arg:{<2>})]
                      do_fork: T
                    )
                    (C {<usage>})
                  ]
                  spids: [2320 2343]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.AndOr
                          ops: [Id.Op_DAmp]
                          children: [
                            (C {<test>} {($ Id.VSub_Pound '$#')} {<Id.Lit_Equals '='>} {<0>})
                            (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$deinit_all'))})
                          ]
                        )
                      ]
                    )
                  action: [
                    (C {<die>} 
                      {
                        (DQ 
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (C {<eval_gettext>} 
                                {
                                  (DQ 
                                    <
'Use \'--all\' if you really want to deinitialize all submodules'
                                    >
                                  )
                                }
                              )
                          )
                        )
                      }
                    )
                  ]
                  spids: [2368 2389]
                )
              ]
            )
            (command.Pipeline
              children: [
                (BraceGroup
                  children: [
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<git>} {<submodule--helper>} {<list>} {<--prefix>} 
                          {(DQ ($ Id.VSub_DollarName '$wt_prefix'))} {(DQ ($ Id.VSub_At '$@'))}
                        )
                        (C {<echo>} {(DQ <'#unmatched'>)} {($ Id.VSub_QMark '$?')})
                      ]
                    )
                  ]
                )
                (command.WhileUntil
                  keyword: <Id.KW_While while>
                  cond: 
                    (condition.Shell
                      commands: [(C {<read>} {<mode>} {<sha1>} {<stage>} {<sm_path>})]
                    )
                  body: 
                    (command.DoGroup
                      children: [
                        (C {<die_if_unmatched>} {(DQ ($ Id.VSub_DollarName '$mode'))} 
                          {(DQ ($ Id.VSub_DollarName '$sha1'))}
                        )
                        (command.AndOr
                          ops: [Id.Op_DPipe]
                          children: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:name)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (C {<git>} {<submodule--helper>} {<name>} 
                                            {(DQ ($ Id.VSub_DollarName '$sm_path'))}
                                          )
                                      )
                                    }
                                  spids: [2472]
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Exit exit>
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:displaypath)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (C {<git>} {<submodule--helper>} {<relative-path>} 
                                        {(DQ ($ Id.VSub_DollarName '$sm_path'))} {(DQ ($ Id.VSub_DollarName '$wt_prefix'))}
                                      )
                                  )
                                }
                              spids: [2491]
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (C {<test>} {<-d>} {(DQ ($ Id.VSub_DollarName '$sm_path'))})
                                  ]
                                )
                              action: [
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: 
                                        (condition.Shell
                                          commands: [
                                            (C {<test>} {<-d>} 
                                              {(DQ ($ Id.VSub_DollarName '$sm_path') <'/.git'>)}
                                            )
                                          ]
                                        )
                                      action: [
                                        (C {<die>} 
                                          {
                                            (DQ 
                                              (command_sub
                                                left_token: <Id.Left_DollarParen '$('>
                                                child: 
                                                  (C {<eval_gettext>} 
                                                    {
                                                      (DQ <'Submodule work tree \''> 
                                                        (word_part.EscapedLiteral
                                                          token: <Id.Lit_EscapedChar '\\$'>
                                                        ) <'displaypath\' contains a .git directory\n'> 
                                                        <
'(use \'rm -rf\' if you really want to remove it including all of its history)'
                                                        >
                                                      )
                                                    }
                                                  )
                                              )
                                            )
                                          }
                                        )
                                      ]
                                      spids: [2532 2544]
                                    )
                                  ]
                                )
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: 
                                        (condition.Shell
                                          commands: [
                                            (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$force'))})
                                          ]
                                        )
                                      action: [
                                        (command.AndOr
                                          ops: [Id.Op_DPipe]
                                          children: [
                                            (C {<git>} {<rm>} {<-qn>} 
                                              {(DQ ($ Id.VSub_DollarName '$sm_path'))}
                                            )
                                            (C {<die>} 
                                              {
                                                (DQ 
                                                  (command_sub
                                                    left_token: <Id.Left_DollarParen '$('>
                                                    child: 
                                                      (C {<eval_gettext>} 
                                                        {
                                                          (DQ <'Submodule work tree \''> 
                                                            (word_part.EscapedLiteral
                                                              token: <Id.Lit_EscapedChar '\\$'>
                                                            ) <'displaypath\' contains local modifications; use \'-f\' to discard them'>
                                                          )
                                                        }
                                                      )
                                                  )
                                                )
                                              }
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [2568 2579]
                                    )
                                  ]
                                )
                                (command.AndOr
                                  ops: [Id.Op_DAmp Id.Op_DPipe]
                                  children: [
                                    (C {<rm>} {<-rf>} {(DQ ($ Id.VSub_DollarName '$sm_path'))})
                                    (C {<say>} 
                                      {
                                        (DQ 
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            child: 
                                              (C {<eval_gettext>} 
                                                {
                                                  (DQ <'Cleared directory \''> 
                                                    (word_part.EscapedLiteral
                                                      token: <Id.Lit_EscapedChar '\\$'>
                                                    ) <'displaypath\''>
                                                  )
                                                }
                                              )
                                          )
                                        )
                                      }
                                    )
                                    (C {<say>} 
                                      {
                                        (DQ 
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            child: 
                                              (C {<eval_gettext>} 
                                                {
                                                  (DQ <'Could not remove submodule work tree \''> 
                                                    (word_part.EscapedLiteral
                                                      token: <Id.Lit_EscapedChar '\\$'>
                                                    ) <'displaypath\''>
                                                  )
                                                }
                                              )
                                          )
                                        )
                                      }
                                    )
                                  ]
                                )
                              ]
                              spids: [2514 2525]
                            )
                          ]
                        )
                        (command.AndOr
                          ops: [Id.Op_DPipe]
                          children: [
                            (C {<mkdir>} {(DQ ($ Id.VSub_DollarName '$sm_path'))})
                            (C {<say>} 
                              {
                                (DQ 
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (C {<eval_gettext>} 
                                        {
                                          (DQ <'Could not create empty submodule directory \''> 
                                            (word_part.EscapedLiteral
                                              token: <Id.Lit_EscapedChar '\\$'>
                                            ) <'displaypath\''>
                                          )
                                        }
                                      )
                                  )
                                )
                              }
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (C {<test>} {<-n>} 
                                      {
                                        (DQ 
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            child: 
                                              (C {<git>} {<config>} {<--get-regexp>} 
                                                {<submodule.> 
                                                  (DQ ($ Id.VSub_DollarName '$name') 
                                                    <Id.Lit_BadBackslash '\\'> <.>
                                                  )
                                                }
                                              )
                                          )
                                        )
                                      }
                                    )
                                  ]
                                )
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:url)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            child: 
                                              (C {<git>} {<config>} 
                                                {<submodule.> (DQ ($ Id.VSub_DollarName '$name')) 
                                                  <.url>
                                                }
                                              )
                                          )
                                        }
                                      spids: [2723]
                                    )
                                  ]
                                )
                                (command.AndOr
                                  ops: [Id.Op_DAmp]
                                  children: [
                                    (command.Simple
                                      words: [
                                        {<git>}
                                        {<config>}
                                        {<--remove-section>}
                                        {<submodule.> (DQ ($ Id.VSub_DollarName '$name'))}
                                      ]
                                      redirects: [
                                        (redir
                                          op: <Id.Redir_Great '2>'>
                                          loc: (redir_loc.Fd fd:2)
                                          arg: {<'/dev/null'>}
                                        )
                                      ]
                                      do_fork: T
                                    )
                                    (C {<say>} 
                                      {
                                        (DQ 
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            child: 
                                              (C {<eval_gettext>} 
                                                {
                                                  (DQ <'Submodule \''> 
                                                    (word_part.EscapedLiteral
                                                      token: <Id.Lit_EscapedChar '\\$'>
                                                    ) <'name\' ('> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) 
                                                    <'url) unregistered for path \''> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'displaypath\''>
                                                  )
                                                }
                                              )
                                          )
                                        )
                                      }
                                    )
                                  ]
                                )
                              ]
                              spids: [2688 2712]
                            )
                          ]
                        )
                      ]
                    )
                )
              ]
              negated: F
            )
          ]
        )
    )
    (command.ShFunction
      name: is_tip_reachable
      body: 
        (command.Subshell
          child: 
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp]
              children: [
                (C {<sanitize_submodule_env>})
                (C {<cd>} {(DQ ($ Id.VSub_Number '$1'))})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:rev)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (command_sub
                            left_token: <Id.Left_DollarParen '$('>
                            child: 
                              (command.Simple
                                words: [
                                  {<git>}
                                  {<rev-list>}
                                  {<-n>}
                                  {<1>}
                                  {(DQ ($ Id.VSub_Number '$2'))}
                                  {<--not>}
                                  {<--all>}
                                ]
                                redirects: [
                                  (redir
                                    op: <Id.Redir_Great '2>'>
                                    loc: (redir_loc.Fd fd:2)
                                    arg: {<'/dev/null'>}
                                  )
                                ]
                                do_fork: T
                              )
                          )
                        }
                      spids: [2803]
                    )
                  ]
                )
                (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$rev'))})
              ]
            )
        )
    )
    (command.ShFunction
      name: fetch_in_submodule
      body: 
        (command.Subshell
          child: 
            (command.AndOr
              ops: [Id.Op_DAmp Id.Op_DAmp]
              children: [
                (C {<sanitize_submodule_env>})
                (C {<cd>} {(DQ ($ Id.VSub_Number '$1'))})
                (command.Case
                  to_match: {(DQ ($ Id.VSub_Number '$2'))}
                  arms: [
                    (case_arm
                      pat_list: [{(SQ )}]
                      action: [(C {<git>} {<fetch>})]
                      spids: [2870 2872 2879 -1]
                    )
                    (case_arm
                      pat_list: [{<Id.Lit_Star '*'>}]
                      action: [
                        (C {<shift>})
                        (C {<git>} {<fetch>} 
                          {
                            (command_sub
                              left_token: <Id.Left_DollarParen '$('>
                              child: (C {<get_default_remote>})
                            )
                          } {(DQ ($ Id.VSub_At '$@'))}
                        )
                      ]
                      spids: [2882 2883 2901 -1]
                    )
                  ]
                )
              ]
            )
        )
    )
    (command.ShFunction
      name: cmd_update
      body: 
        (BraceGroup
          children: [
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: (condition.Shell commands:[(C {<test>} {($ Id.VSub_Pound '$#')} {<-ne>} {<0>})])
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_Number '$1'))}
                      arms: [
                        (case_arm
                          pat_list: [{<-q>} {<--quiet>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:GIT_QUIET)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [2964]
                                )
                              ]
                            )
                          ]
                          spids: [2958 2961 2968 -1]
                        )
                        (case_arm
                          pat_list: [{<--progress>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:progress)
                                  op: assign_op.Equal
                                  rhs: {(DQ <--progress>)}
                                  spids: [2975]
                                )
                              ]
                            )
                          ]
                          spids: [2971 2972 2981 -1]
                        )
                        (case_arm
                          pat_list: [{<-i>} {<--init>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:init)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [2990]
                                )
                              ]
                            )
                          ]
                          spids: [2984 2987 2994 -1]
                        )
                        (case_arm
                          pat_list: [{<--remote>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:remote)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [3001]
                                )
                              ]
                            )
                          ]
                          spids: [2997 2998 3005 -1]
                        )
                        (case_arm
                          pat_list: [{<-N>} {<--no-fetch>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:nofetch)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [3014]
                                )
                              ]
                            )
                          ]
                          spids: [3008 3011 3018 -1]
                        )
                        (case_arm
                          pat_list: [{<-f>} {<--force>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:force)
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_Number '$1')}
                                  spids: [3027]
                                )
                              ]
                            )
                          ]
                          spids: [3021 3024 3031 -1]
                        )
                        (case_arm
                          pat_list: [{<-r>} {<--rebase>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:update)
                                  op: assign_op.Equal
                                  rhs: {(DQ <rebase>)}
                                  spids: [3040]
                                )
                              ]
                            )
                          ]
                          spids: [3034 3037 3046 -1]
                        )
                        (case_arm
                          pat_list: [{<--reference>}]
                          action: [
                            (command.Case
                              to_match: {(DQ ($ Id.VSub_Number '$2'))}
                              arms: [
                                (case_arm
                                  pat_list: [{(SQ )}]
                                  action: [(C {<usage>})]
                                  spids: [3061 3063 3067 -1]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:reference)
                                  op: assign_op.Equal
                                  rhs: {(DQ <'--reference='> ($ Id.VSub_Number '$2'))}
                                  spids: [3072]
                                )
                              ]
                            )
                            (C {<shift>})
                          ]
                          spids: [3049 3050 3082 -1]
                        )
                        (case_arm
                          pat_list: [{<--reference> <Id.Lit_Equals '='> <Id.Lit_Star '*'>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:reference)
                                  op: assign_op.Equal
                                  rhs: {(DQ ($ Id.VSub_Number '$1'))}
                                  spids: [3091]
                                )
                              ]
                            )
                          ]
                          spids: [3085 3088 3097 -1]
                        )
                        (case_arm
                          pat_list: [{<-m>} {<--merge>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:update)
                                  op: assign_op.Equal
                                  rhs: {(DQ <merge>)}
                                  spids: [3106]
                                )
                              ]
                            )
                          ]
                          spids: [3100 3103 3112 -1]
                        )
                        (case_arm
                          pat_list: [{<--recursive>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:recursive)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [3119]
                                )
                              ]
                            )
                          ]
                          spids: [3115 3116 3123 -1]
                        )
                        (case_arm
                          pat_list: [{<--checkout>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:update)
                                  op: assign_op.Equal
                                  rhs: {(DQ <checkout>)}
                                  spids: [3130]
                                )
                              ]
                            )
                          ]
                          spids: [3126 3127 3136 -1]
                        )
                        (case_arm
                          pat_list: [{<--recommend-shallow>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:recommend_shallow)
                                  op: assign_op.Equal
                                  rhs: {(DQ <--recommend-shallow>)}
                                  spids: [3143]
                                )
                              ]
                            )
                          ]
                          spids: [3139 3140 3149 -1]
                        )
                        (case_arm
                          pat_list: [{<--no-recommend-shallow>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:recommend_shallow)
                                  op: assign_op.Equal
                                  rhs: {(DQ <--no-recommend-shallow>)}
                                  spids: [3156]
                                )
                              ]
                            )
                          ]
                          spids: [3152 3153 3162 -1]
                        )
                        (case_arm
                          pat_list: [{<--depth>}]
                          action: [
                            (command.Case
                              to_match: {(DQ ($ Id.VSub_Number '$2'))}
                              arms: [
                                (case_arm
                                  pat_list: [{(SQ )}]
                                  action: [(C {<usage>})]
                                  spids: [3177 3179 3183 -1]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:depth)
                                  op: assign_op.Equal
                                  rhs: {(DQ <'--depth='> ($ Id.VSub_Number '$2'))}
                                  spids: [3188]
                                )
                              ]
                            )
                            (C {<shift>})
                          ]
                          spids: [3165 3166 3198 -1]
                        )
                        (case_arm
                          pat_list: [{<--depth> <Id.Lit_Equals '='> <Id.Lit_Star '*'>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:depth)
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_Number '$1')}
                                  spids: [3207]
                                )
                              ]
                            )
                          ]
                          spids: [3201 3204 3211 -1]
                        )
                        (case_arm
                          pat_list: [{<-j>} {<--jobs>}]
                          action: [
                            (command.Case
                              to_match: {(DQ ($ Id.VSub_Number '$2'))}
                              arms: [
                                (case_arm
                                  pat_list: [{(SQ )}]
                                  action: [(C {<usage>})]
                                  spids: [3228 3230 3234 -1]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:jobs)
                                  op: assign_op.Equal
                                  rhs: {(DQ <'--jobs='> ($ Id.VSub_Number '$2'))}
                                  spids: [3239]
                                )
                              ]
                            )
                            (C {<shift>})
                          ]
                          spids: [3214 3217 3249 -1]
                        )
                        (case_arm
                          pat_list: [{<--jobs> <Id.Lit_Equals '='> <Id.Lit_Star '*'>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:jobs)
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_Number '$1')}
                                  spids: [3258]
                                )
                              ]
                            )
                          ]
                          spids: [3252 3255 3262 -1]
                        )
                        (case_arm
                          pat_list: [{<-->}]
                          action: [
                            (C {<shift>})
                            (command.ControlFlow
                              token: <Id.ControlFlow_Break break>
                            )
                          ]
                          spids: [3265 3266 3275 -1]
                        )
                        (case_arm
                          pat_list: [{<-> <Id.Lit_Star '*'>}]
                          action: [(C {<usage>})]
                          spids: [3278 3280 3286 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [(command.ControlFlow token:<Id.ControlFlow_Break break>)]
                          spids: [3289 3290 3296 -1]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                )
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [(C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$init'))})]
                    )
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<cmd_init>} {(DQ <-->)} {(DQ ($ Id.VSub_At '$@'))})
                        (command.ControlFlow
                          token: <Id.ControlFlow_Return return>
                        )
                      ]
                    )
                  ]
                  spids: [3309 3320]
                )
              ]
            )
            (command.Pipeline
              children: [
                (BraceGroup
                  children: [
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<git>} {<submodule--helper>} {<update-clone>} 
                          {
                            (braced_var_sub
                              token: <Id.VSub_Name GIT_QUIET>
                              suffix_op: 
                                (suffix_op.Unary
                                  tok: <Id.VTest_ColonPlus ':+'>
                                  arg_word: {<--quiet>}
                                )
                            )
                          } 
                          {
                            (braced_var_sub
                              token: <Id.VSub_Name progress>
                              suffix_op: 
                                (suffix_op.Unary
                                  tok: <Id.VTest_ColonPlus ':+'>
                                  arg_word: {(DQ ($ Id.VSub_DollarName '$progress'))}
                                )
                            )
                          } 
                          {
                            (braced_var_sub
                              token: <Id.VSub_Name wt_prefix>
                              suffix_op: 
                                (suffix_op.Unary
                                  tok: <Id.VTest_ColonPlus ':+'>
                                  arg_word: {<'--prefix '> (DQ ($ Id.VSub_DollarName '$wt_prefix'))}
                                )
                            )
                          } 
                          {
                            (braced_var_sub
                              token: <Id.VSub_Name prefix>
                              suffix_op: 
                                (suffix_op.Unary
                                  tok: <Id.VTest_ColonPlus ':+'>
                                  arg_word: 
                                    {<'--recursive-prefix '> (DQ ($ Id.VSub_DollarName '$prefix'))}
                                )
                            )
                          } 
                          {
                            (braced_var_sub
                              token: <Id.VSub_Name update>
                              suffix_op: 
                                (suffix_op.Unary
                                  tok: <Id.VTest_ColonPlus ':+'>
                                  arg_word: {<'--update '> (DQ ($ Id.VSub_DollarName '$update'))}
                                )
                            )
                          } 
                          {
                            (braced_var_sub
                              token: <Id.VSub_Name reference>
                              suffix_op: 
                                (suffix_op.Unary
                                  tok: <Id.VTest_ColonPlus ':+'>
                                  arg_word: {(DQ ($ Id.VSub_DollarName '$reference'))}
                                )
                            )
                          } 
                          {
                            (braced_var_sub
                              token: <Id.VSub_Name depth>
                              suffix_op: 
                                (suffix_op.Unary
                                  tok: <Id.VTest_ColonPlus ':+'>
                                  arg_word: {<'--depth '> (DQ ($ Id.VSub_DollarName '$depth'))}
                                )
                            )
                          } 
                          {
                            (braced_var_sub
                              token: <Id.VSub_Name recommend_shallow>
                              suffix_op: 
                                (suffix_op.Unary
                                  tok: <Id.VTest_ColonPlus ':+'>
                                  arg_word: {(DQ ($ Id.VSub_DollarName '$recommend_shallow'))}
                                )
                            )
                          } 
                          {
                            (braced_var_sub
                              token: <Id.VSub_Name jobs>
                              suffix_op: 
                                (suffix_op.Unary
                                  tok: <Id.VTest_ColonPlus ':+'>
                                  arg_word: {($ Id.VSub_DollarName '$jobs')}
                                )
                            )
                          } {(DQ ($ Id.VSub_At '$@'))}
                        )
                        (C {<echo>} {(DQ <'#unmatched'>)} {($ Id.VSub_QMark '$?')})
                      ]
                    )
                  ]
                )
                (BraceGroup
                  children: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:err)
                          op: assign_op.Equal
                          rhs: (word.Empty)
                          spids: [3463]
                        )
                      ]
                    )
                    (command.WhileUntil
                      keyword: <Id.KW_While while>
                      cond: 
                        (condition.Shell
                          commands: [
                            (C {<read>} {<mode>} {<sha1>} {<stage>} {<just_cloned>} {<sm_path>})
                          ]
                        )
                      body: 
                        (command.DoGroup
                          children: [
                            (C {<die_if_unmatched>} {(DQ ($ Id.VSub_DollarName '$mode'))} 
                              {(DQ ($ Id.VSub_DollarName '$sha1'))}
                            )
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:name)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            child: 
                                              (C {<git>} {<submodule--helper>} {<name>} 
                                                {(DQ ($ Id.VSub_DollarName '$sm_path'))}
                                              )
                                          )
                                        }
                                      spids: [3496]
                                    )
                                  ]
                                )
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Exit exit>
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:url)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (C {<git>} {<config>} 
                                            {<submodule.> (DQ ($ Id.VSub_DollarName '$name')) <.url>}
                                          )
                                      )
                                    }
                                  spids: [3514]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.Pipeline
                                          children: [
                                            (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$update'))})
                                          ]
                                          negated: T
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:update_module)
                                          op: assign_op.Equal
                                          rhs: {($ Id.VSub_DollarName '$update')}
                                          spids: [3544]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [3528 3541]
                                )
                              ]
                              else_action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:update_module)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            child: 
                                              (C {<git>} {<config>} 
                                                {<submodule.> (DQ ($ Id.VSub_DollarName '$name')) 
                                                  <.update>
                                                }
                                              )
                                          )
                                        }
                                      spids: [3551]
                                    )
                                  ]
                                )
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: 
                                        (condition.Shell
                                          commands: [
                                            (C {<test>} {<-z>} 
                                              {(DQ ($ Id.VSub_DollarName '$update_module'))}
                                            )
                                          ]
                                        )
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:update_module)
                                              op: assign_op.Equal
                                              rhs: {(DQ <checkout>)}
                                              spids: [3579]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [3565 3576]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:displaypath)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (C {<git>} {<submodule--helper>} {<relative-path>} 
                                            {
                                              (DQ ($ Id.VSub_DollarName '$prefix') 
                                                ($ Id.VSub_DollarName '$sm_path')
                                              )
                                            } {(DQ ($ Id.VSub_DollarName '$wt_prefix'))}
                                          )
                                      )
                                    }
                                  spids: [3592]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (C {<test>} {($ Id.VSub_DollarName '$just_cloned')} {<-eq>} {<1>})
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:subsha1)
                                          op: assign_op.Equal
                                          rhs: (word.Empty)
                                          spids: [3626]
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:update_module)
                                          op: assign_op.Equal
                                          rhs: {<checkout>}
                                          spids: [3629]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [3612 3623]
                                )
                              ]
                              else_action: [
                                (command.AndOr
                                  ops: [Id.Op_DPipe]
                                  children: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:subsha1)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Id.Left_DollarParen '$('>
                                                child: 
                                                  (command.CommandList
                                                    children: [
                                                      (command.Sentence
                                                        child: (C {<sanitize_submodule_env>})
                                                        terminator: <Id.Op_Semi _>
                                                      )
                                                      (command.AndOr
                                                        ops: [Id.Op_DAmp]
                                                        children: [
                                                          (C {<cd>} 
                                                            {(DQ ($ Id.VSub_DollarName '$sm_path'))}
                                                          )
                                                          (C {<git>} {<rev-parse>} {<--verify>} {<HEAD>})
                                                        ]
                                                      )
                                                    ]
                                                  )
                                              )
                                            }
                                          spids: [3636]
                                        )
                                      ]
                                    )
                                    (C {<die>} 
                                      {
                                        (DQ 
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            child: 
                                              (C {<eval_gettext>} 
                                                {
                                                  (DQ 
                                                    <
'Unable to find current revision in submodule path \''
                                                    > (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'displaypath\''>
                                                  )
                                                }
                                              )
                                          )
                                        )
                                      }
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$remote'))})
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:branch)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Id.Left_DollarParen '$('>
                                                child: 
                                                  (C {<git>} {<submodule--helper>} {<remote-branch>} 
                                                    {(DQ ($ Id.VSub_DollarName '$sm_path'))}
                                                  )
                                              )
                                            }
                                          spids: [3695]
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: 
                                            (condition.Shell
                                              commands: [
                                                (C {<test>} {<-z>} 
                                                  {(DQ ($ Id.VSub_DollarName '$nofetch'))}
                                                )
                                              ]
                                            )
                                          action: [
                                            (command.AndOr
                                              ops: [Id.Op_DPipe]
                                              children: [
                                                (C {<fetch_in_submodule>} 
                                                  {(DQ ($ Id.VSub_DollarName '$sm_path'))} {($ Id.VSub_DollarName '$depth')}
                                                )
                                                (C {<die>} 
                                                  {
                                                    (DQ 
                                                      (command_sub
                                                        left_token: <Id.Left_DollarParen '$('>
                                                        child: 
                                                          (C {<eval_gettext>} 
                                                            {
                                                              (DQ 
                                                                <
'Unable to fetch in submodule path \''
                                                                > (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'sm_path\''>
                                                              )
                                                            }
                                                          )
                                                      )
                                                    )
                                                  }
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [3709 3720]
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:remote_name)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Id.Left_DollarParen '$('>
                                                child: 
                                                  (command.CommandList
                                                    children: [
                                                      (command.Sentence
                                                        child: (C {<sanitize_submodule_env>})
                                                        terminator: <Id.Op_Semi _>
                                                      )
                                                      (command.AndOr
                                                        ops: [Id.Op_DAmp]
                                                        children: [
                                                          (C {<cd>} 
                                                            {(DQ ($ Id.VSub_DollarName '$sm_path'))}
                                                          )
                                                          (C {<get_default_remote>})
                                                        ]
                                                      )
                                                    ]
                                                  )
                                              )
                                            }
                                          spids: [3756]
                                        )
                                      ]
                                    )
                                    (command.AndOr
                                      ops: [Id.Op_DPipe]
                                      children: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:sha1)
                                              op: assign_op.Equal
                                              rhs: 
                                                {
                                                  (command_sub
                                                    left_token: <Id.Left_DollarParen '$('>
                                                    child: 
                                                      (command.CommandList
                                                        children: [
                                                          (command.Sentence
                                                            child: (C {<sanitize_submodule_env>})
                                                            terminator: <Id.Op_Semi _>
                                                          )
                                                          (command.AndOr
                                                            ops: [Id.Op_DAmp]
                                                            children: [
                                                              (C {<cd>} 
                                                                {
                                                                  (DQ 
                                                                    ($ Id.VSub_DollarName '$sm_path')
                                                                  )
                                                                }
                                                              )
                                                              (C {<git>} {<rev-parse>} {<--verify>} 
                                                                {
                                                                  (DQ (${ Id.VSub_Name remote_name) 
                                                                    <'/'> (${ Id.VSub_Name branch)
                                                                  )
                                                                }
                                                              )
                                                            ]
                                                          )
                                                        ]
                                                      )
                                                  )
                                                }
                                              spids: [3773]
                                            )
                                          ]
                                        )
                                        (C {<die>} 
                                          {
                                            (DQ 
                                              (command_sub
                                                left_token: <Id.Left_DollarParen '$('>
                                                child: 
                                                  (C {<eval_gettext>} 
                                                    {
                                                      (DQ <'Unable to find current '> 
                                                        (word_part.EscapedLiteral
                                                          token: <Id.Lit_EscapedChar '\\$'>
                                                        ) <'{remote_name}/'> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) 
                                                        <'{branch} revision in submodule path \''> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'sm_path\''>
                                                      )
                                                    }
                                                  )
                                              )
                                            )
                                          }
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [3681 3692]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.AndOr
                                          ops: [Id.Op_DPipe]
                                          children: [
                                            (C {<test>} {(DQ ($ Id.VSub_DollarName '$subsha1'))} 
                                              {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {(DQ ($ Id.VSub_DollarName '$sha1'))}
                                            )
                                            (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$force'))})
                                          ]
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:subforce)
                                          op: assign_op.Equal
                                          rhs: {($ Id.VSub_DollarName '$force')}
                                          spids: [3859]
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: 
                                            (condition.Shell
                                              commands: [
                                                (command.AndOr
                                                  ops: [Id.Op_DAmp]
                                                  children: [
                                                    (C {<test>} {<-z>} 
                                                      {(DQ ($ Id.VSub_DollarName '$subsha1'))}
                                                    )
                                                    (C {<test>} {<-z>} 
                                                      {(DQ ($ Id.VSub_DollarName '$force'))}
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:subforce)
                                                  op: assign_op.Equal
                                                  rhs: {(DQ <-f>)}
                                                  spids: [3891]
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [3867 3888]
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: 
                                            (condition.Shell
                                              commands: [
                                                (C {<test>} {<-z>} 
                                                  {(DQ ($ Id.VSub_DollarName '$nofetch'))}
                                                )
                                              ]
                                            )
                                          action: [
                                            (command.AndOr
                                              ops: [Id.Op_DPipe Id.Op_DPipe]
                                              children: [
                                                (C {<is_tip_reachable>} 
                                                  {(DQ ($ Id.VSub_DollarName '$sm_path'))} {(DQ ($ Id.VSub_DollarName '$sha1'))}
                                                )
                                                (C {<fetch_in_submodule>} 
                                                  {(DQ ($ Id.VSub_DollarName '$sm_path'))} {($ Id.VSub_DollarName '$depth')}
                                                )
                                                (C {<die>} 
                                                  {
                                                    (DQ 
                                                      (command_sub
                                                        left_token: <Id.Left_DollarParen '$('>
                                                        child: 
                                                          (C {<eval_gettext>} 
                                                            {
                                                              (DQ 
                                                                <
'Unable to fetch in submodule path \''
                                                                > (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'displaypath\''>
                                                              )
                                                            }
                                                          )
                                                      )
                                                    )
                                                  }
                                                )
                                              ]
                                            )
                                            (command.AndOr
                                              ops: [Id.Op_DPipe Id.Op_DPipe]
                                              children: [
                                                (C {<is_tip_reachable>} 
                                                  {(DQ ($ Id.VSub_DollarName '$sm_path'))} {(DQ ($ Id.VSub_DollarName '$sha1'))}
                                                )
                                                (C {<fetch_in_submodule>} 
                                                  {(DQ ($ Id.VSub_DollarName '$sm_path'))} {($ Id.VSub_DollarName '$depth')} {(DQ ($ Id.VSub_DollarName '$sha1'))}
                                                )
                                                (C {<die>} 
                                                  {
                                                    (DQ 
                                                      (command_sub
                                                        left_token: <Id.Left_DollarParen '$('>
                                                        child: 
                                                          (C {<eval_gettext>} 
                                                            {
                                                              (DQ <'Fetched in submodule path \''> 
                                                                (word_part.EscapedLiteral
                                                                  token: <Id.Lit_EscapedChar '\\$'>
                                                                ) <'displaypath\', but it did not contain '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) 
                                                                <
'sha1. Direct fetching of that commit failed.'
                                                                >
                                                              )
                                                            }
                                                          )
                                                      )
                                                    )
                                                  }
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [3901 3912]
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:must_die_on_failure)
                                          op: assign_op.Equal
                                          rhs: (word.Empty)
                                          spids: [4020]
                                        )
                                      ]
                                    )
                                    (command.Case
                                      to_match: {(DQ ($ Id.VSub_DollarName '$update_module'))}
                                      arms: [
                                        (case_arm
                                          pat_list: [{<checkout>}]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:command)
                                                  op: assign_op.Equal
                                                  rhs: 
                                                    {
                                                      (DQ <'git checkout '> 
                                                        ($ Id.VSub_DollarName '$subforce') <' -q'>
                                                      )
                                                    }
                                                  spids: [4036]
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:die_msg)
                                                  op: assign_op.Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (command_sub
                                                          left_token: <Id.Left_DollarParen '$('>
                                                          child: 
                                                            (C {<eval_gettext>} 
                                                              {
                                                                (DQ <'Unable to checkout \''> 
                                                                  (word_part.EscapedLiteral
                                                                    token: <Id.Lit_EscapedChar '\\$'>
                                                                  ) <'sha1\' in submodule path \''> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) 
                                                                  <'displaypath\''>
                                                                )
                                                              }
                                                            )
                                                        )
                                                      )
                                                    }
                                                  spids: [4044]
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:say_msg)
                                                  op: assign_op.Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (command_sub
                                                          left_token: <Id.Left_DollarParen '$('>
                                                          child: 
                                                            (C {<eval_gettext>} 
                                                              {
                                                                (DQ <'Submodule path \''> 
                                                                  (word_part.EscapedLiteral
                                                                    token: <Id.Lit_EscapedChar '\\$'>
                                                                  ) <'displaypath\': checked out \''> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) 
                                                                  <'sha1\''>
                                                                )
                                                              }
                                                            )
                                                        )
                                                      )
                                                    }
                                                  spids: [4060]
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [4032 4033 4076 -1]
                                        )
                                        (case_arm
                                          pat_list: [{<rebase>}]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:command)
                                                  op: assign_op.Equal
                                                  rhs: {(DQ <'git rebase'>)}
                                                  spids: [4083]
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:die_msg)
                                                  op: assign_op.Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (command_sub
                                                          left_token: <Id.Left_DollarParen '$('>
                                                          child: 
                                                            (C {<eval_gettext>} 
                                                              {
                                                                (DQ <'Unable to rebase \''> 
                                                                  (word_part.EscapedLiteral
                                                                    token: <Id.Lit_EscapedChar '\\$'>
                                                                  ) <'sha1\' in submodule path \''> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) 
                                                                  <'displaypath\''>
                                                                )
                                                              }
                                                            )
                                                        )
                                                      )
                                                    }
                                                  spids: [4089]
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:say_msg)
                                                  op: assign_op.Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (command_sub
                                                          left_token: <Id.Left_DollarParen '$('>
                                                          child: 
                                                            (C {<eval_gettext>} 
                                                              {
                                                                (DQ <'Submodule path \''> 
                                                                  (word_part.EscapedLiteral
                                                                    token: <Id.Lit_EscapedChar '\\$'>
                                                                  ) <'displaypath\': rebased into \''> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) 
                                                                  <'sha1\''>
                                                                )
                                                              }
                                                            )
                                                        )
                                                      )
                                                    }
                                                  spids: [4105]
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:must_die_on_failure)
                                                  op: assign_op.Equal
                                                  rhs: {<yes>}
                                                  spids: [4121]
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [4079 4080 4125 -1]
                                        )
                                        (case_arm
                                          pat_list: [{<merge>}]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:command)
                                                  op: assign_op.Equal
                                                  rhs: {(DQ <'git merge'>)}
                                                  spids: [4132]
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:die_msg)
                                                  op: assign_op.Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (command_sub
                                                          left_token: <Id.Left_DollarParen '$('>
                                                          child: 
                                                            (C {<eval_gettext>} 
                                                              {
                                                                (DQ <'Unable to merge \''> 
                                                                  (word_part.EscapedLiteral
                                                                    token: <Id.Lit_EscapedChar '\\$'>
                                                                  ) <'sha1\' in submodule path \''> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) 
                                                                  <'displaypath\''>
                                                                )
                                                              }
                                                            )
                                                        )
                                                      )
                                                    }
                                                  spids: [4138]
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:say_msg)
                                                  op: assign_op.Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (command_sub
                                                          left_token: <Id.Left_DollarParen '$('>
                                                          child: 
                                                            (C {<eval_gettext>} 
                                                              {
                                                                (DQ <'Submodule path \''> 
                                                                  (word_part.EscapedLiteral
                                                                    token: <Id.Lit_EscapedChar '\\$'>
                                                                  ) <'displaypath\': merged in \''> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'sha1\''>
                                                                )
                                                              }
                                                            )
                                                        )
                                                      )
                                                    }
                                                  spids: [4154]
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:must_die_on_failure)
                                                  op: assign_op.Equal
                                                  rhs: {<yes>}
                                                  spids: [4170]
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [4128 4129 4174 -1]
                                        )
                                        (case_arm
                                          pat_list: [{<Id.KW_Bang '!'> <Id.Lit_Star '*'>}]
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:command)
                                                  op: assign_op.Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (braced_var_sub
                                                          token: <Id.VSub_Name update_module>
                                                          suffix_op: 
                                                            (suffix_op.Unary
                                                              tok: <Id.VOp1_Pound '#'>
                                                              arg_word: {<Id.Lit_Other '!'>}
                                                            )
                                                        )
                                                      )
                                                    }
                                                  spids: [4182]
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:die_msg)
                                                  op: assign_op.Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (command_sub
                                                          left_token: <Id.Left_DollarParen '$('>
                                                          child: 
                                                            (C {<eval_gettext>} 
                                                              {
                                                                (DQ <'Execution of \''> 
                                                                  (word_part.EscapedLiteral
                                                                    token: <Id.Lit_EscapedChar '\\$'>
                                                                  ) <'command '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) 
                                                                  <
'sha1\' failed in submodule path \''
                                                                  > (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'displaypath\''>
                                                                )
                                                              }
                                                            )
                                                        )
                                                      )
                                                    }
                                                  spids: [4192]
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:say_msg)
                                                  op: assign_op.Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (command_sub
                                                          left_token: <Id.Left_DollarParen '$('>
                                                          child: 
                                                            (C {<eval_gettext>} 
                                                              {
                                                                (DQ <'Submodule path \''> 
                                                                  (word_part.EscapedLiteral
                                                                    token: <Id.Lit_EscapedChar '\\$'>
                                                                  ) <'displaypath\': \''> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'command '> 
                                                                  (word_part.EscapedLiteral
                                                                    token: <Id.Lit_EscapedChar '\\$'>
                                                                  ) <'sha1\''>
                                                                )
                                                              }
                                                            )
                                                        )
                                                      )
                                                    }
                                                  spids: [4210]
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:must_die_on_failure)
                                                  op: assign_op.Equal
                                                  rhs: {<yes>}
                                                  spids: [4228]
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [4177 4179 4232 -1]
                                        )
                                        (case_arm
                                          pat_list: [{<Id.Lit_Star '*'>}]
                                          action: [
                                            (C {<die>} 
                                              {
                                                (DQ 
                                                  (command_sub
                                                    left_token: <Id.Left_DollarParen '$('>
                                                    child: 
                                                      (C {<eval_gettext>} 
                                                        {
                                                          (DQ <'Invalid update mode \''> 
                                                            ($ Id.VSub_DollarName '$update_module') <'\' for submodule \''> ($ Id.VSub_DollarName '$name') <'\''>
                                                          )
                                                        }
                                                      )
                                                  )
                                                )
                                              }
                                            )
                                          ]
                                          spids: [4235 4236 -1 4256]
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: 
                                            (condition.Shell
                                              commands: [
                                                (command.Subshell
                                                  child: 
                                                    (command.CommandList
                                                      children: [
                                                        (command.Sentence
                                                          child: (C {<sanitize_submodule_env>})
                                                          terminator: <Id.Op_Semi _>
                                                        )
                                                        (command.AndOr
                                                          ops: [Id.Op_DAmp]
                                                          children: [
                                                            (C {<cd>} 
                                                              {(DQ ($ Id.VSub_DollarName '$sm_path'))}
                                                            )
                                                            (C {($ Id.VSub_DollarName '$command')} 
                                                              {(DQ ($ Id.VSub_DollarName '$sha1'))}
                                                            )
                                                          ]
                                                        )
                                                      ]
                                                    )
                                                )
                                              ]
                                            )
                                          action: [(C {<say>} {(DQ ($ Id.VSub_DollarName '$say_msg'))})]
                                          spids: [4260 4282]
                                        )
                                        (if_arm
                                          cond: 
                                            (condition.Shell
                                              commands: [
                                                (C {<test>} {<-n>} 
                                                  {(DQ ($ Id.VSub_DollarName '$must_die_on_failure'))}
                                                )
                                              ]
                                            )
                                          action: [
                                            (C {<die_with_status>} {<2>} 
                                              {(DQ ($ Id.VSub_DollarName '$die_msg'))}
                                            )
                                          ]
                                          spids: [4292 4303]
                                        )
                                      ]
                                      else_action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:err)
                                              op: assign_op.Equal
                                              rhs: 
                                                {
                                                  (DQ (${ Id.VSub_Name err) <';'> 
                                                    ($ Id.VSub_DollarName '$die_msg')
                                                  )
                                                }
                                              spids: [4318]
                                            )
                                          ]
                                        )
                                        (command.ControlFlow
                                          token: <Id.ControlFlow_Continue continue>
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [3830 3856]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$recursive'))})
                                      ]
                                    )
                                  action: [
                                    (command.Subshell
                                      child: 
                                        (command.CommandList
                                          children: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:prefix)
                                                  op: assign_op.Equal
                                                  rhs: 
                                                    {
                                                      (command_sub
                                                        left_token: <Id.Left_DollarParen '$('>
                                                        child: 
                                                          (C {<git>} {<submodule--helper>} 
                                                            {<relative-path>} {(DQ ($ Id.VSub_DollarName '$prefix') ($ Id.VSub_DollarName '$sm_path') <'/'>)} 
                                                            {(DQ ($ Id.VSub_DollarName '$wt_prefix'))}
                                                          )
                                                      )
                                                    }
                                                  spids: [4355]
                                                )
                                              ]
                                            )
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:wt_prefix)
                                                  op: assign_op.Equal
                                                  rhs: (word.Empty)
                                                  spids: [4375]
                                                )
                                              ]
                                            )
                                            (C {<sanitize_submodule_env>})
                                            (command.AndOr
                                              ops: [Id.Op_DAmp]
                                              children: [
                                                (C {<cd>} {(DQ ($ Id.VSub_DollarName '$sm_path'))})
                                                (C {<eval>} {<cmd_update>})
                                              ]
                                            )
                                          ]
                                        )
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:res)
                                          op: assign_op.Equal
                                          rhs: {($ Id.VSub_QMark '$?')}
                                          spids: [4398]
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: 
                                            (condition.Shell
                                              commands: [
                                                (C {<test>} {($ Id.VSub_DollarName '$res')} {<-gt>} {<0>})
                                              ]
                                            )
                                          action: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:die_msg)
                                                  op: assign_op.Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (command_sub
                                                          left_token: <Id.Left_DollarParen '$('>
                                                          child: 
                                                            (C {<eval_gettext>} 
                                                              {
                                                                (DQ 
                                                                  <
'Failed to recurse into submodule path \''
                                                                  > (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <'displaypath\''>
                                                                )
                                                              }
                                                            )
                                                        )
                                                      )
                                                    }
                                                  spids: [4416]
                                                )
                                              ]
                                            )
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: 
                                                    (condition.Shell
                                                      commands: [
                                                        (C {<test>} {($ Id.VSub_DollarName '$res')} 
                                                          {<-ne>} {<2>}
                                                        )
                                                      ]
                                                    )
                                                  action: [
                                                    (command.ShAssignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (sh_lhs_expr.Name name:err)
                                                          op: assign_op.Equal
                                                          rhs: 
                                                            {
                                                              (DQ (${ Id.VSub_Name err) <';'> 
                                                                ($ Id.VSub_DollarName '$die_msg')
                                                              )
                                                            }
                                                          spids: [4444]
                                                        )
                                                      ]
                                                    )
                                                    (command.ControlFlow
                                                      token: <Id.ControlFlow_Continue continue>
                                                    )
                                                  ]
                                                  spids: [4430 4441]
                                                )
                                              ]
                                              else_action: [
                                                (C {<die_with_status>} {($ Id.VSub_DollarName '$res')} 
                                                  {(DQ ($ Id.VSub_DollarName '$die_msg'))}
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [4402 4413]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [4338 4349]
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: 
                            (condition.Shell
                              commands: [(C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$err'))})]
                            )
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:OIFS)
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_DollarName '$IFS')}
                                  spids: [4496]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:IFS)
                                  op: assign_op.Equal
                                  rhs: {(SQ <';'>)}
                                  spids: [4500]
                                )
                              ]
                            )
                            (command.ForEach
                              iter_name: e
                              iter_words: [{($ Id.VSub_DollarName '$err')}]
                              do_arg_iter: F
                              body: 
                                (command.DoGroup
                                  children: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: 
                                            (condition.Shell
                                              commands: [
                                                (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$e'))})
                                              ]
                                            )
                                          action: [
                                            (command.Simple
                                              words: [{<echo>} {(DQ ($ Id.VSub_DollarName '$e'))}]
                                              redirects: [
                                                (redir
                                                  op: <Id.Redir_GreatAnd '>&'>
                                                  loc: (redir_loc.Fd fd:1)
                                                  arg: {<2>}
                                                )
                                              ]
                                              do_fork: T
                                            )
                                          ]
                                          spids: [4518 4529]
                                        )
                                      ]
                                    )
                                  ]
                                )
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:IFS)
                                  op: assign_op.Equal
                                  rhs: {($ Id.VSub_DollarName '$OIFS')}
                                  spids: [4548]
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Exit exit>
                              arg_word: {<1>}
                            )
                          ]
                          spids: [4482 4493]
                        )
                      ]
                    )
                  ]
                )
              ]
              negated: F
            )
          ]
        )
    )
    (command.ShFunction
      name: set_name_rev
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:revname)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (command.Subshell
                            child: 
                              (command.CommandList
                                children: [
                                  (C {<sanitize_submodule_env>})
                                  (command.AndOr
                                    ops: [Id.Op_DAmp]
                                    children: [
                                      (C {<cd>} {(DQ ($ Id.VSub_Number '$1'))})
                                      (BraceGroup
                                        children: [
                                          (command.AndOr
                                            ops: [Id.Op_DPipe Id.Op_DPipe Id.Op_DPipe]
                                            children: [
                                              (command.Simple
                                                words: [
                                                  {<git>}
                                                  {<describe>}
                                                  {(DQ ($ Id.VSub_Number '$2'))}
                                                ]
                                                redirects: [
                                                  (redir
                                                    op: <Id.Redir_Great '2>'>
                                                    loc: (redir_loc.Fd fd:2)
                                                    arg: {<'/dev/null'>}
                                                  )
                                                ]
                                                do_fork: T
                                              )
                                              (command.Simple
                                                words: [
                                                  {<git>}
                                                  {<describe>}
                                                  {<--tags>}
                                                  {(DQ ($ Id.VSub_Number '$2'))}
                                                ]
                                                redirects: [
                                                  (redir
                                                    op: <Id.Redir_Great '2>'>
                                                    loc: (redir_loc.Fd fd:2)
                                                    arg: {<'/dev/null'>}
                                                  )
                                                ]
                                                do_fork: T
                                              )
                                              (command.Simple
                                                words: [
                                                  {<git>}
                                                  {<describe>}
                                                  {<--contains>}
                                                  {(DQ ($ Id.VSub_Number '$2'))}
                                                ]
                                                redirects: [
                                                  (redir
                                                    op: <Id.Redir_Great '2>'>
                                                    loc: (redir_loc.Fd fd:2)
                                                    arg: {<'/dev/null'>}
                                                  )
                                                ]
                                                do_fork: T
                                              )
                                              (C {<git>} {<describe>} {<--all>} {<--always>} 
                                                {(DQ ($ Id.VSub_Number '$2'))}
                                              )
                                            ]
                                          )
                                        ]
                                      )
                                    ]
                                  )
                                ]
                              )
                          )
                      )
                    }
                  spids: [4573]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$revname'))})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:revname)
                      op: assign_op.Equal
                      rhs: {(DQ <' ('> ($ Id.VSub_DollarName '$revname') <')'>)}
                      spids: [4670]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: cmd_summary
      body: 
        (BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:summary_limit)
                  op: assign_op.Equal
                  rhs: {<-1>}
                  spids: [4710]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:for_status)
                  op: assign_op.Equal
                  rhs: (word.Empty)
                  spids: [4714]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:diff_cmd)
                  op: assign_op.Equal
                  rhs: {<diff-index>}
                  spids: [4717]
                )
              ]
            )
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: (condition.Shell commands:[(C {<test>} {($ Id.VSub_Pound '$#')} {<-ne>} {<0>})])
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_Number '$1'))}
                      arms: [
                        (case_arm
                          pat_list: [{<--cached>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:cached)
                                  op: assign_op.Equal
                                  rhs: {(DQ ($ Id.VSub_Number '$1'))}
                                  spids: [4753]
                                )
                              ]
                            )
                          ]
                          spids: [4749 4750 4759 -1]
                        )
                        (case_arm
                          pat_list: [{<--files>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:files)
                                  op: assign_op.Equal
                                  rhs: {(DQ ($ Id.VSub_Number '$1'))}
                                  spids: [4766]
                                )
                              ]
                            )
                          ]
                          spids: [4762 4763 4772 -1]
                        )
                        (case_arm
                          pat_list: [{<--for-status>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:for_status)
                                  op: assign_op.Equal
                                  rhs: {(DQ ($ Id.VSub_Number '$1'))}
                                  spids: [4779]
                                )
                              ]
                            )
                          ]
                          spids: [4775 4776 4785 -1]
                        )
                        (case_arm
                          pat_list: [{<-n>} {<--summary-limit>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:summary_limit)
                                  op: assign_op.Equal
                                  rhs: {(DQ ($ Id.VSub_Number '$2'))}
                                  spids: [4794]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (C {<isnumber>} {(DQ ($ Id.VSub_DollarName '$summary_limit'))})
                                (C {<usage>})
                              ]
                            )
                            (C {<shift>})
                          ]
                          spids: [4788 4791 4814 -1]
                        )
                        (case_arm
                          pat_list: [{<--summary-limit> <Id.Lit_Equals '='> <Id.Lit_Star '*'>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:summary_limit)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (braced_var_sub
                                          token: <Id.VSub_Number 1>
                                          suffix_op: 
                                            (suffix_op.Unary
                                              tok: <Id.VOp1_Pound '#'>
                                              arg_word: {<'--summary-limit='>}
                                            )
                                        )
                                      )
                                    }
                                  spids: [4823]
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Id.Op_DPipe]
                              children: [
                                (C {<isnumber>} {(DQ ($ Id.VSub_DollarName '$summary_limit'))})
                                (C {<usage>})
                              ]
                            )
                          ]
                          spids: [4817 4820 4844 -1]
                        )
                        (case_arm
                          pat_list: [{<-->}]
                          action: [
                            (C {<shift>})
                            (command.ControlFlow
                              token: <Id.ControlFlow_Break break>
                            )
                          ]
                          spids: [4847 4848 4857 -1]
                        )
                        (case_arm
                          pat_list: [{<-> <Id.Lit_Star '*'>}]
                          action: [(C {<usage>})]
                          spids: [4860 4862 4868 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [(command.ControlFlow token:<Id.ControlFlow_Break break>)]
                          spids: [4871 4872 4878 -1]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                )
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<test>} {($ Id.VSub_DollarName '$summary_limit')} {<Id.Lit_Equals '='>} {<0>})
                (command.ControlFlow token:<Id.ControlFlow_Return return>)
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:rev)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (C {<git>} {<rev-parse>} {<-q>} {<--verify>} {<--default>} {<HEAD>} 
                                        {
                                          (braced_var_sub
                                            token: <Id.VSub_Number 1>
                                            suffix_op: 
                                              (suffix_op.Unary
                                                tok: <Id.VTest_Plus '+'>
                                                arg_word: {(DQ ($ Id.VSub_Number '$1'))}
                                              )
                                          )
                                        }
                                      )
                                  )
                                }
                              spids: [4907]
                            )
                          ]
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:head)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_DollarName '$rev')}
                          spids: [4934]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<test>} {($ Id.VSub_Pound '$#')} {<Id.Lit_Equals '='>} {<0>})
                        (C {<shift>})
                      ]
                    )
                  ]
                  spids: [4905 4931]
                )
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (command.AndOr
                          ops: [Id.Op_DPipe]
                          children: [
                            (C {<test>} {<-z>} {(DQ ($ Id.VSub_Number '$1'))})
                            (C {<test>} {(DQ ($ Id.VSub_Number '$1'))} {<Id.Lit_Equals '='>} {(DQ <HEAD>)})
                          ]
                        )
                      ]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:head)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (command.Simple
                                    words: [{<git>} {<hash-object>} {<-w>} {<-t>} {<tree>} {<--stdin>}]
                                    redirects: [
                                      (redir
                                        op: <Id.Redir_Less '<'>
                                        loc: (redir_loc.Fd fd:0)
                                        arg: {<'/dev/null'>}
                                      )
                                    ]
                                    do_fork: T
                                  )
                              )
                            }
                          spids: [4983]
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [(C {<test>} {<-z>} {(DQ ($ Id.VSub_Number '$1'))}) (C {<shift>})]
                    )
                  ]
                  spids: [4951 4976]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:head)
                      op: assign_op.Equal
                      rhs: {(DQ <HEAD>)}
                      spids: [5018]
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [
                        (C {<Id.Lit_LBracket '['>} {<-n>} {(DQ ($ Id.VSub_DollarName '$files'))} 
                          {<Id.Lit_RBracket ']'>}
                        )
                      ]
                    )
                  action: [
                    (command.AndOr
                      ops: [Id.Op_DAmp]
                      children: [
                        (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$cached'))})
                        (C {<die>} 
                          {
                            (DQ 
                              (command_sub
                                left_token: <Id.Left_DollarParen '$('>
                                child: 
                                  (C {<gettext>} 
                                    {
                                      (DQ 
                                        <
'The --cached option cannot be used with the --files option'
                                        >
                                      )
                                    }
                                  )
                              )
                            )
                          }
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:diff_cmd)
                          op: assign_op.Equal
                          rhs: {<diff-files>}
                          spids: [5068]
                        )
                      ]
                    )
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:head)
                          op: assign_op.Equal
                          rhs: (word.Empty)
                          spids: [5072]
                        )
                      ]
                    )
                  ]
                  spids: [5028 5041]
                )
              ]
            )
            (C {<cd_to_toplevel>})
            (C {<eval>} 
              {
                (DQ <'set '> 
                  (command_sub
                    left_token: <Id.Left_DollarParen '$('>
                    child: 
                      (C {<git>} {<rev-parse>} {<--sq>} {<--prefix>} 
                        {(DQ ($ Id.VSub_DollarName '$wt_prefix'))} {<-->} {(DQ ($ Id.VSub_At '$@'))}
                      )
                  )
                )
              }
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:modules)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (command_sub
                        left_token: <Id.Left_DollarParen '$('>
                        child: 
                          (command.Pipeline
                            children: [
                              (C {<git>} {($ Id.VSub_DollarName '$diff_cmd')} 
                                {($ Id.VSub_DollarName '$cached')} {<--ignore-submodules> <Id.Lit_Equals '='> <dirty>} {<--raw>} {($ Id.VSub_DollarName '$head')} {<-->} 
                                {(DQ ($ Id.VSub_At '$@'))}
                              )
                              (C {<sane_egrep>} {(SQ <'^:([0-7]* )?160000'>)})
                              (command.WhileUntil
                                keyword: <Id.KW_While while>
                                cond: 
                                  (condition.Shell
                                    commands: [
                                      (C {<read>} {<mod_src>} {<mod_dst>} {<sha1_src>} {<sha1_dst>} 
                                        {<status>} {<sm_path>}
                                      )
                                    ]
                                  )
                                body: 
                                  (command.DoGroup
                                    children: [
                                      (command.If
                                        arms: [
                                          (if_arm
                                            cond: 
                                              (condition.Shell
                                                commands: [
                                                  (command.AndOr
                                                    ops: [Id.Op_DPipe]
                                                    children: [
                                                      (C {<test>} 
                                                        {(DQ ($ Id.VSub_DollarName '$status'))} {<Id.Lit_Equals '='>} {<D>}
                                                      )
                                                      (C {<test>} 
                                                        {(DQ ($ Id.VSub_DollarName '$status'))} {<Id.Lit_Equals '='>} {<T>}
                                                      )
                                                    ]
                                                  )
                                                ]
                                              )
                                            action: [
                                              (C {<printf>} {(SQ <'%s\\n'>)} 
                                                {(DQ ($ Id.VSub_DollarName '$sm_path'))}
                                              )
                                              (command.ControlFlow
                                                token: <Id.ControlFlow_Continue continue>
                                              )
                                            ]
                                            spids: [5170 5195]
                                          )
                                        ]
                                      )
                                      (command.If
                                        arms: [
                                          (if_arm
                                            cond: 
                                              (condition.Shell
                                                commands: [
                                                  (C {<test>} {<-n>} 
                                                    {(DQ ($ Id.VSub_DollarName '$for_status'))}
                                                  )
                                                ]
                                              )
                                            action: [
                                              (command.ShAssignment
                                                pairs: [
                                                  (assign_pair
                                                    lhs: (sh_lhs_expr.Name name:name)
                                                    op: assign_op.Equal
                                                    rhs: 
                                                      {
                                                        (command_sub
                                                          left_token: <Id.Left_DollarParen '$('>
                                                          child: 
                                                            (C {<git>} {<submodule--helper>} {<name>} 
                                                              {(DQ ($ Id.VSub_DollarName '$sm_path'))}
                                                            )
                                                        )
                                                      }
                                                    spids: [5233]
                                                  )
                                                ]
                                              )
                                              (command.ShAssignment
                                                pairs: [
                                                  (assign_pair
                                                    lhs: (sh_lhs_expr.Name name:ignore_config)
                                                    op: assign_op.Equal
                                                    rhs: 
                                                      {
                                                        (command_sub
                                                          left_token: <Id.Left_DollarParen '$('>
                                                          child: 
                                                            (C {<get_submodule_config>} 
                                                              {(DQ ($ Id.VSub_DollarName '$name'))} {<ignore>} {<none>}
                                                            )
                                                        )
                                                      }
                                                    spids: [5247]
                                                  )
                                                ]
                                              )
                                              (command.AndOr
                                                ops: [Id.Op_DAmp Id.Op_DAmp]
                                                children: [
                                                  (C {<test>} {($ Id.VSub_DollarName '$status')} 
                                                    {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<A>}
                                                  )
                                                  (C {<test>} {($ Id.VSub_DollarName '$ignore_config')} 
                                                    {<Id.Lit_Equals '='>} {<all>}
                                                  )
                                                  (command.ControlFlow
                                                    token: <Id.ControlFlow_Continue continue>
                                                  )
                                                ]
                                              )
                                            ]
                                            spids: [5219 5230]
                                          )
                                        ]
                                      )
                                      (command.AndOr
                                        ops: [Id.Op_DAmp]
                                        children: [
                                          (command.Simple
                                            words: [{<git-rev-parse>} {<--git-dir>}]
                                            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>}
                                              )
                                            ]
                                            more_env: [
                                              (env_pair
                                                name: GIT_DIR
                                                val: {(DQ ($ Id.VSub_DollarName '$sm_path') <'/.git'>)}
                                                spids: [5292]
                                              )
                                            ]
                                            do_fork: T
                                          )
                                          (C {<printf>} {(SQ <'%s\\n'>)} 
                                            {(DQ ($ Id.VSub_DollarName '$sm_path'))}
                                          )
                                        ]
                                      )
                                    ]
                                  )
                              )
                            ]
                            negated: F
                          )
                      )
                    }
                  spids: [5112]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$modules'))})
                (command.ControlFlow token:<Id.ControlFlow_Return return>)
              ]
            )
            (command.Pipeline
              children: [
                (C {<git>} {($ Id.VSub_DollarName '$diff_cmd')} {($ Id.VSub_DollarName '$cached')} 
                  {<--ignore-submodules> <Id.Lit_Equals '='> <dirty>} {<--raw>} {($ Id.VSub_DollarName '$head')} {<-->} {($ Id.VSub_DollarName '$modules')}
                )
                (C {<sane_egrep>} {(SQ <'^:([0-7]* )?160000'>)})
                (C {<cut>} {<-c2->})
                (command.WhileUntil
                  keyword: <Id.KW_While while>
                  cond: 
                    (condition.Shell
                      commands: [
                        (C {<read>} {<mod_src>} {<mod_dst>} {<sha1_src>} {<sha1_dst>} {<status>} {<name>})
                      ]
                    )
                  body: 
                    (command.DoGroup
                      children: [
                        (command.If
                          arms: [
                            (if_arm
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.AndOr
                                      ops: [Id.Op_DAmp]
                                      children: [
                                        (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$cached'))})
                                        (C {<test>} {($ Id.VSub_DollarName '$sha1_dst')} 
                                          {<Id.Lit_Equals '='>} {<0000000000000000000000000000000000000000>}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              action: [
                                (command.Case
                                  to_match: {(DQ ($ Id.VSub_DollarName '$mod_dst'))}
                                  arms: [
                                    (case_arm
                                      pat_list: [{<160000>}]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:sha1_dst)
                                              op: assign_op.Equal
                                              rhs: 
                                                {
                                                  (command_sub
                                                    left_token: <Id.Left_DollarParen '$('>
                                                    child: 
                                                      (command.Simple
                                                        words: [{<git>} {<rev-parse>} {<HEAD>}]
                                                        more_env: [
                                                          (env_pair
                                                            name: GIT_DIR
                                                            val: 
                                                              {
                                                                (DQ ($ Id.VSub_DollarName '$name') 
                                                                  <'/.git'>
                                                                )
                                                              }
                                                            spids: [5440]
                                                          )
                                                        ]
                                                        do_fork: T
                                                      )
                                                  )
                                                }
                                              spids: [5438]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [5434 5435 5454 -1]
                                    )
                                    (case_arm
                                      pat_list: [{<100644>} {<100755>} {<120000>}]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:sha1_dst)
                                              op: assign_op.Equal
                                              rhs: 
                                                {
                                                  (command_sub
                                                    left_token: <Id.Left_DollarParen '$('>
                                                    child: 
                                                      (C {<git>} {<hash-object>} 
                                                        {($ Id.VSub_DollarName '$name')}
                                                      )
                                                  )
                                                }
                                              spids: [5469]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [5457 5466 5479 -1]
                                    )
                                    (case_arm
                                      pat_list: [{<000000>}]
                                      spids: [5482 5483 5486 -1]
                                    )
                                    (case_arm
                                      pat_list: [{<Id.Lit_Star '*'>}]
                                      action: [
                                        (command.Simple
                                          words: [
                                            {<eval_gettextln>}
                                            {
                                              (DQ <'unexpected mode '> 
                                                (word_part.EscapedLiteral
                                                  token: <Id.Lit_EscapedChar '\\$'>
                                                ) <mod_dst>
                                              )
                                            }
                                          ]
                                          redirects: [
                                            (redir
                                              op: <Id.Redir_GreatAnd '>&'>
                                              loc: (redir_loc.Fd fd:1)
                                              arg: {<2>}
                                            )
                                          ]
                                          do_fork: T
                                        )
                                        (command.ControlFlow
                                          token: <Id.ControlFlow_Continue continue>
                                        )
                                      ]
                                      spids: [5492 5493 5514 -1]
                                    )
                                  ]
                                )
                              ]
                              spids: [5400 5422]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:missing_src)
                              op: assign_op.Equal
                              rhs: (word.Empty)
                              spids: [5523]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:missing_dst)
                              op: assign_op.Equal
                              rhs: (word.Empty)
                              spids: [5526]
                            )
                          ]
                        )
                        (command.AndOr
                          ops: [Id.Op_DAmp Id.Op_DAmp]
                          children: [
                            (C {<test>} {($ Id.VSub_DollarName '$mod_src')} {<Id.Lit_Equals '='>} 
                              {<160000>}
                            )
                            (command.Pipeline
                              children: [
                                (command.Simple
                                  words: [
                                    {<git-rev-parse>}
                                    {<-q>}
                                    {<--verify>}
                                    {($ Id.VSub_DollarName '$sha1_src') <Id.Lit_Other '^'> <0>}
                                  ]
                                  redirects: [
                                    (redir
                                      op: <Id.Redir_Great '>'>
                                      loc: (redir_loc.Fd fd:1)
                                      arg: {<'/dev/null'>}
                                    )
                                  ]
                                  more_env: [
                                    (env_pair
                                      name: GIT_DIR
                                      val: {(DQ ($ Id.VSub_DollarName '$name') <'/.git'>)}
                                      spids: [5543]
                                    )
                                  ]
                                  do_fork: T
                                )
                              ]
                              negated: T
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:missing_src)
                                  op: assign_op.Equal
                                  rhs: {<t>}
                                  spids: [5565]
                                )
                              ]
                            )
                          ]
                        )
                        (command.AndOr
                          ops: [Id.Op_DAmp Id.Op_DAmp]
                          children: [
                            (C {<test>} {($ Id.VSub_DollarName '$mod_dst')} {<Id.Lit_Equals '='>} 
                              {<160000>}
                            )
                            (command.Pipeline
                              children: [
                                (command.Simple
                                  words: [
                                    {<git-rev-parse>}
                                    {<-q>}
                                    {<--verify>}
                                    {($ Id.VSub_DollarName '$sha1_dst') <Id.Lit_Other '^'> <0>}
                                  ]
                                  redirects: [
                                    (redir
                                      op: <Id.Redir_Great '>'>
                                      loc: (redir_loc.Fd fd:1)
                                      arg: {<'/dev/null'>}
                                    )
                                  ]
                                  more_env: [
                                    (env_pair
                                      name: GIT_DIR
                                      val: {(DQ ($ Id.VSub_DollarName '$name') <'/.git'>)}
                                      spids: [5583]
                                    )
                                  ]
                                  do_fork: T
                                )
                              ]
                              negated: T
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:missing_dst)
                                  op: assign_op.Equal
                                  rhs: {<t>}
                                  spids: [5605]
                                )
                              ]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:display_name)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (C {<git>} {<submodule--helper>} {<relative-path>} 
                                        {(DQ ($ Id.VSub_DollarName '$name'))} {(DQ ($ Id.VSub_DollarName '$wt_prefix'))}
                                      )
                                  )
                                }
                              spids: [5610]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:total_commits)
                              op: assign_op.Equal
                              rhs: (word.Empty)
                              spids: [5629]
                            )
                          ]
                        )
                        (command.Case
                          to_match: 
                            {
                              (DQ ($ Id.VSub_DollarName '$missing_src') <','> 
                                ($ Id.VSub_DollarName '$missing_dst')
                              )
                            }
                          arms: [
                            (case_arm
                              pat_list: [{<t> <Id.Lit_Comma ','>}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:errmsg)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (DQ 
                                            (command_sub
                                              left_token: <Id.Left_DollarParen '$('>
                                              child: 
                                                (C {<eval_gettext>} 
                                                  {
                                                    (DQ <'  Warn: '> 
                                                      (word_part.EscapedLiteral
                                                        token: <Id.Lit_EscapedChar '\\$'>
                                                      ) <'display_name doesn\'t contain commit '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) 
                                                      <sha1_src>
                                                    )
                                                  }
                                                )
                                            )
                                          )
                                        }
                                      spids: [5648]
                                    )
                                  ]
                                )
                              ]
                              spids: [5643 5645 5664 -1]
                            )
                            (case_arm
                              pat_list: [{<Id.Lit_Comma ','> <t>}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:errmsg)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (DQ 
                                            (command_sub
                                              left_token: <Id.Left_DollarParen '$('>
                                              child: 
                                                (C {<eval_gettext>} 
                                                  {
                                                    (DQ <'  Warn: '> 
                                                      (word_part.EscapedLiteral
                                                        token: <Id.Lit_EscapedChar '\\$'>
                                                      ) <'display_name doesn\'t contain commit '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) 
                                                      <sha1_dst>
                                                    )
                                                  }
                                                )
                                            )
                                          )
                                        }
                                      spids: [5672]
                                    )
                                  ]
                                )
                              ]
                              spids: [5667 5669 5688 -1]
                            )
                            (case_arm
                              pat_list: [{<t> <Id.Lit_Comma ','> <t>}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:errmsg)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (DQ 
                                            (command_sub
                                              left_token: <Id.Left_DollarParen '$('>
                                              child: 
                                                (C {<eval_gettext>} 
                                                  {
                                                    (DQ <'  Warn: '> 
                                                      (word_part.EscapedLiteral
                                                        token: <Id.Lit_EscapedChar '\\$'>
                                                      ) <'display_name doesn\'t contain commits '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) 
                                                      <'sha1_src and '> (word_part.EscapedLiteral token:<Id.Lit_EscapedChar '\\$'>) <sha1_dst>
                                                    )
                                                  }
                                                )
                                            )
                                          )
                                        }
                                      spids: [5697]
                                    )
                                  ]
                                )
                              ]
                              spids: [5691 5694 5715 -1]
                            )
                            (case_arm
                              pat_list: [{<Id.Lit_Star '*'>}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:errmsg)
                                      op: assign_op.Equal
                                      rhs: (word.Empty)
                                      spids: [5722]
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:total_commits)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            child: 
                                              (command.CommandList
                                                children: [
                                                  (command.If
                                                    arms: [
                                                      (if_arm
                                                        cond: 
                                                          (condition.Shell
                                                            commands: [
                                                              (command.AndOr
                                                                ops: [Id.Op_DAmp]
                                                                children: [
                                                                  (C {<test>} 
                                                                    {
                                                                      ($ Id.VSub_DollarName 
'$mod_src'
                                                                      )
                                                                    } {<Id.Lit_Equals '='>} {<160000>}
                                                                  )
                                                                  (C {<test>} 
                                                                    {
                                                                      ($ Id.VSub_DollarName 
'$mod_dst'
                                                                      )
                                                                    } {<Id.Lit_Equals '='>} {<160000>}
                                                                  )
                                                                ]
                                                              )
                                                            ]
                                                          )
                                                        action: [
                                                          (command.ShAssignment
                                                            pairs: [
                                                              (assign_pair
                                                                lhs: (sh_lhs_expr.Name name:range)
                                                                op: assign_op.Equal
                                                                rhs: 
                                                                  {
                                                                    (DQ 
                                                                      ($ Id.VSub_DollarName 
'$sha1_src'
                                                                      ) <...> ($ Id.VSub_DollarName '$sha1_dst')
                                                                    )
                                                                  }
                                                                spids: [5753]
                                                              )
                                                            ]
                                                          )
                                                        ]
                                                        spids: [5729 5750]
                                                      )
                                                      (if_arm
                                                        cond: 
                                                          (condition.Shell
                                                            commands: [
                                                              (C {<test>} 
                                                                {($ Id.VSub_DollarName '$mod_src')} {<Id.Lit_Equals '='>} {<160000>}
                                                              )
                                                            ]
                                                          )
                                                        action: [
                                                          (command.ShAssignment
                                                            pairs: [
                                                              (assign_pair
                                                                lhs: (sh_lhs_expr.Name name:range)
                                                                op: assign_op.Equal
                                                                rhs: 
                                                                  {
                                                                    ($ Id.VSub_DollarName '$sha1_src')
                                                                  }
                                                                spids: [5775]
                                                              )
                                                            ]
                                                          )
                                                        ]
                                                        spids: [5761 5772]
                                                      )
                                                    ]
                                                    else_action: [
                                                      (command.ShAssignment
                                                        pairs: [
                                                          (assign_pair
                                                            lhs: (sh_lhs_expr.Name name:range)
                                                            op: assign_op.Equal
                                                            rhs: {($ Id.VSub_DollarName '$sha1_dst')}
                                                            spids: [5782]
                                                          )
                                                        ]
                                                      )
                                                    ]
                                                  )
                                                  (command.Pipeline
                                                    children: [
                                                      (command.Simple
                                                        words: [
                                                          {<git>}
                                                          {<rev-list>}
                                                          {<--first-parent>}
                                                          {($ Id.VSub_DollarName '$range')}
                                                          {<-->}
                                                        ]
                                                        more_env: [
                                                          (env_pair
                                                            name: GIT_DIR
                                                            val: 
                                                              {
                                                                (DQ ($ Id.VSub_DollarName '$name') 
                                                                  <'/.git'>
                                                                )
                                                              }
                                                            spids: [5789]
                                                          )
                                                        ]
                                                        do_fork: T
                                                      )
                                                      (C {<wc>} {<-l>})
                                                    ]
                                                    negated: F
                                                  )
                                                ]
                                              )
                                          )
                                        }
                                      spids: [5725]
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:total_commits)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (DQ <' ('> 
                                            (word_part.ArithSub
                                              anode: 
                                                (arith_expr.Binary
                                                  op_id: Id.Arith_Plus
                                                  left: {($ Id.VSub_DollarName '$total_commits')}
                                                  right: {<Id.Lit_Digits 0>}
                                                )
                                            ) <')'>
                                          )
                                        }
                                      spids: [5817]
                                    )
                                  ]
                                )
                              ]
                              spids: [5718 5719 5832 -1]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:sha1_abbr_src)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (command.Pipeline
                                        children: [
                                          (C {<echo>} {($ Id.VSub_DollarName '$sha1_src')})
                                          (C {<cut>} {<-c1-7>})
                                        ]
                                        negated: F
                                      )
                                  )
                                }
                              spids: [5839]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:sha1_abbr_dst)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (command.Pipeline
                                        children: [
                                          (C {<echo>} {($ Id.VSub_DollarName '$sha1_dst')})
                                          (C {<cut>} {<-c1-7>})
                                        ]
                                        negated: F
                                      )
                                  )
                                }
                              spids: [5853]
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (C {<test>} {($ Id.VSub_DollarName '$status')} {<Id.Lit_Equals '='>} 
                                      {<T>}
                                    )
                                  ]
                                )
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:blob)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (DQ 
                                            (command_sub
                                              left_token: <Id.Left_DollarParen '$('>
                                              child: (C {<gettext>} {(DQ <blob>)})
                                            )
                                          )
                                        }
                                      spids: [5881]
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:submodule)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (DQ 
                                            (command_sub
                                              left_token: <Id.Left_DollarParen '$('>
                                              child: (C {<gettext>} {(DQ <submodule>)})
                                            )
                                          )
                                        }
                                      spids: [5893]
                                    )
                                  ]
                                )
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: 
                                        (condition.Shell
                                          commands: [
                                            (C {<test>} {($ Id.VSub_DollarName '$mod_dst')} 
                                              {<Id.Lit_Equals '='>} {<160000>}
                                            )
                                          ]
                                        )
                                      action: [
                                        (C {<echo>} 
                                          {
                                            (DQ <'* '> ($ Id.VSub_DollarName '$display_name') <' '> 
                                              ($ Id.VSub_DollarName '$sha1_abbr_src') <'('> ($ Id.VSub_DollarName '$blob') <')->'> ($ Id.VSub_DollarName '$sha1_abbr_dst') <'('> 
                                              ($ Id.VSub_DollarName '$submodule') <')'> ($ Id.VSub_DollarName '$total_commits') <':'>
                                            )
                                          }
                                        )
                                      ]
                                      spids: [5905 5916]
                                    )
                                  ]
                                  else_action: [
                                    (C {<echo>} 
                                      {
                                        (DQ <'* '> ($ Id.VSub_DollarName '$display_name') <' '> 
                                          ($ Id.VSub_DollarName '$sha1_abbr_src') <'('> ($ Id.VSub_DollarName '$submodule') <')->'> ($ Id.VSub_DollarName '$sha1_abbr_dst') <'('> 
                                          ($ Id.VSub_DollarName '$blob') <')'> ($ Id.VSub_DollarName '$total_commits') <':'>
                                        )
                                      }
                                    )
                                  ]
                                )
                              ]
                              spids: [5867 5878]
                            )
                          ]
                          else_action: [
                            (C {<echo>} 
                              {
                                (DQ <'* '> ($ Id.VSub_DollarName '$display_name') <' '> 
                                  ($ Id.VSub_DollarName '$sha1_abbr_src') <...> ($ Id.VSub_DollarName '$sha1_abbr_dst') ($ Id.VSub_DollarName '$total_commits') <':'>
                                )
                              }
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: 
                                (condition.Shell
                                  commands: [(C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$errmsg'))})]
                                )
                              action: [
                                (command.AndOr
                                  ops: [Id.Op_DAmp]
                                  children: [
                                    (C {<test>} {($ Id.VSub_DollarName '$mod_dst')} 
                                      {<Id.Lit_Equals '='>} {<160000>}
                                    )
                                    (C {<echo>} {(DQ ($ Id.VSub_DollarName '$errmsg'))})
                                  ]
                                )
                              ]
                              spids: [5983 5994]
                            )
                          ]
                          else_action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (command.AndOr
                                          ops: [Id.Op_DAmp]
                                          children: [
                                            (C {<test>} {($ Id.VSub_DollarName '$mod_src')} 
                                              {<Id.Lit_Equals '='>} {<160000>}
                                            )
                                            (C {<test>} {($ Id.VSub_DollarName '$mod_dst')} 
                                              {<Id.Lit_Equals '='>} {<160000>}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:limit)
                                          op: assign_op.Equal
                                          rhs: (word.Empty)
                                          spids: [6049]
                                        )
                                      ]
                                    )
                                    (command.AndOr
                                      ops: [Id.Op_DAmp]
                                      children: [
                                        (C {<test>} {($ Id.VSub_DollarName '$summary_limit')} {<-gt>} 
                                          {<0>}
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:limit)
                                              op: assign_op.Equal
                                              rhs: {(DQ <-> ($ Id.VSub_DollarName '$summary_limit'))}
                                              spids: [6062]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.Simple
                                      words: [
                                        {<git>}
                                        {<log>}
                                        {($ Id.VSub_DollarName '$limit')}
                                        {<--pretty> <Id.Lit_Equals '='> (SQ <'format:  %m %s'>)}
                                        {<--first-parent>}
                                        {($ Id.VSub_DollarName '$sha1_src') <Id.Lit_TDot ...> 
                                          ($ Id.VSub_DollarName '$sha1_dst')
                                        }
                                      ]
                                      more_env: [
                                        (env_pair
                                          name: GIT_DIR
                                          val: {(DQ ($ Id.VSub_DollarName '$name') <'/.git'>)}
                                          spids: [6069]
                                        )
                                      ]
                                      do_fork: T
                                    )
                                  ]
                                  spids: [6025 6046]
                                )
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (C {<test>} {($ Id.VSub_DollarName '$mod_dst')} 
                                          {<Id.Lit_Equals '='>} {<160000>}
                                        )
                                      ]
                                    )
                                  action: [
                                    (command.Simple
                                      words: [
                                        {<git>}
                                        {<log>}
                                        {<--pretty> <Id.Lit_Equals '='> (SQ <'format:  > %s'>)}
                                        {<-1>}
                                        {($ Id.VSub_DollarName '$sha1_dst')}
                                      ]
                                      more_env: [
                                        (env_pair
                                          name: GIT_DIR
                                          val: {(DQ ($ Id.VSub_DollarName '$name') <'/.git'>)}
                                          spids: [6112]
                                        )
                                      ]
                                      do_fork: T
                                    )
                                  ]
                                  spids: [6098 6109]
                                )
                              ]
                              else_action: [
                                (command.Simple
                                  words: [
                                    {<git>}
                                    {<log>}
                                    {<--pretty> <Id.Lit_Equals '='> (SQ <'format:  < %s'>)}
                                    {<-1>}
                                    {($ Id.VSub_DollarName '$sha1_src')}
                                  ]
                                  more_env: [
                                    (env_pair
                                      name: GIT_DIR
                                      val: {(DQ ($ Id.VSub_DollarName '$name') <'/.git'>)}
                                      spids: [6138]
                                    )
                                  ]
                                  do_fork: T
                                )
                              ]
                            )
                            (C {<echo>})
                          ]
                        )
                        (C {<echo>})
                      ]
                    )
                )
              ]
              negated: F
            )
          ]
        )
    )
    (command.ShFunction
      name: cmd_status
      body: 
        (BraceGroup
          children: [
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: (condition.Shell commands:[(C {<test>} {($ Id.VSub_Pound '$#')} {<-ne>} {<0>})])
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_Number '$1'))}
                      arms: [
                        (case_arm
                          pat_list: [{<-q>} {<--quiet>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:GIT_QUIET)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [6247]
                                )
                              ]
                            )
                          ]
                          spids: [6241 6244 6251 -1]
                        )
                        (case_arm
                          pat_list: [{<--cached>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:cached)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [6258]
                                )
                              ]
                            )
                          ]
                          spids: [6254 6255 6262 -1]
                        )
                        (case_arm
                          pat_list: [{<--recursive>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:recursive)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [6269]
                                )
                              ]
                            )
                          ]
                          spids: [6265 6266 6273 -1]
                        )
                        (case_arm
                          pat_list: [{<-->}]
                          action: [
                            (C {<shift>})
                            (command.ControlFlow
                              token: <Id.ControlFlow_Break break>
                            )
                          ]
                          spids: [6276 6277 6286 -1]
                        )
                        (case_arm
                          pat_list: [{<-> <Id.Lit_Star '*'>}]
                          action: [(C {<usage>})]
                          spids: [6289 6291 6297 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [(command.ControlFlow token:<Id.ControlFlow_Break break>)]
                          spids: [6300 6301 6307 -1]
                        )
                      ]
                    )
                    (C {<shift>})
                  ]
                )
            )
            (command.Pipeline
              children: [
                (BraceGroup
                  children: [
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<git>} {<submodule--helper>} {<list>} {<--prefix>} 
                          {(DQ ($ Id.VSub_DollarName '$wt_prefix'))} {(DQ ($ Id.VSub_At '$@'))}
                        )
                        (C {<echo>} {(DQ <'#unmatched'>)} {($ Id.VSub_QMark '$?')})
                      ]
                    )
                  ]
                )
                (command.WhileUntil
                  keyword: <Id.KW_While while>
                  cond: 
                    (condition.Shell
                      commands: [(C {<read>} {<mode>} {<sha1>} {<stage>} {<sm_path>})]
                    )
                  body: 
                    (command.DoGroup
                      children: [
                        (C {<die_if_unmatched>} {(DQ ($ Id.VSub_DollarName '$mode'))} 
                          {(DQ ($ Id.VSub_DollarName '$sha1'))}
                        )
                        (command.AndOr
                          ops: [Id.Op_DPipe]
                          children: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:name)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (C {<git>} {<submodule--helper>} {<name>} 
                                            {(DQ ($ Id.VSub_DollarName '$sm_path'))}
                                          )
                                      )
                                    }
                                  spids: [6383]
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <Id.ControlFlow_Exit exit>
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:url)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (C {<git>} {<config>} 
                                        {<submodule.> (DQ ($ Id.VSub_DollarName '$name')) <.url>}
                                      )
                                  )
                                }
                              spids: [6401]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:displaypath)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (C {<git>} {<submodule--helper>} {<relative-path>} 
                                        {
                                          (DQ ($ Id.VSub_DollarName '$prefix') 
                                            ($ Id.VSub_DollarName '$sm_path')
                                          )
                                        } {(DQ ($ Id.VSub_DollarName '$wt_prefix'))}
                                      )
                                  )
                                }
                              spids: [6415]
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (C {<test>} {(DQ ($ Id.VSub_DollarName '$stage'))} 
                                      {<Id.Lit_Equals '='>} {<U>}
                                    )
                                  ]
                                )
                              action: [
                                (C {<say>} 
                                  {
                                    (DQ <U> ($ Id.VSub_DollarName '$sha1') <' '> 
                                      ($ Id.VSub_DollarName '$displaypath')
                                    )
                                  }
                                )
                                (command.ControlFlow
                                  token: <Id.ControlFlow_Continue continue>
                                )
                              ]
                              spids: [6434 6447]
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.AndOr
                                      ops: [Id.Op_DPipe]
                                      children: [
                                        (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$url'))})
                                        (BraceGroup
                                          children: [
                                            (command.AndOr
                                              ops: [Id.Op_DAmp]
                                              children: [
                                                (command.Pipeline
                                                  children: [
                                                    (C {<test>} {<-d>} 
                                                      {(DQ ($ Id.VSub_DollarName '$sm_path')) 
                                                        <'/.git'>
                                                      }
                                                    )
                                                  ]
                                                  negated: T
                                                )
                                                (command.Pipeline
                                                  children: [
                                                    (C {<test>} {<-f>} 
                                                      {(DQ ($ Id.VSub_DollarName '$sm_path')) 
                                                        <'/.git'>
                                                      }
                                                    )
                                                  ]
                                                  negated: T
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              action: [
                                (C {<say>} 
                                  {
                                    (DQ <-> ($ Id.VSub_DollarName '$sha1') <' '> 
                                      ($ Id.VSub_DollarName '$displaypath')
                                    )
                                  }
                                )
                                (command.Sentence
                                  child: 
                                    (command.ControlFlow
                                      token: <Id.ControlFlow_Continue continue>
                                    )
                                  terminator: <Id.Op_Semi _>
                                )
                              ]
                              spids: [6466 6511]
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (C {<git>} {<diff-files>} 
                                      {<--ignore-submodules> <Id.Lit_Equals '='> <dirty>} {<--quiet>} {<-->} {(DQ ($ Id.VSub_DollarName '$sm_path'))}
                                    )
                                  ]
                                )
                              action: [
                                (C {<set_name_rev>} {(DQ ($ Id.VSub_DollarName '$sm_path'))} 
                                  {(DQ ($ Id.VSub_DollarName '$sha1'))}
                                )
                                (C {<say>} 
                                  {
                                    (DQ <' '> ($ Id.VSub_DollarName '$sha1') <' '> 
                                      ($ Id.VSub_DollarName '$displaypath') ($ Id.VSub_DollarName '$revname')
                                    )
                                  }
                                )
                              ]
                              spids: [6531 6550]
                            )
                          ]
                          else_action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: 
                                    (condition.Shell
                                      commands: [
                                        (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$cached'))})
                                      ]
                                    )
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:sha1)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Id.Left_DollarParen '$('>
                                                child: 
                                                  (command.CommandList
                                                    children: [
                                                      (command.Sentence
                                                        child: (C {<sanitize_submodule_env>})
                                                        terminator: <Id.Op_Semi _>
                                                      )
                                                      (command.AndOr
                                                        ops: [Id.Op_DAmp]
                                                        children: [
                                                          (C {<cd>} 
                                                            {(DQ ($ Id.VSub_DollarName '$sm_path'))}
                                                          )
                                                          (C {<git>} {<rev-parse>} {<--verify>} {<HEAD>})
                                                        ]
                                                      )
                                                    ]
                                                  )
                                              )
                                            }
                                          spids: [6592]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [6578 6589]
                                )
                              ]
                            )
                            (C {<set_name_rev>} {(DQ ($ Id.VSub_DollarName '$sm_path'))} 
                              {(DQ ($ Id.VSub_DollarName '$sha1'))}
                            )
                            (C {<say>} 
                              {
                                (DQ <'+'> ($ Id.VSub_DollarName '$sha1') <' '> 
                                  ($ Id.VSub_DollarName '$displaypath') ($ Id.VSub_DollarName '$revname')
                                )
                              }
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$recursive'))})
                                  ]
                                )
                              action: [
                                (command.AndOr
                                  ops: [Id.Op_DPipe]
                                  children: [
                                    (command.Subshell
                                      child: 
                                        (command.CommandList
                                          children: [
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:prefix)
                                                  op: assign_op.Equal
                                                  rhs: 
                                                    {(DQ ($ Id.VSub_DollarName '$displaypath') <'/'>)}
                                                  spids: [6661]
                                                )
                                              ]
                                            )
                                            (C {<sanitize_submodule_env>})
                                            (command.ShAssignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (sh_lhs_expr.Name name:wt_prefix)
                                                  op: assign_op.Equal
                                                  rhs: (word.Empty)
                                                  spids: [6671]
                                                )
                                              ]
                                            )
                                            (command.AndOr
                                              ops: [Id.Op_DAmp]
                                              children: [
                                                (C {<cd>} {(DQ ($ Id.VSub_DollarName '$sm_path'))})
                                                (C {<eval>} {<cmd_status>})
                                              ]
                                            )
                                          ]
                                        )
                                    )
                                    (C {<die>} 
                                      {
                                        (DQ 
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            child: 
                                              (C {<eval_gettext>} 
                                                {
                                                  (DQ <'Failed to recurse into submodule path \''> 
                                                    (word_part.EscapedLiteral
                                                      token: <Id.Lit_EscapedChar '\\$'>
                                                    ) <'sm_path\''>
                                                  )
                                                }
                                              )
                                          )
                                        )
                                      }
                                    )
                                  ]
                                )
                              ]
                              spids: [6644 6655]
                            )
                          ]
                        )
                      ]
                    )
                )
              ]
              negated: F
            )
          ]
        )
    )
    (command.ShFunction
      name: cmd_sync
      body: 
        (BraceGroup
          children: [
            (command.WhileUntil
              keyword: <Id.KW_While while>
              cond: (condition.Shell commands:[(C {<test>} {($ Id.VSub_Pound '$#')} {<-ne>} {<0>})])
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_Number '$1'))}
                      arms: [
                        (case_arm
                          pat_list: [{<-q>} {<--quiet>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:GIT_QUIET)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [6766]
                                )
                              ]
                            )
                            (C {<shift>})
                          ]
                          spids: [6760 6763 6773 -1]
                        )
                        (case_arm
                          pat_list: [{<--recursive>}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:recursive)
                                  op: assign_op.Equal
                                  rhs: {<1>}
                                  spids: [6780]
                                )
                              ]
                            )
                            (C {<shift>})
                          ]
                          spids: [6776 6777 6787 -1]
                        )
                        (case_arm
                          pat_list: [{<-->}]
                          action: [
                            (C {<shift>})
                            (command.ControlFlow
                              token: <Id.ControlFlow_Break break>
                            )
                          ]
                          spids: [6790 6791 6800 -1]
                        )
                        (case_arm
                          pat_list: [{<-> <Id.Lit_Star '*'>}]
                          action: [(C {<usage>})]
                          spids: [6803 6805 6811 -1]
                        )
                        (case_arm
                          pat_list: [{<Id.Lit_Star '*'>}]
                          action: [(command.ControlFlow token:<Id.ControlFlow_Break break>)]
                          spids: [6814 6815 6821 -1]
                        )
                      ]
                    )
                  ]
                )
            )
            (C {<cd_to_toplevel>})
            (command.Pipeline
              children: [
                (BraceGroup
                  children: [
                    (command.AndOr
                      ops: [Id.Op_DPipe]
                      children: [
                        (C {<git>} {<submodule--helper>} {<list>} {<--prefix>} 
                          {(DQ ($ Id.VSub_DollarName '$wt_prefix'))} {(DQ ($ Id.VSub_At '$@'))}
                        )
                        (C {<echo>} {(DQ <'#unmatched'>)} {($ Id.VSub_QMark '$?')})
                      ]
                    )
                  ]
                )
                (command.WhileUntil
                  keyword: <Id.KW_While while>
                  cond: 
                    (condition.Shell
                      commands: [(C {<read>} {<mode>} {<sha1>} {<stage>} {<sm_path>})]
                    )
                  body: 
                    (command.DoGroup
                      children: [
                        (C {<die_if_unmatched>} {(DQ ($ Id.VSub_DollarName '$mode'))} 
                          {(DQ ($ Id.VSub_DollarName '$sha1'))}
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:name)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (C {<git>} {<submodule--helper>} {<name>} 
                                        {(DQ ($ Id.VSub_DollarName '$sm_path'))}
                                      )
                                  )
                                }
                              spids: [6896]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:url)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (command_sub
                                    left_token: <Id.Left_DollarParen '$('>
                                    child: 
                                      (C {<git>} {<config>} {<-f>} {<.gitmodules>} {<--get>} 
                                        {<submodule.> (DQ ($ Id.VSub_DollarName '$name')) <.url>}
                                      )
                                  )
                                }
                              spids: [6910]
                            )
                          ]
                        )
                        (command.Case
                          to_match: {(DQ ($ Id.VSub_DollarName '$url'))}
                          arms: [
                            (case_arm
                              pat_list: [{<'./'> <Id.Lit_Star '*'>} {<'../'> <Id.Lit_Star '*'>}]
                              action: [
                                (command.AndOr
                                  ops: [Id.Op_DAmp Id.Op_DAmp Id.Op_DAmp Id.Op_DPipe]
                                  children: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:up_path)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (command_sub
                                                  left_token: <Id.Left_DollarParen '$('>
                                                  child: 
                                                    (command.Pipeline
                                                      children: [
                                                        (C {<printf>} {(SQ <'%s\\n'>)} 
                                                          {(DQ ($ Id.VSub_DollarName '$sm_path'))}
                                                        )
                                                        (C {<sed>} {(DQ <'s/[^/][^/]*/../g'>)})
                                                      ]
                                                      negated: F
                                                    )
                                                )
                                              )
                                            }
                                          spids: [6960]
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:up_path)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (braced_var_sub
                                                token: <Id.VSub_Name up_path>
                                                suffix_op: 
                                                  (suffix_op.Unary
                                                    tok: <Id.VOp1_Percent '%'>
                                                    arg_word: {<Id.Lit_Slash '/'>}
                                                  )
                                              ) <'/'>
                                            }
                                          spids: [6990]
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:sub_origin_url)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Id.Left_DollarParen '$('>
                                                child: 
                                                  (C {<git>} {<submodule--helper>} 
                                                    {<resolve-relative-url>} {(DQ ($ Id.VSub_DollarName '$url'))} {(DQ ($ Id.VSub_DollarName '$up_path'))}
                                                  )
                                              )
                                            }
                                          spids: [7005]
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:super_config_url)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (command_sub
                                                left_token: <Id.Left_DollarParen '$('>
                                                child: 
                                                  (C {<git>} {<submodule--helper>} 
                                                    {<resolve-relative-url>} {(DQ ($ Id.VSub_DollarName '$url'))}
                                                  )
                                              )
                                            }
                                          spids: [7029]
                                        )
                                      ]
                                    )
                                    (command.ControlFlow
                                      token: <Id.ControlFlow_Exit exit>
                                    )
                                  ]
                                )
                              ]
                              spids: [6944 6949 7047 -1]
                            )
                            (case_arm
                              pat_list: [{<Id.Lit_Star '*'>}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:sub_origin_url)
                                      op: assign_op.Equal
                                      rhs: {(DQ ($ Id.VSub_DollarName '$url'))}
                                      spids: [7054]
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:super_config_url)
                                      op: assign_op.Equal
                                      rhs: {(DQ ($ Id.VSub_DollarName '$url'))}
                                      spids: [7060]
                                    )
                                  ]
                                )
                              ]
                              spids: [7050 7051 7066 -1]
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: 
                                (condition.Shell
                                  commands: [
                                    (command.Simple
                                      words: [
                                        {<git>}
                                        {<config>}
                                        {(DQ <submodule.> ($ Id.VSub_DollarName '$name') <.url>)}
                                      ]
                                      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:displaypath)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (command_sub
                                            left_token: <Id.Left_DollarParen '$('>
                                            child: 
                                              (C {<git>} {<submodule--helper>} {<relative-path>} 
                                                {
                                                  (DQ ($ Id.VSub_DollarName '$prefix') 
                                                    ($ Id.VSub_DollarName '$sm_path')
                                                  )
                                                } {(DQ ($ Id.VSub_DollarName '$wt_prefix'))}
                                              )
                                          )
                                        }
                                      spids: [7095]
                                    )
                                  ]
                                )
                                (C {<say>} 
                                  {
                                    (DQ 
                                      (command_sub
                                        left_token: <Id.Left_DollarParen '$('>
                                        child: 
                                          (C {<eval_gettext>} 
                                            {
                                              (DQ <'Synchronizing submodule url for \''> 
                                                (word_part.EscapedLiteral
                                                  token: <Id.Lit_EscapedChar '\\$'>
                                                ) <'displaypath\''>
                                              )
                                            }
                                          )
                                      )
                                    )
                                  }
                                )
                                (C {<git>} {<config>} 
                                  {<submodule.> (DQ ($ Id.VSub_DollarName '$name')) <.url>} {(DQ ($ Id.VSub_DollarName '$super_config_url'))}
                                )
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: 
                                        (condition.Shell
                                          commands: [
                                            (C {<test>} {<-e>} 
                                              {(DQ ($ Id.VSub_DollarName '$sm_path')) <'/.git'>}
                                            )
                                          ]
                                        )
                                      action: [
                                        (command.Subshell
                                          child: 
                                            (command.CommandList
                                              children: [
                                                (C {<sanitize_submodule_env>})
                                                (C {<cd>} {(DQ ($ Id.VSub_DollarName '$sm_path'))})
                                                (command.ShAssignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (sh_lhs_expr.Name name:remote)
                                                      op: assign_op.Equal
                                                      rhs: 
                                                        {
                                                          (command_sub
                                                            left_token: <Id.Left_DollarParen '$('>
                                                            child: (C {<get_default_remote>})
                                                          )
                                                        }
                                                      spids: [7173]
                                                    )
                                                  ]
                                                )
                                                (C {<git>} {<config>} 
                                                  {<remote.> (DQ ($ Id.VSub_DollarName '$remote')) 
                                                    <.url>
                                                  } {(DQ ($ Id.VSub_DollarName '$sub_origin_url'))}
                                                )
                                                (command.If
                                                  arms: [
                                                    (if_arm
                                                      cond: 
                                                        (condition.Shell
                                                          commands: [
                                                            (C {<test>} {<-n>} 
                                                              {
                                                                (DQ 
                                                                  ($ Id.VSub_DollarName '$recursive')
                                                                )
                                                              }
                                                            )
                                                          ]
                                                        )
                                                      action: [
                                                        (command.ShAssignment
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (sh_lhs_expr.Name name:prefix)
                                                              op: assign_op.Equal
                                                              rhs: 
                                                                {
                                                                  (DQ 
                                                                    ($ Id.VSub_DollarName '$prefix') ($ Id.VSub_DollarName '$sm_path') <'/'>
                                                                  )
                                                                }
                                                              spids: [7209]
                                                            )
                                                          ]
                                                        )
                                                        (C {<eval>} {<cmd_sync>})
                                                      ]
                                                      spids: [7195 7206]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                        )
                                      ]
                                      spids: [7145 7157]
                                    )
                                  ]
                                )
                              ]
                              spids: [7073 7092]
                            )
                          ]
                        )
                      ]
                    )
                )
              ]
              negated: F
            )
          ]
        )
    )
    (command.WhileUntil
      keyword: <Id.KW_While while>
      cond: 
        (condition.Shell
          commands: [
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (C {<test>} {($ Id.VSub_Pound '$#')} {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<0>})
                (C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$command'))})
              ]
            )
          ]
        )
      body: 
        (command.DoGroup
          children: [
            (command.Case
              to_match: {(DQ ($ Id.VSub_Number '$1'))}
              arms: [
                (case_arm
                  pat_list: [
                    {<add>}
                    {<foreach>}
                    {<init>}
                    {<deinit>}
                    {<update>}
                    {<status>}
                    {<summary>}
                    {<sync>}
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:command)
                          op: assign_op.Equal
                          rhs: {($ Id.VSub_Number '$1')}
                          spids: [7320]
                        )
                      ]
                    )
                  ]
                  spids: [7288 7317 7324 -1]
                )
                (case_arm
                  pat_list: [{<-q>} {<--quiet>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:GIT_QUIET)
                          op: assign_op.Equal
                          rhs: {<1>}
                          spids: [7333]
                        )
                      ]
                    )
                  ]
                  spids: [7327 7330 7337 -1]
                )
                (case_arm
                  pat_list: [{<-b>} {<--branch>}]
                  action: [
                    (command.Case
                      to_match: {(DQ ($ Id.VSub_Number '$2'))}
                      arms: [
                        (case_arm
                          pat_list: [{(SQ )}]
                          action: [(C {<usage>})]
                          spids: [7355 7357 7363 -1]
                        )
                      ]
                    )
                    (command.Sentence
                      child: 
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:branch)
                              op: assign_op.Equal
                              rhs: {(DQ ($ Id.VSub_Number '$2'))}
                              spids: [7369]
                            )
                          ]
                        )
                      terminator: <Id.Op_Semi _>
                    )
                    (C {<shift>})
                  ]
                  spids: [7340 7343 7378 -1]
                )
                (case_arm
                  pat_list: [{<--cached>}]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:cached)
                          op: assign_op.Equal
                          rhs: {(DQ ($ Id.VSub_Number '$1'))}
                          spids: [7385]
                        )
                      ]
                    )
                  ]
                  spids: [7381 7382 7391 -1]
                )
                (case_arm
                  pat_list: [{<-->}]
                  action: [(command.ControlFlow token:<Id.ControlFlow_Break break>)]
                  spids: [7394 7395 7401 -1]
                )
                (case_arm
                  pat_list: [{<-> <Id.Lit_Star '*'>}]
                  action: [(C {<usage>})]
                  spids: [7404 7406 7412 -1]
                )
                (case_arm
                  pat_list: [{<Id.Lit_Star '*'>}]
                  action: [(command.ControlFlow token:<Id.ControlFlow_Break break>)]
                  spids: [7415 7416 7422 -1]
                )
              ]
            )
            (C {<shift>})
          ]
        )
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [(C {<test>} {<-z>} {(DQ ($ Id.VSub_DollarName '$command'))})]
            )
          action: [
            (command.If
              arms: [
                (if_arm
                  cond: 
                    (condition.Shell
                      commands: [(C {<test>} {($ Id.VSub_Pound '$#')} {<Id.Lit_Equals '='>} {<0>})]
                    )
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:command)
                          op: assign_op.Equal
                          rhs: {<status>}
                          spids: [7463]
                        )
                      ]
                    )
                  ]
                  spids: [7449 7460]
                )
              ]
              else_action: [(C {<usage>})]
            )
          ]
          spids: [7436 7446]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.AndOr
                  ops: [Id.Op_DAmp]
                  children: [
                    (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$branch'))})
                    (C {<test>} {(DQ ($ Id.VSub_DollarName '$command'))} 
                      {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<add>}
                    )
                  ]
                )
              ]
            )
          action: [(C {<usage>})]
          spids: [7481 7504]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: 
            (condition.Shell
              commands: [
                (command.AndOr
                  ops: [Id.Op_DAmp Id.Op_DAmp]
                  children: [
                    (C {<test>} {<-n>} {(DQ ($ Id.VSub_DollarName '$cached'))})
                    (C {<test>} {(DQ ($ Id.VSub_DollarName '$command'))} 
                      {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<status>}
                    )
                    (C {<test>} {(DQ ($ Id.VSub_DollarName '$command'))} 
                      {<Id.KW_Bang '!'> <Id.Lit_Equals '='>} {<summary>}
                    )
                  ]
                )
              ]
            )
          action: [(C {<usage>})]
          spids: [7515 7551]
        )
      ]
    )
    (C {(DQ <cmd_> ($ Id.VSub_DollarName '$command'))} {(DQ ($ Id.VSub_At '$@'))})
  ]
)