(command.CommandList
  children: [
    (command.Assignment
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:dashless)
          op: Equal
          rhs: 
            {
              (word_part.CommandSub
                left_token: <Left_DollarParen '$('>
                command_list: 
                  (command.CommandList
                    children: [
                      (command.Pipeline
                        children: [
                          (C {(basename)} {(DQ ($ VSub_Number '$0'))})
                          (C {(sed)} {(-e)} {(SQ <'s/-/ /'>)})
                        ]
                        negated: F
                      )
                    ]
                  )
              )
            }
        )
      ]
    )
    (command.Assignment
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:USAGE)
          op: Equal
          rhs: 
            {
              (DQ 
                (
'[--quiet] add [-b <branch>] [-f|--force] [--name <name>] [--reference <repository>] [--] <repository> [<path>]\n'
                ) ('   or: ') ($ VSub_DollarName '$dashless') 
                (' [--quiet] status [--cached] [--recursive] [--] [<path>...]\n') ('   or: ') ($ VSub_DollarName '$dashless') (' [--quiet] init [--] [<path>...]\n') ('   or: ') 
                ($ VSub_DollarName '$dashless') (' [--quiet] deinit [-f|--force] (--all| [--] <path>...)\n') ('   or: ') 
                ($ VSub_DollarName '$dashless') 
                (
' [--quiet] update [--init] [--remote] [-N|--no-fetch] [-f|--force] [--checkout|--merge|--rebase] [--[no-]recommend-shallow] [--reference <repository>] [--recursive] [--] [<path>...]\n'
                ) ('   or: ') ($ VSub_DollarName '$dashless') 
                (
' [--quiet] summary [--cached|--files] [--summary-limit <n>] [commit] [--] [<path>...]\n'
                ) ('   or: ') ($ VSub_DollarName '$dashless') (' [--quiet] foreach [--recursive] <command>\n') ('   or: ') 
                ($ VSub_DollarName '$dashless') (' [--quiet] sync [--recursive] [--] [<path>...]')
              )
            }
        )
      ]
    )
    (command.Assignment
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:OPTIONS_SPEC) op:Equal rhs:(word.Empty))]
    )
    (command.Assignment
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:SUBDIRECTORY_OK) op:Equal rhs:{(Yes)})]
    )
    (C {(.)} {(git-sh-setup)})
    (C {(.)} {(git-parse-remote)})
    (C {(require_work_tree)})
    (command.Assignment
      pairs: [
        (assign_pair
          lhs: (lhs_expr.LhsName name:wt_prefix)
          op: Equal
          rhs: 
            {
              (word_part.CommandSub
                left_token: <Left_DollarParen '$('>
                command_list: 
                  (command.CommandList
                    children: [(C {(git)} {(rev-parse)} {(--show-prefix)})]
                  )
              )
            }
        )
      ]
    )
    (C {(cd_to_toplevel)})
    (C {(Lit_Other ':')} 
      {
        (word_part.BracedVarSub
          token: <VSub_Name GIT_ALLOW_PROTOCOL>
          suffix_op: (suffix_op.Unary op_id:VTest_Equals arg_word:{('file:git:http:https:ssh')})
        )
      }
    )
    (C {(export)} {(GIT_ALLOW_PROTOCOL)})
    (command.Assignment
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:command) op:Equal rhs:(word.Empty))]
    )
    (command.Assignment
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:branch) op:Equal rhs:(word.Empty))]
    )
    (command.Assignment
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:force) op:Equal rhs:(word.Empty))]
    )
    (command.Assignment
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:reference) op:Equal rhs:(word.Empty))]
    )
    (command.Assignment
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:cached) op:Equal rhs:(word.Empty))]
    )
    (command.Assignment
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:recursive) op:Equal rhs:(word.Empty))]
    )
    (command.Assignment
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:init) op:Equal rhs:(word.Empty))]
    )
    (command.Assignment
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:files) op:Equal rhs:(word.Empty))]
    )
    (command.Assignment
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:remote) op:Equal rhs:(word.Empty))]
    )
    (command.Assignment
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:nofetch) op:Equal rhs:(word.Empty))]
    )
    (command.Assignment
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:update) op:Equal rhs:(word.Empty))]
    )
    (command.Assignment
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:prefix) op:Equal rhs:(word.Empty))]
    )
    (command.Assignment
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:custom_name) op:Equal rhs:(word.Empty))]
    )
    (command.Assignment
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:depth) op:Equal rhs:(word.Empty))]
    )
    (command.Assignment
      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:progress) op:Equal rhs:(word.Empty))]
    )
    (command.FuncDef
      name: die_if_unmatched
      body: 
        (command.BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (C {(test)} {(DQ ($ VSub_Number '$1'))} {(Lit_Other '=')} {(DQ ('#unmatched'))})
                  ]
                  action: [
                    (command.ControlFlow
                      token: <ControlFlow_Exit exit>
                      arg_word: 
                        {
                          (word_part.BracedVarSub
                            token: <VSub_Number 2>
                            suffix_op: (suffix_op.Unary op_id:VTest_ColonHyphen arg_word:{(1)})
                          )
                        }
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.FuncDef
      name: get_submodule_config
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:name)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number '$1'))}
                )
              ]
            )
            (command.Assignment
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:option)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number '$2'))}
                )
              ]
            )
            (command.Assignment
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:default)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number '$3'))}
                )
              ]
            )
            (command.Assignment
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:value)
                  op: Equal
                  rhs: 
                    {
                      (word_part.CommandSub
                        left_token: <Left_DollarParen '$('>
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {(git)} {(config)} 
                                {(submodule.) (DQ ($ VSub_DollarName '$name')) (.) 
                                  (DQ ($ VSub_DollarName '$option'))
                                }
                              )
                            ]
                          )
                      )
                    }
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$value'))})]
                  action: [
                    (command.Assignment
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:value)
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSub
                                left_token: <Left_DollarParen '$('>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(git)} {(config)} {(-f)} {(.gitmodules)} 
                                        {(submodule.) (DQ ($ VSub_DollarName '$name')) (.) 
                                          (DQ ($ VSub_DollarName '$option'))
                                        }
                                      )
                                    ]
                                  )
                              )
                            }
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (C {(printf)} {(SQ <'%s'>)} 
              {
                (DQ 
                  (word_part.BracedVarSub
                    token: <VSub_Name value>
                    suffix_op: 
                      (suffix_op.Unary
                        op_id: VTest_ColonHyphen
                        arg_word: {($ VSub_DollarName '$default')}
                      )
                  )
                )
              }
            )
          ]
        )
    )
    (command.FuncDef
      name: isnumber
      body: 
        (command.BraceGroup
          children: [
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (command.Assignment
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:n)
                      op: Equal
                      rhs: 
                        {
                          (word_part.ArithSub
                            anode: 
                              (arith_expr.Binary
                                op_id: Arith_Plus
                                left: (arith_expr.ArithWord w:{($ VSub_Number '$1')})
                                right: (arith_expr.ArithWord w:{(Lit_Digits 0)})
                              )
                          )
                        }
                    )
                  ]
                  redirects: [(redir.Redir op:<Redir_Great '2>'> fd:2 arg_word:{(/dev/null)})]
                )
                (C {(test)} {(DQ ($ VSub_DollarName '$n'))} {(Lit_Other '=')} {(DQ ($ VSub_Number '$1'))})
              ]
            )
          ]
        )
    )
    (command.FuncDef
      name: sanitize_submodule_env
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:save_config)
                  op: Equal
                  rhs: {($ VSub_DollarName '$GIT_CONFIG_PARAMETERS')}
                )
              ]
            )
            (C {(clear_local_git_env)})
            (command.Assignment
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:GIT_CONFIG_PARAMETERS)
                  op: Equal
                  rhs: {($ VSub_DollarName '$save_config')}
                )
              ]
            )
            (C {(export)} {(GIT_CONFIG_PARAMETERS)})
          ]
        )
    )
    (command.FuncDef
      name: cmd_add
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              pairs: [(assign_pair lhs:(lhs_expr.LhsName name:reference_path) op:Equal rhs:(word.Empty))]
            )
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [(C {(test)} {($ VSub_Pound '$#')} {(-ne)} {(0)})]
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ VSub_Number '$1'))}
                      arms: [
                        (case_arm
                          pat_list: [{(-b)} {(--branch)}]
                          action: [
                            (command.Case
                              to_match: {(DQ ($ VSub_Number '$2'))}
                              arms: [(case_arm pat_list:[{(SQ )}] action:[(C {(usage)})])]
                            )
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:branch)
                                  op: Equal
                                  rhs: {($ VSub_Number '$2')}
                                )
                              ]
                            )
                            (C {(shift)})
                          ]
                        )
                        (case_arm
                          pat_list: [{(-f)} {(--force)}]
                          action: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:force)
                                  op: Equal
                                  rhs: {($ VSub_Number '$1')}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-q)} {(--quiet)}]
                          action: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:GIT_QUIET)
                                  op: Equal
                                  rhs: {(1)}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--reference)}]
                          action: [
                            (command.Case
                              to_match: {(DQ ($ VSub_Number '$2'))}
                              arms: [(case_arm pat_list:[{(SQ )}] action:[(C {(usage)})])]
                            )
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:reference_path)
                                  op: Equal
                                  rhs: {($ VSub_Number '$2')}
                                )
                              ]
                            )
                            (C {(shift)})
                          ]
                        )
                        (case_arm
                          pat_list: [{(--reference) (Lit_Other '=') (Lit_Star '*')}]
                          action: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:reference_path)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (word_part.BracedVarSub
                                          token: <VSub_Number 1>
                                          suffix_op: 
                                            (suffix_op.Unary
                                              op_id: VOp1_Pound
                                              arg_word: {('--reference=')}
                                            )
                                        )
                                      )
                                    }
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--name)}]
                          action: [
                            (command.Case
                              to_match: {(DQ ($ VSub_Number '$2'))}
                              arms: [(case_arm pat_list:[{(SQ )}] action:[(C {(usage)})])]
                            )
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:custom_name)
                                  op: Equal
                                  rhs: {($ VSub_Number '$2')}
                                )
                              ]
                            )
                            (C {(shift)})
                          ]
                        )
                        (case_arm
                          pat_list: [{(--depth)}]
                          action: [
                            (command.Case
                              to_match: {(DQ ($ VSub_Number '$2'))}
                              arms: [(case_arm pat_list:[{(SQ )}] action:[(C {(usage)})])]
                            )
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:depth)
                                  op: Equal
                                  rhs: {(DQ ('--depth=') ($ VSub_Number '$2'))}
                                )
                              ]
                            )
                            (C {(shift)})
                          ]
                        )
                        (case_arm
                          pat_list: [{(--depth) (Lit_Other '=') (Lit_Star '*')}]
                          action: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:depth)
                                  op: Equal
                                  rhs: {($ VSub_Number '$1')}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--)}]
                          action: [(C {(shift)}) (command.ControlFlow token:<ControlFlow_Break break>)]
                        )
                        (case_arm
                          pat_list: [{(-) (Lit_Star '*')}]
                          action: [(C {(usage)})]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*')}]
                          action: [(command.ControlFlow token:<ControlFlow_Break break>)]
                        )
                      ]
                    )
                    (C {(shift)})
                  ]
                )
            )
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$reference_path'))})]
                  action: [
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(is_absolute_path)} {(DQ ($ VSub_DollarName '$reference_path'))})
                        (command.Assignment
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:reference_path)
                              op: Equal
                              rhs: 
                                {
                                  (DQ ($ VSub_DollarName '$wt_prefix') 
                                    ($ VSub_DollarName '$reference_path')
                                  )
                                }
                            )
                          ]
                        )
                      ]
                    )
                    (command.Assignment
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:reference)
                          op: Equal
                          rhs: {(DQ ('--reference=') ($ VSub_DollarName '$reference_path'))}
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.Assignment
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:repo)
                  op: Equal
                  rhs: {($ VSub_Number '$1')}
                )
              ]
            )
            (command.Assignment
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:sm_path)
                  op: Equal
                  rhs: {($ VSub_Number '$2')}
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$sm_path'))})
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (command.Assignment
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:sm_path)
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSub
                                left_token: <Left_DollarParen '$('>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (command.Pipeline
                                        children: [
                                          (C {(printf)} {(SQ <'%s\\n'>)} 
                                            {(DQ ($ VSub_DollarName '$repo'))}
                                          )
                                          (C {(sed)} {(-e)} {(SQ <'s|/$||'>)} {(-e)} 
                                            {(SQ <'s|:*/*\\.git$||'>)} {(-e)} {(SQ <'s|.*[/:]||g'>)}
                                          )
                                        ]
                                        negated: F
                                      )
                                    ]
                                  )
                              )
                            }
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.AndOr
                          ops: [Op_DPipe]
                          children: [
                            (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$repo'))})
                            (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$sm_path'))})
                          ]
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [(C {(usage)})]
                )
              ]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(is_absolute_path)} {(DQ ($ VSub_DollarName '$sm_path'))})
                (command.Assignment
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:sm_path)
                      op: Equal
                      rhs: {(DQ ($ VSub_DollarName '$wt_prefix') ($ VSub_DollarName '$sm_path'))}
                    )
                  ]
                )
              ]
            )
            (command.Case
              to_match: {(DQ ($ VSub_DollarName '$repo'))}
              arms: [
                (case_arm
                  pat_list: [{(./) (Lit_Star '*')} {(../) (Lit_Star '*')}]
                  action: [
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$wt_prefix'))})
                        (C {(die)} 
                          {
                            (DQ 
                              (word_part.CommandSub
                                left_token: <Left_DollarParen '$('>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(gettext)} 
                                        {
                                          (DQ 
                                            (
'Relative path can only be used from the toplevel of the working tree'
                                            )
                                          )
                                        }
                                      )
                                    ]
                                  )
                              )
                            )
                          }
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (command.Assignment
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:realrepo)
                              op: Equal
                              rhs: 
                                {
                                  (word_part.CommandSub
                                    left_token: <Left_DollarParen '$('>
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(git)} {(submodule--helper)} {(resolve-relative-url)} 
                                            {(DQ ($ VSub_DollarName '$repo'))}
                                          )
                                        ]
                                      )
                                  )
                                }
                            )
                          ]
                        )
                        (command.ControlFlow token:<ControlFlow_Exit exit>)
                      ]
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(Lit_Star '*') (Lit_Other ':') (Lit_Star '*')} {(/) (Lit_Star '*')}]
                  action: [
                    (command.Assignment
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:realrepo)
                          op: Equal
                          rhs: {($ VSub_DollarName '$repo')}
                        )
                      ]
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(Lit_Star '*')}]
                  action: [
                    (C {(die)} 
                      {
                        (DQ 
                          (word_part.CommandSub
                            left_token: <Left_DollarParen '$('>
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ ("repo URL: '") 
                                        (word_part.EscapedLiteral
                                          token: <Lit_EscapedChar '\\$'>
                                        ) ("repo' must be absolute or begin with ./|../")
                                      )
                                    }
                                  )
                                ]
                              )
                          )
                        )
                      }
                    )
                  ]
                )
              ]
            )
            (command.Assignment
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:sm_path)
                  op: Equal
                  rhs: 
                    {
                      (word_part.CommandSub
                        left_token: <Left_DollarParen '$('>
                        command_list: 
                          (command.CommandList
                            children: [
                              (command.Pipeline
                                children: [
                                  (C {(printf)} {(SQ <'%s/\\n'>)} {(DQ ($ 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
                              )
                            ]
                          )
                      )
                    }
                )
              ]
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (command.Simple
                  words: [{(git)} {(ls-files)} {(--error-unmatch)} {(DQ ($ VSub_DollarName '$sm_path'))}]
                  redirects: [
                    (redir.Redir
                      op: <Redir_Great '>'>
                      fd: 16777215
                      arg_word: {(/dev/null)}
                    )
                    (redir.Redir op:<Redir_GreatAnd '2>&'> fd:2 arg_word:{(1)})
                  ]
                )
                (C {(die)} 
                  {
                    (DQ 
                      (word_part.CommandSub
                        left_token: <Left_DollarParen '$('>
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {(eval_gettext)} 
                                {
                                  (DQ ("'") (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) 
                                    ("sm_path' already exists in the index")
                                  )
                                }
                              )
                            ]
                          )
                      )
                    )
                  }
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$force'))})
                        (command.Pipeline
                          children: [
                            (command.Simple
                              words: [
                                {(git)}
                                {(add)}
                                {(--dry-run)}
                                {(--ignore-missing)}
                                {(DQ ($ VSub_DollarName '$sm_path'))}
                              ]
                              redirects: [
                                (redir.Redir
                                  op: <Redir_Great '>'>
                                  fd: 16777215
                                  arg_word: {(/dev/null)}
                                )
                                (redir.Redir
                                  op: <Redir_GreatAnd '2>&'>
                                  fd: 2
                                  arg_word: {(1)}
                                )
                              ]
                            )
                          ]
                          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: <Lit_EscapedChar '\\$'>
                            ) ('sm_path\n') ('Use -f if you really want to add it.')
                          )
                        }
                      ]
                      redirects: [(redir.Redir op:<Redir_GreatAnd '>&'> fd:16777215 arg_word:{(2)})]
                    )
                    (command.ControlFlow
                      token: <ControlFlow_Exit exit>
                      arg_word: {(1)}
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$custom_name'))})]
                  action: [
                    (command.Assignment
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:sm_name)
                          op: Equal
                          rhs: {(DQ ($ VSub_DollarName '$custom_name'))}
                        )
                      ]
                    )
                  ]
                )
              ]
              else_action: [
                (command.Assignment
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:sm_name)
                      op: Equal
                      rhs: {(DQ ($ VSub_DollarName '$sm_path'))}
                    )
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-e)} {(DQ ($ VSub_DollarName '$sm_path'))})]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {(test)} {(-d)} {(DQ ($ VSub_DollarName '$sm_path')) (/.git)})
                                (C {(test)} {(-f)} {(DQ ($ VSub_DollarName '$sm_path')) (/.git)})
                              ]
                            )
                          ]
                          action: [
                            (C {(eval_gettextln)} 
                              {
                                (DQ ("Adding existing repo at '") 
                                  (word_part.EscapedLiteral
                                    token: <Lit_EscapedChar '\\$'>
                                  ) ("sm_path' to the index")
                                )
                              }
                            )
                          ]
                        )
                      ]
                      else_action: [
                        (C {(die)} 
                          {
                            (DQ 
                              (word_part.CommandSub
                                left_token: <Left_DollarParen '$('>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(eval_gettext)} 
                                        {
                                          (DQ ("'") 
                                            (word_part.EscapedLiteral
                                              token: <Lit_EscapedChar '\\$'>
                                            ) ("sm_path' already exists and is not a valid git repo")
                                          )
                                        }
                                      )
                                    ]
                                  )
                              )
                            )
                          }
                        )
                      ]
                    )
                  ]
                )
              ]
              else_action: [
                (command.If
                  arms: [
                    (if_arm
                      cond: [(C {(test)} {(-d)} {(DQ (.git/modules/) ($ VSub_DollarName '$sm_name'))})]
                      action: [
                        (command.If
                          arms: [
                            (if_arm
                              cond: [(C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$force'))})]
                              action: [
                                (command.Simple
                                  words: [
                                    {(eval_gettextln)}
                                    {
                                      (DQ ("A git directory for '") 
                                        (word_part.EscapedLiteral
                                          token: <Lit_EscapedChar '\\$'>
                                        ) ("sm_name' is found locally with remote(s):")
                                      )
                                    }
                                  ]
                                  redirects: [
                                    (redir.Redir
                                      op: <Redir_GreatAnd '>&'>
                                      fd: 16777215
                                      arg_word: {(2)}
                                    )
                                  ]
                                )
                                (command.Pipeline
                                  children: [
                                    (command.Simple
                                      words: [{(git)} {(remote)} {(-v)}]
                                      more_env: [
                                        (env_pair
                                          name: GIT_DIR
                                          val: {(DQ (.git/modules/) ($ VSub_DollarName '$sm_name'))}
                                        )
                                        (env_pair
                                          name: GIT_WORK_TREE
                                          val: {(.)}
                                        )
                                      ]
                                    )
                                    (C {(grep)} {(SQ <'(fetch)'>)})
                                    (command.Simple
                                      words: [
                                        {(sed)}
                                        {(-e)}
                                        {(s) (Lit_Comma ',') (Lit_Other '^') (Lit_Comma ',') (DQ ('  ')) 
                                          (Lit_Comma ',')
                                        }
                                        {(-e)}
                                        {(s) (Lit_Comma ',') (SQ <' (fetch)'>) (Lit_Comma ',') 
                                          (Lit_Comma ',')
                                        }
                                      ]
                                      redirects: [
                                        (redir.Redir
                                          op: <Redir_GreatAnd '>&'>
                                          fd: 16777215
                                          arg_word: {(2)}
                                        )
                                      ]
                                    )
                                  ]
                                  negated: F
                                )
                                (C {(die)} 
                                  {
                                    (DQ 
                                      (word_part.CommandSub
                                        left_token: <Left_DollarParen '$('>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (C {(eval_gettextln)} 
                                                {
                                                  (DQ 
                                                    (
'If you want to reuse this local git directory instead of cloning again from\n'
                                                    ) ('  ') (word_part.EscapedLiteral token:<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.")
                                                  )
                                                }
                                              )
                                            ]
                                          )
                                      )
                                    )
                                  }
                                )
                              ]
                            )
                          ]
                          else_action: [
                            (C {(eval_gettextln)} 
                              {
                                (DQ ("Reactivating local git directory for submodule '") 
                                  (word_part.EscapedLiteral
                                    token: <Lit_EscapedChar '\\$'>
                                  ) ("sm_name'.")
                                )
                              }
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
                (command.AndOr
                  ops: [Op_DPipe]
                  children: [
                    (C {(git)} {(submodule--helper)} {(clone)} 
                      {
                        (word_part.BracedVarSub
                          token: <VSub_Name GIT_QUIET>
                          suffix_op: (suffix_op.Unary op_id:VTest_ColonPlus arg_word:{(--quiet)})
                        )
                      } {(--prefix)} {(DQ ($ VSub_DollarName '$wt_prefix'))} {(--path)} {(DQ ($ VSub_DollarName '$sm_path'))} 
                      {(--name)} {(DQ ($ VSub_DollarName '$sm_name'))} {(--url)} {(DQ ($ VSub_DollarName '$realrepo'))} 
                      {
                        (word_part.BracedVarSub
                          token: <VSub_Name reference>
                          suffix_op: 
                            (suffix_op.Unary
                              op_id: VTest_ColonPlus
                              arg_word: {(DQ ($ VSub_DollarName '$reference'))}
                            )
                        )
                      } 
                      {
                        (word_part.BracedVarSub
                          token: <VSub_Name depth>
                          suffix_op: 
                            (suffix_op.Unary
                              op_id: VTest_ColonPlus
                              arg_word: {(DQ ($ VSub_DollarName '$depth'))}
                            )
                        )
                      }
                    )
                    (command.ControlFlow token:<ControlFlow_Exit exit>)
                  ]
                )
                (command.AndOr
                  ops: [Op_DPipe]
                  children: [
                    (command.Subshell
                      command_list: 
                        (command.CommandList
                          children: [
                            (C {(sanitize_submodule_env)})
                            (command.AndOr
                              ops: [Op_DAmp]
                              children: [
                                (C {(cd)} {(DQ ($ VSub_DollarName '$sm_path'))})
                                (command.Case
                                  to_match: {(DQ ($ VSub_DollarName '$branch'))}
                                  arms: [
                                    (case_arm
                                      pat_list: [{(SQ )}]
                                      action: [(C {(git)} {(checkout)} {(-f)} {(-q)})]
                                    )
                                    (case_arm
                                      pat_list: [{(Lit_QMark '?') (Lit_Star '*')}]
                                      action: [
                                        (C {(git)} {(checkout)} {(-f)} {(-q)} {(-B)} 
                                          {(DQ ($ VSub_DollarName '$branch'))} {(DQ (origin/) ($ VSub_DollarName '$branch'))}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (C {(die)} 
                      {
                        (DQ 
                          (word_part.CommandSub
                            left_token: <Left_DollarParen '$('>
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ ("Unable to checkout submodule '") 
                                        (word_part.EscapedLiteral
                                          token: <Lit_EscapedChar '\\$'>
                                        ) ("sm_path'")
                                      )
                                    }
                                  )
                                ]
                              )
                          )
                        )
                      }
                    )
                  ]
                )
              ]
            )
            (C {(git)} {(config)} {(submodule.) (DQ ($ VSub_DollarName '$sm_name')) (.url)} 
              {(DQ ($ VSub_DollarName '$realrepo'))}
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(git)} {(add)} {($ VSub_DollarName '$force')} {(DQ ($ VSub_DollarName '$sm_path'))})
                (C {(die)} 
                  {
                    (DQ 
                      (word_part.CommandSub
                        left_token: <Left_DollarParen '$('>
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {(eval_gettext)} 
                                {
                                  (DQ ("Failed to add submodule '") 
                                    (word_part.EscapedLiteral
                                      token: <Lit_EscapedChar '\\$'>
                                    ) ("sm_path'")
                                  )
                                }
                              )
                            ]
                          )
                      )
                    )
                  }
                )
              ]
            )
            (command.AndOr
              ops: [Op_DAmp Op_DAmp Op_DAmp Op_DPipe]
              children: [
                (C {(git)} {(config)} {(-f)} {(.gitmodules)} 
                  {(submodule.) (DQ ($ VSub_DollarName '$sm_name')) (.path)} {(DQ ($ VSub_DollarName '$sm_path'))}
                )
                (C {(git)} {(config)} {(-f)} {(.gitmodules)} 
                  {(submodule.) (DQ ($ VSub_DollarName '$sm_name')) (.url)} {(DQ ($ VSub_DollarName '$repo'))}
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: [(C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$branch'))})]
                      action: [
                        (C {(git)} {(config)} {(-f)} {(.gitmodules)} 
                          {(submodule.) (DQ ($ VSub_DollarName '$sm_name')) (.branch)} {(DQ ($ VSub_DollarName '$branch'))}
                        )
                      ]
                    )
                  ]
                )
                (C {(git)} {(add)} {(--force)} {(.gitmodules)})
                (C {(die)} 
                  {
                    (DQ 
                      (word_part.CommandSub
                        left_token: <Left_DollarParen '$('>
                        command_list: 
                          (command.CommandList
                            children: [
                              (C {(eval_gettext)} 
                                {
                                  (DQ ("Failed to register submodule '") 
                                    (word_part.EscapedLiteral
                                      token: <Lit_EscapedChar '\\$'>
                                    ) ("sm_path'")
                                  )
                                }
                              )
                            ]
                          )
                      )
                    )
                  }
                )
              ]
            )
          ]
        )
    )
    (command.FuncDef
      name: cmd_foreach
      body: 
        (command.BraceGroup
          children: [
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [(C {(test)} {($ VSub_Pound '$#')} {(-ne)} {(0)})]
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ VSub_Number '$1'))}
                      arms: [
                        (case_arm
                          pat_list: [{(-q)} {(--quiet)}]
                          action: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:GIT_QUIET)
                                  op: Equal
                                  rhs: {(1)}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--recursive)}]
                          action: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:recursive)
                                  op: Equal
                                  rhs: {(1)}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-) (Lit_Star '*')}]
                          action: [(C {(usage)})]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*')}]
                          action: [(command.ControlFlow token:<ControlFlow_Break break>)]
                        )
                      ]
                    )
                    (C {(shift)})
                  ]
                )
            )
            (command.Assignment
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:toplevel)
                  op: Equal
                  rhs: 
                    {
                      (word_part.CommandSub
                        left_token: <Left_DollarParen '$('>
                        command_list: (command.CommandList children:[(C {(pwd)})])
                      )
                    }
                )
              ]
            )
            (command.Simple
              words: [{(exec)}]
              redirects: [(redir.Redir op:<Redir_LessAnd '3<&'> fd:3 arg_word:{(0)})]
            )
            (command.Pipeline
              children: [
                (command.BraceGroup
                  children: [
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(git)} {(submodule--helper)} {(list)} {(--prefix)} 
                          {(DQ ($ VSub_DollarName '$wt_prefix'))}
                        )
                        (C {(echo)} {(DQ ('#unmatched'))} {($ VSub_QMark '$?')})
                      ]
                    )
                  ]
                )
                (command.WhileUntil
                  keyword: <KW_While while>
                  cond: [(C {(read)} {(mode)} {(sha1)} {(stage)} {(sm_path)})]
                  body: 
                    (command.DoGroup
                      children: [
                        (C {(die_if_unmatched)} {(DQ ($ VSub_DollarName '$mode'))} 
                          {(DQ ($ VSub_DollarName '$sha1'))}
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: [(C {(test)} {(-e)} {(DQ ($ VSub_DollarName '$sm_path')) (/.git)})]
                              action: [
                                (command.Assignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:displaypath)
                                      op: Equal
                                      rhs: 
                                        {
                                          (word_part.CommandSub
                                            left_token: <Left_DollarParen '$('>
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (C {(git)} {(submodule--helper)} {(relative-path)} 
                                                    {
                                                      (DQ ($ VSub_DollarName '$prefix') 
                                                        ($ VSub_DollarName '$sm_path')
                                                      )
                                                    } {(DQ ($ VSub_DollarName '$wt_prefix'))}
                                                  )
                                                ]
                                              )
                                          )
                                        }
                                    )
                                  ]
                                )
                                (C {(say)} 
                                  {
                                    (DQ 
                                      (word_part.CommandSub
                                        left_token: <Left_DollarParen '$('>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (C {(eval_gettext)} 
                                                {
                                                  (DQ ("Entering '") 
                                                    (word_part.EscapedLiteral
                                                      token: <Lit_EscapedChar '\\$'>
                                                    ) ("displaypath'")
                                                  )
                                                }
                                              )
                                            ]
                                          )
                                      )
                                    )
                                  }
                                )
                                (command.Assignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:name)
                                      op: Equal
                                      rhs: 
                                        {
                                          (word_part.CommandSub
                                            left_token: <Left_DollarParen '$('>
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (C {(git)} {(submodule--helper)} {(name)} 
                                                    {(DQ ($ VSub_DollarName '$sm_path'))}
                                                  )
                                                ]
                                              )
                                          )
                                        }
                                    )
                                  ]
                                )
                                (command.AndOr
                                  ops: [Op_DPipe]
                                  children: [
                                    (command.Subshell
                                      command_list: 
                                        (command.CommandList
                                          children: [
                                            (command.Assignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (lhs_expr.LhsName name:prefix)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_DollarName '$prefix') 
                                                        ($ VSub_DollarName '$sm_path') (/)
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                            (C {(sanitize_submodule_env)})
                                            (command.AndOr
                                              ops: [Op_DAmp Op_DAmp Op_DAmp Op_DAmp]
                                              children: [
                                                (C {(cd)} {(DQ ($ VSub_DollarName '$sm_path'))})
                                                (command.Assignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (lhs_expr.LhsName name:sm_path)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (word_part.CommandSub
                                                            left_token: <Left_DollarParen '$('>
                                                            command_list: 
                                                              (command.CommandList
                                                                children: [
                                                                  (C {(git)} {(submodule--helper)} 
                                                                    {(relative-path)} {(DQ ($ VSub_DollarName '$sm_path'))} {(DQ ($ VSub_DollarName '$wt_prefix'))}
                                                                  )
                                                                ]
                                                              )
                                                          )
                                                        }
                                                    )
                                                  ]
                                                )
                                                (command.Assignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (lhs_expr.LhsName name:path)
                                                      op: Equal
                                                      rhs: {($ VSub_DollarName '$sm_path')}
                                                    )
                                                  ]
                                                )
                                                (command.If
                                                  arms: [
                                                    (if_arm
                                                      cond: [
                                                        (C {(test)} {($ VSub_Pound '$#')} {(-eq)} {(1)})
                                                      ]
                                                      action: [(C {(eval)} {(DQ ($ VSub_Number '$1'))})]
                                                    )
                                                  ]
                                                  else_action: [(C {(DQ ($ VSub_At '$@'))})]
                                                )
                                                (command.If
                                                  arms: [
                                                    (if_arm
                                                      cond: [
                                                        (C {(test)} {(-n)} 
                                                          {(DQ ($ VSub_DollarName '$recursive'))}
                                                        )
                                                      ]
                                                      action: [
                                                        (C {(cmd_foreach)} {(DQ (--recursive))} 
                                                          {(DQ ($ VSub_At '$@'))}
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      redirects: [
                                        (redir.Redir
                                          op: <Redir_LessAnd '<&'>
                                          fd: 16777215
                                          arg_word: {(3)}
                                        )
                                        (redir.Redir
                                          op: <Redir_LessAnd '3<&'>
                                          fd: 3
                                          arg_word: {(-)}
                                        )
                                      ]
                                    )
                                    (C {(die)} 
                                      {
                                        (DQ 
                                          (word_part.CommandSub
                                            left_token: <Left_DollarParen '$('>
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (C {(eval_gettext)} 
                                                    {
                                                      (DQ ("Stopping at '") 
                                                        (word_part.EscapedLiteral
                                                          token: <Lit_EscapedChar '\\$'>
                                                        ) ("displaypath'; script returned non-zero status.")
                                                      )
                                                    }
                                                  )
                                                ]
                                              )
                                          )
                                        )
                                      }
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                )
              ]
              negated: F
            )
          ]
        )
    )
    (command.FuncDef
      name: cmd_init
      body: 
        (command.BraceGroup
          children: [
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [(C {(test)} {($ VSub_Pound '$#')} {(-ne)} {(0)})]
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ VSub_Number '$1'))}
                      arms: [
                        (case_arm
                          pat_list: [{(-q)} {(--quiet)}]
                          action: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:GIT_QUIET)
                                  op: Equal
                                  rhs: {(1)}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--)}]
                          action: [(C {(shift)}) (command.ControlFlow token:<ControlFlow_Break break>)]
                        )
                        (case_arm
                          pat_list: [{(-) (Lit_Star '*')}]
                          action: [(C {(usage)})]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*')}]
                          action: [(command.ControlFlow token:<ControlFlow_Break break>)]
                        )
                      ]
                    )
                    (C {(shift)})
                  ]
                )
            )
            (C {(git)} 
              {
                (word_part.BracedVarSub
                  token: <VSub_Name wt_prefix>
                  suffix_op: 
                    (suffix_op.Unary
                      op_id: VTest_ColonPlus
                      arg_word: {('-C ') (DQ ($ VSub_DollarName '$wt_prefix'))}
                    )
                )
              } {(submodule--helper)} {(init)} 
              {
                (word_part.BracedVarSub
                  token: <VSub_Name GIT_QUIET>
                  suffix_op: (suffix_op.Unary op_id:VTest_ColonPlus arg_word:{(--quiet)})
                )
              } 
              {
                (word_part.BracedVarSub
                  token: <VSub_Name prefix>
                  suffix_op: 
                    (suffix_op.Unary
                      op_id: VTest_ColonPlus
                      arg_word: {('--prefix ') (DQ ($ VSub_DollarName '$prefix'))}
                    )
                )
              } {(DQ ($ VSub_At '$@'))}
            )
          ]
        )
    )
    (command.FuncDef
      name: cmd_deinit
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              pairs: [(assign_pair lhs:(lhs_expr.LhsName name:deinit_all) op:Equal rhs:(word.Empty))]
            )
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [(C {(test)} {($ VSub_Pound '$#')} {(-ne)} {(0)})]
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ VSub_Number '$1'))}
                      arms: [
                        (case_arm
                          pat_list: [{(-f)} {(--force)}]
                          action: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:force)
                                  op: Equal
                                  rhs: {($ VSub_Number '$1')}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-q)} {(--quiet)}]
                          action: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:GIT_QUIET)
                                  op: Equal
                                  rhs: {(1)}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--all)}]
                          action: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:deinit_all)
                                  op: Equal
                                  rhs: {(t)}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--)}]
                          action: [(C {(shift)}) (command.ControlFlow token:<ControlFlow_Break break>)]
                        )
                        (case_arm
                          pat_list: [{(-) (Lit_Star '*')}]
                          action: [(C {(usage)})]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*')}]
                          action: [(command.ControlFlow token:<ControlFlow_Break break>)]
                        )
                      ]
                    )
                    (C {(shift)})
                  ]
                )
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$deinit_all'))})
                        (C {(test)} {(DQ ($ VSub_Pound '$#'))} {(-ne)} {(0)})
                      ]
                    )
                  ]
                  action: [
                    (command.Simple
                      words: [
                        {(echo)}
                        {
                          (DQ 
                            (word_part.CommandSub
                              left_token: <Left_DollarParen '$('>
                              command_list: 
                                (command.CommandList
                                  children: [
                                    (C {(eval_gettext)} {(DQ ('pathspec and --all are incompatible'))})
                                  ]
                                )
                            )
                          )
                        }
                      ]
                      redirects: [(redir.Redir op:<Redir_GreatAnd '>&'> fd:16777215 arg_word:{(2)})]
                    )
                    (C {(usage)})
                  ]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {($ VSub_Pound '$#')} {(Lit_Other '=')} {(0)})
                        (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$deinit_all'))})
                      ]
                    )
                  ]
                  action: [
                    (C {(die)} 
                      {
                        (DQ 
                          (word_part.CommandSub
                            left_token: <Left_DollarParen '$('>
                            command_list: 
                              (command.CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ 
                                        (
"Use '--all' if you really want to deinitialize all submodules"
                                        )
                                      )
                                    }
                                  )
                                ]
                              )
                          )
                        )
                      }
                    )
                  ]
                )
              ]
            )
            (command.Pipeline
              children: [
                (command.BraceGroup
                  children: [
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(git)} {(submodule--helper)} {(list)} {(--prefix)} 
                          {(DQ ($ VSub_DollarName '$wt_prefix'))} {(DQ ($ VSub_At '$@'))}
                        )
                        (C {(echo)} {(DQ ('#unmatched'))} {($ VSub_QMark '$?')})
                      ]
                    )
                  ]
                )
                (command.WhileUntil
                  keyword: <KW_While while>
                  cond: [(C {(read)} {(mode)} {(sha1)} {(stage)} {(sm_path)})]
                  body: 
                    (command.DoGroup
                      children: [
                        (C {(die_if_unmatched)} {(DQ ($ VSub_DollarName '$mode'))} 
                          {(DQ ($ VSub_DollarName '$sha1'))}
                        )
                        (command.AndOr
                          ops: [Op_DPipe]
                          children: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:name)
                                  op: Equal
                                  rhs: 
                                    {
                                      (word_part.CommandSub
                                        left_token: <Left_DollarParen '$('>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (C {(git)} {(submodule--helper)} {(name)} 
                                                {(DQ ($ VSub_DollarName '$sm_path'))}
                                              )
                                            ]
                                          )
                                      )
                                    }
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Exit exit>
                            )
                          ]
                        )
                        (command.Assignment
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:displaypath)
                              op: Equal
                              rhs: 
                                {
                                  (word_part.CommandSub
                                    left_token: <Left_DollarParen '$('>
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(git)} {(submodule--helper)} {(relative-path)} 
                                            {(DQ ($ VSub_DollarName '$sm_path'))} {(DQ ($ VSub_DollarName '$wt_prefix'))}
                                          )
                                        ]
                                      )
                                  )
                                }
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: [(C {(test)} {(-d)} {(DQ ($ VSub_DollarName '$sm_path'))})]
                              action: [
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (C {(test)} {(-d)} {(DQ ($ VSub_DollarName '$sm_path') (/.git))})
                                      ]
                                      action: [
                                        (C {(die)} 
                                          {
                                            (DQ 
                                              (word_part.CommandSub
                                                left_token: <Left_DollarParen '$('>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [
                                                      (C {(eval_gettext)} 
                                                        {
                                                          (DQ ("Submodule work tree '") 
                                                            (word_part.EscapedLiteral
                                                              token: <Lit_EscapedChar '\\$'>
                                                            ) ("displaypath' contains a .git directory\n") 
                                                            (
"(use 'rm -rf' if you really want to remove it including all of its history)"
                                                            )
                                                          )
                                                        }
                                                      )
                                                    ]
                                                  )
                                              )
                                            )
                                          }
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: [(C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$force'))})]
                                      action: [
                                        (command.AndOr
                                          ops: [Op_DPipe]
                                          children: [
                                            (C {(git)} {(rm)} {(-qn)} 
                                              {(DQ ($ VSub_DollarName '$sm_path'))}
                                            )
                                            (C {(die)} 
                                              {
                                                (DQ 
                                                  (word_part.CommandSub
                                                    left_token: <Left_DollarParen '$('>
                                                    command_list: 
                                                      (command.CommandList
                                                        children: [
                                                          (C {(eval_gettext)} 
                                                            {
                                                              (DQ ("Submodule work tree '") 
                                                                (word_part.EscapedLiteral
                                                                  token: <Lit_EscapedChar '\\$'>
                                                                ) ("displaypath' contains local modifications; use '-f' to discard them")
                                                              )
                                                            }
                                                          )
                                                        ]
                                                      )
                                                  )
                                                )
                                              }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (command.AndOr
                                  ops: [Op_DAmp Op_DPipe]
                                  children: [
                                    (C {(rm)} {(-rf)} {(DQ ($ VSub_DollarName '$sm_path'))})
                                    (C {(say)} 
                                      {
                                        (DQ 
                                          (word_part.CommandSub
                                            left_token: <Left_DollarParen '$('>
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (C {(eval_gettext)} 
                                                    {
                                                      (DQ ("Cleared directory '") 
                                                        (word_part.EscapedLiteral
                                                          token: <Lit_EscapedChar '\\$'>
                                                        ) ("displaypath'")
                                                      )
                                                    }
                                                  )
                                                ]
                                              )
                                          )
                                        )
                                      }
                                    )
                                    (C {(say)} 
                                      {
                                        (DQ 
                                          (word_part.CommandSub
                                            left_token: <Left_DollarParen '$('>
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (C {(eval_gettext)} 
                                                    {
                                                      (DQ ("Could not remove submodule work tree '") 
                                                        (word_part.EscapedLiteral
                                                          token: <Lit_EscapedChar '\\$'>
                                                        ) ("displaypath'")
                                                      )
                                                    }
                                                  )
                                                ]
                                              )
                                          )
                                        )
                                      }
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                        (command.AndOr
                          ops: [Op_DPipe]
                          children: [
                            (C {(mkdir)} {(DQ ($ VSub_DollarName '$sm_path'))})
                            (C {(say)} 
                              {
                                (DQ 
                                  (word_part.CommandSub
                                    left_token: <Left_DollarParen '$('>
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(eval_gettext)} 
                                            {
                                              (DQ ("Could not create empty submodule directory '") 
                                                (word_part.EscapedLiteral
                                                  token: <Lit_EscapedChar '\\$'>
                                                ) ("displaypath'")
                                              )
                                            }
                                          )
                                        ]
                                      )
                                  )
                                )
                              }
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (C {(test)} {(-n)} 
                                  {
                                    (DQ 
                                      (word_part.CommandSub
                                        left_token: <Left_DollarParen '$('>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (C {(git)} {(config)} {(--get-regexp)} 
                                                {(submodule.) 
                                                  (DQ ($ VSub_DollarName '$name') (Lit_Other '\\') (.))
                                                }
                                              )
                                            ]
                                          )
                                      )
                                    )
                                  }
                                )
                              ]
                              action: [
                                (command.Assignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:url)
                                      op: Equal
                                      rhs: 
                                        {
                                          (word_part.CommandSub
                                            left_token: <Left_DollarParen '$('>
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (C {(git)} {(config)} 
                                                    {(submodule.) (DQ ($ VSub_DollarName '$name')) 
                                                      (.url)
                                                    }
                                                  )
                                                ]
                                              )
                                          )
                                        }
                                    )
                                  ]
                                )
                                (command.AndOr
                                  ops: [Op_DAmp]
                                  children: [
                                    (command.Simple
                                      words: [
                                        {(git)}
                                        {(config)}
                                        {(--remove-section)}
                                        {(submodule.) (DQ ($ VSub_DollarName '$name'))}
                                      ]
                                      redirects: [
                                        (redir.Redir
                                          op: <Redir_Great '2>'>
                                          fd: 2
                                          arg_word: {(/dev/null)}
                                        )
                                      ]
                                    )
                                    (C {(say)} 
                                      {
                                        (DQ 
                                          (word_part.CommandSub
                                            left_token: <Left_DollarParen '$('>
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (C {(eval_gettext)} 
                                                    {
                                                      (DQ ("Submodule '") 
                                                        (word_part.EscapedLiteral
                                                          token: <Lit_EscapedChar '\\$'>
                                                        ) ("name' (") (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ("url) unregistered for path '") 
                                                        (word_part.EscapedLiteral
                                                          token: <Lit_EscapedChar '\\$'>
                                                        ) ("displaypath'")
                                                      )
                                                    }
                                                  )
                                                ]
                                              )
                                          )
                                        )
                                      }
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                )
              ]
              negated: F
            )
          ]
        )
    )
    (command.FuncDef
      name: is_tip_reachable
      body: 
        (command.Subshell
          command_list: 
            (command.CommandList
              children: [
                (command.AndOr
                  ops: [Op_DAmp Op_DAmp Op_DAmp]
                  children: [
                    (C {(sanitize_submodule_env)})
                    (C {(cd)} {(DQ ($ VSub_Number '$1'))})
                    (command.Assignment
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:rev)
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSub
                                left_token: <Left_DollarParen '$('>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (command.Simple
                                        words: [
                                          {(git)}
                                          {(rev-list)}
                                          {(-n)}
                                          {(1)}
                                          {(DQ ($ VSub_Number '$2'))}
                                          {(--not)}
                                          {(--all)}
                                        ]
                                        redirects: [
                                          (redir.Redir
                                            op: <Redir_Great '2>'>
                                            fd: 2
                                            arg_word: {(/dev/null)}
                                          )
                                        ]
                                      )
                                    ]
                                  )
                              )
                            }
                        )
                      ]
                    )
                    (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$rev'))})
                  ]
                )
              ]
            )
        )
    )
    (command.FuncDef
      name: fetch_in_submodule
      body: 
        (command.Subshell
          command_list: 
            (command.CommandList
              children: [
                (command.AndOr
                  ops: [Op_DAmp Op_DAmp]
                  children: [
                    (C {(sanitize_submodule_env)})
                    (C {(cd)} {(DQ ($ VSub_Number '$1'))})
                    (command.Case
                      to_match: {(DQ ($ VSub_Number '$2'))}
                      arms: [
                        (case_arm
                          pat_list: [{(SQ )}]
                          action: [(C {(git)} {(fetch)})]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*')}]
                          action: [
                            (C {(shift)})
                            (C {(git)} {(fetch)} 
                              {
                                (word_part.CommandSub
                                  left_token: <Left_DollarParen '$('>
                                  command_list: 
                                    (command.CommandList
                                      children: [(C {(get_default_remote)})]
                                    )
                                )
                              } {(DQ ($ VSub_At '$@'))}
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
        )
    )
    (command.FuncDef
      name: cmd_update
      body: 
        (command.BraceGroup
          children: [
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [(C {(test)} {($ VSub_Pound '$#')} {(-ne)} {(0)})]
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ VSub_Number '$1'))}
                      arms: [
                        (case_arm
                          pat_list: [{(-q)} {(--quiet)}]
                          action: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:GIT_QUIET)
                                  op: Equal
                                  rhs: {(1)}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--progress)}]
                          action: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:progress)
                                  op: Equal
                                  rhs: {(DQ (--progress))}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-i)} {(--init)}]
                          action: [
                            (command.Assignment
                              pairs: [(assign_pair lhs:(lhs_expr.LhsName name:init) op:Equal rhs:{(1)})]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--remote)}]
                          action: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:remote)
                                  op: Equal
                                  rhs: {(1)}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-N)} {(--no-fetch)}]
                          action: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:nofetch)
                                  op: Equal
                                  rhs: {(1)}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-f)} {(--force)}]
                          action: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:force)
                                  op: Equal
                                  rhs: {($ VSub_Number '$1')}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-r)} {(--rebase)}]
                          action: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:update)
                                  op: Equal
                                  rhs: {(DQ (rebase))}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--reference)}]
                          action: [
                            (command.Case
                              to_match: {(DQ ($ VSub_Number '$2'))}
                              arms: [(case_arm pat_list:[{(SQ )}] action:[(C {(usage)})])]
                            )
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:reference)
                                  op: Equal
                                  rhs: {(DQ ('--reference=') ($ VSub_Number '$2'))}
                                )
                              ]
                            )
                            (C {(shift)})
                          ]
                        )
                        (case_arm
                          pat_list: [{(--reference) (Lit_Other '=') (Lit_Star '*')}]
                          action: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:reference)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Number '$1'))}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-m)} {(--merge)}]
                          action: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:update)
                                  op: Equal
                                  rhs: {(DQ (merge))}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--recursive)}]
                          action: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:recursive)
                                  op: Equal
                                  rhs: {(1)}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--checkout)}]
                          action: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:update)
                                  op: Equal
                                  rhs: {(DQ (checkout))}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--recommend-shallow)}]
                          action: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:recommend_shallow)
                                  op: Equal
                                  rhs: {(DQ (--recommend-shallow))}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--no-recommend-shallow)}]
                          action: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:recommend_shallow)
                                  op: Equal
                                  rhs: {(DQ (--no-recommend-shallow))}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--depth)}]
                          action: [
                            (command.Case
                              to_match: {(DQ ($ VSub_Number '$2'))}
                              arms: [(case_arm pat_list:[{(SQ )}] action:[(C {(usage)})])]
                            )
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:depth)
                                  op: Equal
                                  rhs: {(DQ ('--depth=') ($ VSub_Number '$2'))}
                                )
                              ]
                            )
                            (C {(shift)})
                          ]
                        )
                        (case_arm
                          pat_list: [{(--depth) (Lit_Other '=') (Lit_Star '*')}]
                          action: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:depth)
                                  op: Equal
                                  rhs: {($ VSub_Number '$1')}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-j)} {(--jobs)}]
                          action: [
                            (command.Case
                              to_match: {(DQ ($ VSub_Number '$2'))}
                              arms: [(case_arm pat_list:[{(SQ )}] action:[(C {(usage)})])]
                            )
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:jobs)
                                  op: Equal
                                  rhs: {(DQ ('--jobs=') ($ VSub_Number '$2'))}
                                )
                              ]
                            )
                            (C {(shift)})
                          ]
                        )
                        (case_arm
                          pat_list: [{(--jobs) (Lit_Other '=') (Lit_Star '*')}]
                          action: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:jobs)
                                  op: Equal
                                  rhs: {($ VSub_Number '$1')}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--)}]
                          action: [(C {(shift)}) (command.ControlFlow token:<ControlFlow_Break break>)]
                        )
                        (case_arm
                          pat_list: [{(-) (Lit_Star '*')}]
                          action: [(C {(usage)})]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*')}]
                          action: [(command.ControlFlow token:<ControlFlow_Break break>)]
                        )
                      ]
                    )
                    (C {(shift)})
                  ]
                )
            )
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$init'))})]
                  action: [
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(cmd_init)} {(DQ (--))} {(DQ ($ VSub_At '$@'))})
                        (command.ControlFlow
                          token: <ControlFlow_Return return>
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.Pipeline
              children: [
                (command.BraceGroup
                  children: [
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(git)} {(submodule--helper)} {(update-clone)} 
                          {
                            (word_part.BracedVarSub
                              token: <VSub_Name GIT_QUIET>
                              suffix_op: (suffix_op.Unary op_id:VTest_ColonPlus arg_word:{(--quiet)})
                            )
                          } 
                          {
                            (word_part.BracedVarSub
                              token: <VSub_Name progress>
                              suffix_op: 
                                (suffix_op.Unary
                                  op_id: VTest_ColonPlus
                                  arg_word: {(DQ ($ VSub_DollarName '$progress'))}
                                )
                            )
                          } 
                          {
                            (word_part.BracedVarSub
                              token: <VSub_Name wt_prefix>
                              suffix_op: 
                                (suffix_op.Unary
                                  op_id: VTest_ColonPlus
                                  arg_word: {('--prefix ') (DQ ($ VSub_DollarName '$wt_prefix'))}
                                )
                            )
                          } 
                          {
                            (word_part.BracedVarSub
                              token: <VSub_Name prefix>
                              suffix_op: 
                                (suffix_op.Unary
                                  op_id: VTest_ColonPlus
                                  arg_word: 
                                    {('--recursive-prefix ') (DQ ($ VSub_DollarName '$prefix'))}
                                )
                            )
                          } 
                          {
                            (word_part.BracedVarSub
                              token: <VSub_Name update>
                              suffix_op: 
                                (suffix_op.Unary
                                  op_id: VTest_ColonPlus
                                  arg_word: {('--update ') (DQ ($ VSub_DollarName '$update'))}
                                )
                            )
                          } 
                          {
                            (word_part.BracedVarSub
                              token: <VSub_Name reference>
                              suffix_op: 
                                (suffix_op.Unary
                                  op_id: VTest_ColonPlus
                                  arg_word: {(DQ ($ VSub_DollarName '$reference'))}
                                )
                            )
                          } 
                          {
                            (word_part.BracedVarSub
                              token: <VSub_Name depth>
                              suffix_op: 
                                (suffix_op.Unary
                                  op_id: VTest_ColonPlus
                                  arg_word: {('--depth ') (DQ ($ VSub_DollarName '$depth'))}
                                )
                            )
                          } 
                          {
                            (word_part.BracedVarSub
                              token: <VSub_Name recommend_shallow>
                              suffix_op: 
                                (suffix_op.Unary
                                  op_id: VTest_ColonPlus
                                  arg_word: {(DQ ($ VSub_DollarName '$recommend_shallow'))}
                                )
                            )
                          } 
                          {
                            (word_part.BracedVarSub
                              token: <VSub_Name jobs>
                              suffix_op: 
                                (suffix_op.Unary
                                  op_id: VTest_ColonPlus
                                  arg_word: {($ VSub_DollarName '$jobs')}
                                )
                            )
                          } {(DQ ($ VSub_At '$@'))}
                        )
                        (C {(echo)} {(DQ ('#unmatched'))} {($ VSub_QMark '$?')})
                      ]
                    )
                  ]
                )
                (command.BraceGroup
                  children: [
                    (command.Assignment
                      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:err) op:Equal rhs:(word.Empty))]
                    )
                    (command.WhileUntil
                      keyword: <KW_While while>
                      cond: [(C {(read)} {(mode)} {(sha1)} {(stage)} {(just_cloned)} {(sm_path)})]
                      body: 
                        (command.DoGroup
                          children: [
                            (C {(die_if_unmatched)} {(DQ ($ VSub_DollarName '$mode'))} 
                              {(DQ ($ VSub_DollarName '$sha1'))}
                            )
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (command.Assignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:name)
                                      op: Equal
                                      rhs: 
                                        {
                                          (word_part.CommandSub
                                            left_token: <Left_DollarParen '$('>
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (C {(git)} {(submodule--helper)} {(name)} 
                                                    {(DQ ($ VSub_DollarName '$sm_path'))}
                                                  )
                                                ]
                                              )
                                          )
                                        }
                                    )
                                  ]
                                )
                                (command.ControlFlow
                                  token: <ControlFlow_Exit exit>
                                )
                              ]
                            )
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:url)
                                  op: Equal
                                  rhs: 
                                    {
                                      (word_part.CommandSub
                                        left_token: <Left_DollarParen '$('>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (C {(git)} {(config)} 
                                                {(submodule.) (DQ ($ VSub_DollarName '$name')) (.url)}
                                              )
                                            ]
                                          )
                                      )
                                    }
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Pipeline
                                      children: [
                                        (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$update'))})
                                      ]
                                      negated: T
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:update_module)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$update')}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                              else_action: [
                                (command.Assignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:update_module)
                                      op: Equal
                                      rhs: 
                                        {
                                          (word_part.CommandSub
                                            left_token: <Left_DollarParen '$('>
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (C {(git)} {(config)} 
                                                    {(submodule.) (DQ ($ VSub_DollarName '$name')) 
                                                      (.update)
                                                    }
                                                  )
                                                ]
                                              )
                                          )
                                        }
                                    )
                                  ]
                                )
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$update_module'))})
                                      ]
                                      action: [
                                        (command.Assignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (lhs_expr.LhsName name:update_module)
                                              op: Equal
                                              rhs: {(DQ (checkout))}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:displaypath)
                                  op: Equal
                                  rhs: 
                                    {
                                      (word_part.CommandSub
                                        left_token: <Left_DollarParen '$('>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (C {(git)} {(submodule--helper)} {(relative-path)} 
                                                {
                                                  (DQ ($ VSub_DollarName '$prefix') 
                                                    ($ VSub_DollarName '$sm_path')
                                                  )
                                                } {(DQ ($ VSub_DollarName '$wt_prefix'))}
                                              )
                                            ]
                                          )
                                      )
                                    }
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (C {(test)} {($ VSub_DollarName '$just_cloned')} {(-eq)} {(1)})
                                  ]
                                  action: [
                                    (command.Assignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:subsha1)
                                          op: Equal
                                          rhs: (word.Empty)
                                        )
                                      ]
                                    )
                                    (command.Assignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:update_module)
                                          op: Equal
                                          rhs: {(checkout)}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                              else_action: [
                                (command.AndOr
                                  ops: [Op_DPipe]
                                  children: [
                                    (command.Assignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:subsha1)
                                          op: Equal
                                          rhs: 
                                            {
                                              (word_part.CommandSub
                                                left_token: <Left_DollarParen '$('>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [
                                                      (command.Sentence
                                                        child: (C {(sanitize_submodule_env)})
                                                        terminator: <Op_Semi ';'>
                                                      )
                                                      (command.AndOr
                                                        ops: [Op_DAmp]
                                                        children: [
                                                          (C {(cd)} 
                                                            {(DQ ($ VSub_DollarName '$sm_path'))}
                                                          )
                                                          (C {(git)} {(rev-parse)} {(--verify)} {(HEAD)})
                                                        ]
                                                      )
                                                    ]
                                                  )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (C {(die)} 
                                      {
                                        (DQ 
                                          (word_part.CommandSub
                                            left_token: <Left_DollarParen '$('>
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (C {(eval_gettext)} 
                                                    {
                                                      (DQ 
                                                        (
"Unable to find current revision in submodule path '"
                                                        ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ("displaypath'")
                                                      )
                                                    }
                                                  )
                                                ]
                                              )
                                          )
                                        )
                                      }
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [(C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$remote'))})]
                                  action: [
                                    (command.Assignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:branch)
                                          op: Equal
                                          rhs: 
                                            {
                                              (word_part.CommandSub
                                                left_token: <Left_DollarParen '$('>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [
                                                      (C {(git)} {(submodule--helper)} {(remote-branch)} 
                                                        {(DQ ($ VSub_DollarName '$sm_path'))}
                                                      )
                                                    ]
                                                  )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$nofetch'))})
                                          ]
                                          action: [
                                            (command.AndOr
                                              ops: [Op_DPipe]
                                              children: [
                                                (C {(fetch_in_submodule)} 
                                                  {(DQ ($ VSub_DollarName '$sm_path'))} {($ VSub_DollarName '$depth')}
                                                )
                                                (C {(die)} 
                                                  {
                                                    (DQ 
                                                      (word_part.CommandSub
                                                        left_token: <Left_DollarParen '$('>
                                                        command_list: 
                                                          (command.CommandList
                                                            children: [
                                                              (C {(eval_gettext)} 
                                                                {
                                                                  (DQ 
                                                                    (
"Unable to fetch in submodule path '"
                                                                    ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ("sm_path'")
                                                                  )
                                                                }
                                                              )
                                                            ]
                                                          )
                                                      )
                                                    )
                                                  }
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.Assignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:remote_name)
                                          op: Equal
                                          rhs: 
                                            {
                                              (word_part.CommandSub
                                                left_token: <Left_DollarParen '$('>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [
                                                      (command.Sentence
                                                        child: (C {(sanitize_submodule_env)})
                                                        terminator: <Op_Semi ';'>
                                                      )
                                                      (command.AndOr
                                                        ops: [Op_DAmp]
                                                        children: [
                                                          (C {(cd)} 
                                                            {(DQ ($ VSub_DollarName '$sm_path'))}
                                                          )
                                                          (C {(get_default_remote)})
                                                        ]
                                                      )
                                                    ]
                                                  )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (command.AndOr
                                      ops: [Op_DPipe]
                                      children: [
                                        (command.Assignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (lhs_expr.LhsName name:sha1)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (word_part.CommandSub
                                                    left_token: <Left_DollarParen '$('>
                                                    command_list: 
                                                      (command.CommandList
                                                        children: [
                                                          (command.Sentence
                                                            child: (C {(sanitize_submodule_env)})
                                                            terminator: <Op_Semi ';'>
                                                          )
                                                          (command.AndOr
                                                            ops: [Op_DAmp]
                                                            children: [
                                                              (C {(cd)} 
                                                                {(DQ ($ VSub_DollarName '$sm_path'))}
                                                              )
                                                              (C {(git)} {(rev-parse)} {(--verify)} 
                                                                {
                                                                  (DQ (${ VSub_Name remote_name) (/) 
                                                                    (${ VSub_Name branch)
                                                                  )
                                                                }
                                                              )
                                                            ]
                                                          )
                                                        ]
                                                      )
                                                  )
                                                }
                                            )
                                          ]
                                        )
                                        (C {(die)} 
                                          {
                                            (DQ 
                                              (word_part.CommandSub
                                                left_token: <Left_DollarParen '$('>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [
                                                      (C {(eval_gettext)} 
                                                        {
                                                          (DQ ('Unable to find current ') 
                                                            (word_part.EscapedLiteral
                                                              token: <Lit_EscapedChar '\\$'>
                                                            ) ('{remote_name}/') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) 
                                                            (
"{branch} revision in submodule path '"
                                                            ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ("sm_path'")
                                                          )
                                                        }
                                                      )
                                                    ]
                                                  )
                                              )
                                            )
                                          }
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.AndOr
                                      ops: [Op_DPipe]
                                      children: [
                                        (C {(test)} {(DQ ($ VSub_DollarName '$subsha1'))} 
                                          {(KW_Bang '!') (Lit_Other '=')} {(DQ ($ VSub_DollarName '$sha1'))}
                                        )
                                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$force'))})
                                      ]
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:subforce)
                                          op: Equal
                                          rhs: {($ VSub_DollarName '$force')}
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.AndOr
                                              ops: [Op_DAmp]
                                              children: [
                                                (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$subsha1'))})
                                                (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$force'))})
                                              ]
                                            )
                                          ]
                                          action: [
                                            (command.Assignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (lhs_expr.LhsName name:subforce)
                                                  op: Equal
                                                  rhs: {(DQ (-f))}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$nofetch'))})
                                          ]
                                          action: [
                                            (command.AndOr
                                              ops: [Op_DPipe Op_DPipe]
                                              children: [
                                                (C {(is_tip_reachable)} 
                                                  {(DQ ($ VSub_DollarName '$sm_path'))} {(DQ ($ VSub_DollarName '$sha1'))}
                                                )
                                                (C {(fetch_in_submodule)} 
                                                  {(DQ ($ VSub_DollarName '$sm_path'))} {($ VSub_DollarName '$depth')}
                                                )
                                                (C {(die)} 
                                                  {
                                                    (DQ 
                                                      (word_part.CommandSub
                                                        left_token: <Left_DollarParen '$('>
                                                        command_list: 
                                                          (command.CommandList
                                                            children: [
                                                              (C {(eval_gettext)} 
                                                                {
                                                                  (DQ 
                                                                    (
"Unable to fetch in submodule path '"
                                                                    ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ("displaypath'")
                                                                  )
                                                                }
                                                              )
                                                            ]
                                                          )
                                                      )
                                                    )
                                                  }
                                                )
                                              ]
                                            )
                                            (command.AndOr
                                              ops: [Op_DPipe Op_DPipe]
                                              children: [
                                                (C {(is_tip_reachable)} 
                                                  {(DQ ($ VSub_DollarName '$sm_path'))} {(DQ ($ VSub_DollarName '$sha1'))}
                                                )
                                                (C {(fetch_in_submodule)} 
                                                  {(DQ ($ VSub_DollarName '$sm_path'))} {($ VSub_DollarName '$depth')} {(DQ ($ VSub_DollarName '$sha1'))}
                                                )
                                                (C {(die)} 
                                                  {
                                                    (DQ 
                                                      (word_part.CommandSub
                                                        left_token: <Left_DollarParen '$('>
                                                        command_list: 
                                                          (command.CommandList
                                                            children: [
                                                              (C {(eval_gettext)} 
                                                                {
                                                                  (DQ ("Fetched in submodule path '") 
                                                                    (word_part.EscapedLiteral
                                                                      token: <Lit_EscapedChar '\\$'>
                                                                    ) ("displaypath', but it did not contain ") (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) 
                                                                    (
'sha1. Direct fetching of that commit failed.'
                                                                    )
                                                                  )
                                                                }
                                                              )
                                                            ]
                                                          )
                                                      )
                                                    )
                                                  }
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.Assignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:must_die_on_failure)
                                          op: Equal
                                          rhs: (word.Empty)
                                        )
                                      ]
                                    )
                                    (command.Case
                                      to_match: {(DQ ($ VSub_DollarName '$update_module'))}
                                      arms: [
                                        (case_arm
                                          pat_list: [{(checkout)}]
                                          action: [
                                            (command.Assignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (lhs_expr.LhsName name:command)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ('git checkout ') 
                                                        ($ VSub_DollarName '$subforce') (' -q')
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                            (command.Assignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (lhs_expr.LhsName name:die_msg)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (word_part.CommandSub
                                                          left_token: <Left_DollarParen '$('>
                                                          command_list: 
                                                            (command.CommandList
                                                              children: [
                                                                (C {(eval_gettext)} 
                                                                  {
                                                                    (DQ ("Unable to checkout '") 
                                                                      (word_part.EscapedLiteral
                                                                        token: 
                                                                          <Lit_EscapedChar '\\$'>
                                                                      ) ("sha1' in submodule path '") (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ("displaypath'")
                                                                    )
                                                                  }
                                                                )
                                                              ]
                                                            )
                                                        )
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                            (command.Assignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (lhs_expr.LhsName name:say_msg)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (word_part.CommandSub
                                                          left_token: <Left_DollarParen '$('>
                                                          command_list: 
                                                            (command.CommandList
                                                              children: [
                                                                (C {(eval_gettext)} 
                                                                  {
                                                                    (DQ ("Submodule path '") 
                                                                      (word_part.EscapedLiteral
                                                                        token: 
                                                                          <Lit_EscapedChar '\\$'>
                                                                      ) ("displaypath': checked out '") (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ("sha1'")
                                                                    )
                                                                  }
                                                                )
                                                              ]
                                                            )
                                                        )
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(rebase)}]
                                          action: [
                                            (command.Assignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (lhs_expr.LhsName name:command)
                                                  op: Equal
                                                  rhs: {(DQ ('git rebase'))}
                                                )
                                              ]
                                            )
                                            (command.Assignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (lhs_expr.LhsName name:die_msg)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (word_part.CommandSub
                                                          left_token: <Left_DollarParen '$('>
                                                          command_list: 
                                                            (command.CommandList
                                                              children: [
                                                                (C {(eval_gettext)} 
                                                                  {
                                                                    (DQ ("Unable to rebase '") 
                                                                      (word_part.EscapedLiteral
                                                                        token: 
                                                                          <Lit_EscapedChar '\\$'>
                                                                      ) ("sha1' in submodule path '") (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ("displaypath'")
                                                                    )
                                                                  }
                                                                )
                                                              ]
                                                            )
                                                        )
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                            (command.Assignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (lhs_expr.LhsName name:say_msg)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (word_part.CommandSub
                                                          left_token: <Left_DollarParen '$('>
                                                          command_list: 
                                                            (command.CommandList
                                                              children: [
                                                                (C {(eval_gettext)} 
                                                                  {
                                                                    (DQ ("Submodule path '") 
                                                                      (word_part.EscapedLiteral
                                                                        token: 
                                                                          <Lit_EscapedChar '\\$'>
                                                                      ) ("displaypath': rebased into '") (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ("sha1'")
                                                                    )
                                                                  }
                                                                )
                                                              ]
                                                            )
                                                        )
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                            (command.Assignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (lhs_expr.LhsName name:must_die_on_failure)
                                                  op: Equal
                                                  rhs: {(yes)}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(merge)}]
                                          action: [
                                            (command.Assignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (lhs_expr.LhsName name:command)
                                                  op: Equal
                                                  rhs: {(DQ ('git merge'))}
                                                )
                                              ]
                                            )
                                            (command.Assignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (lhs_expr.LhsName name:die_msg)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (word_part.CommandSub
                                                          left_token: <Left_DollarParen '$('>
                                                          command_list: 
                                                            (command.CommandList
                                                              children: [
                                                                (C {(eval_gettext)} 
                                                                  {
                                                                    (DQ ("Unable to merge '") 
                                                                      (word_part.EscapedLiteral
                                                                        token: 
                                                                          <Lit_EscapedChar '\\$'>
                                                                      ) ("sha1' in submodule path '") (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ("displaypath'")
                                                                    )
                                                                  }
                                                                )
                                                              ]
                                                            )
                                                        )
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                            (command.Assignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (lhs_expr.LhsName name:say_msg)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (word_part.CommandSub
                                                          left_token: <Left_DollarParen '$('>
                                                          command_list: 
                                                            (command.CommandList
                                                              children: [
                                                                (C {(eval_gettext)} 
                                                                  {
                                                                    (DQ ("Submodule path '") 
                                                                      (word_part.EscapedLiteral
                                                                        token: 
                                                                          <Lit_EscapedChar '\\$'>
                                                                      ) ("displaypath': merged in '") (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ("sha1'")
                                                                    )
                                                                  }
                                                                )
                                                              ]
                                                            )
                                                        )
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                            (command.Assignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (lhs_expr.LhsName name:must_die_on_failure)
                                                  op: Equal
                                                  rhs: {(yes)}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(KW_Bang '!') (Lit_Star '*')}]
                                          action: [
                                            (command.Assignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (lhs_expr.LhsName name:command)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (word_part.BracedVarSub
                                                          token: <VSub_Name update_module>
                                                          suffix_op: 
                                                            (suffix_op.Unary
                                                              op_id: VOp1_Pound
                                                              arg_word: {('!')}
                                                            )
                                                        )
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                            (command.Assignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (lhs_expr.LhsName name:die_msg)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (word_part.CommandSub
                                                          left_token: <Left_DollarParen '$('>
                                                          command_list: 
                                                            (command.CommandList
                                                              children: [
                                                                (C {(eval_gettext)} 
                                                                  {
                                                                    (DQ ("Execution of '") 
                                                                      (word_part.EscapedLiteral
                                                                        token: 
                                                                          <Lit_EscapedChar '\\$'>
                                                                      ) ('command ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) 
                                                                      (
"sha1' failed in submodule path '"
                                                                      ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ("displaypath'")
                                                                    )
                                                                  }
                                                                )
                                                              ]
                                                            )
                                                        )
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                            (command.Assignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (lhs_expr.LhsName name:say_msg)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (word_part.CommandSub
                                                          left_token: <Left_DollarParen '$('>
                                                          command_list: 
                                                            (command.CommandList
                                                              children: [
                                                                (C {(eval_gettext)} 
                                                                  {
                                                                    (DQ ("Submodule path '") 
                                                                      (word_part.EscapedLiteral
                                                                        token: 
                                                                          <Lit_EscapedChar '\\$'>
                                                                      ) ("displaypath': '") (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ('command ') 
                                                                      (word_part.EscapedLiteral
                                                                        token: 
                                                                          <Lit_EscapedChar '\\$'>
                                                                      ) ("sha1'")
                                                                    )
                                                                  }
                                                                )
                                                              ]
                                                            )
                                                        )
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                            (command.Assignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (lhs_expr.LhsName name:must_die_on_failure)
                                                  op: Equal
                                                  rhs: {(yes)}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Star '*')}]
                                          action: [
                                            (C {(die)} 
                                              {
                                                (DQ 
                                                  (word_part.CommandSub
                                                    left_token: <Left_DollarParen '$('>
                                                    command_list: 
                                                      (command.CommandList
                                                        children: [
                                                          (C {(eval_gettext)} 
                                                            {
                                                              (DQ ("Invalid update mode '") 
                                                                ($ VSub_DollarName '$update_module') ("' for submodule '") ($ VSub_DollarName '$name') ("'")
                                                              )
                                                            }
                                                          )
                                                        ]
                                                      )
                                                  )
                                                )
                                              }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (command.Subshell
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (command.Sentence
                                                      child: (C {(sanitize_submodule_env)})
                                                      terminator: <Op_Semi ';'>
                                                    )
                                                    (command.AndOr
                                                      ops: [Op_DAmp]
                                                      children: [
                                                        (C {(cd)} {(DQ ($ VSub_DollarName '$sm_path'))})
                                                        (C {($ VSub_DollarName '$command')} 
                                                          {(DQ ($ VSub_DollarName '$sha1'))}
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                            )
                                          ]
                                          action: [(C {(say)} {(DQ ($ VSub_DollarName '$say_msg'))})]
                                        )
                                        (if_arm
                                          cond: [
                                            (C {(test)} {(-n)} 
                                              {(DQ ($ VSub_DollarName '$must_die_on_failure'))}
                                            )
                                          ]
                                          action: [
                                            (C {(die_with_status)} {(2)} 
                                              {(DQ ($ VSub_DollarName '$die_msg'))}
                                            )
                                          ]
                                        )
                                      ]
                                      else_action: [
                                        (command.Assignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (lhs_expr.LhsName name:err)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ (${ VSub_Name err) (';') 
                                                    ($ VSub_DollarName '$die_msg')
                                                  )
                                                }
                                            )
                                          ]
                                        )
                                        (command.ControlFlow
                                          token: <ControlFlow_Continue continue>
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [(C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$recursive'))})]
                                  action: [
                                    (command.Subshell
                                      command_list: 
                                        (command.CommandList
                                          children: [
                                            (command.Assignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (lhs_expr.LhsName name:prefix)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (word_part.CommandSub
                                                        left_token: <Left_DollarParen '$('>
                                                        command_list: 
                                                          (command.CommandList
                                                            children: [
                                                              (C {(git)} {(submodule--helper)} 
                                                                {(relative-path)} {(DQ ($ VSub_DollarName '$prefix') ($ VSub_DollarName '$sm_path') (/))} 
                                                                {
                                                                  (DQ 
                                                                    ($ VSub_DollarName '$wt_prefix')
                                                                  )
                                                                }
                                                              )
                                                            ]
                                                          )
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                            (command.Assignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (lhs_expr.LhsName name:wt_prefix)
                                                  op: Equal
                                                  rhs: (word.Empty)
                                                )
                                              ]
                                            )
                                            (C {(sanitize_submodule_env)})
                                            (command.AndOr
                                              ops: [Op_DAmp]
                                              children: [
                                                (C {(cd)} {(DQ ($ VSub_DollarName '$sm_path'))})
                                                (C {(eval)} {(cmd_update)})
                                              ]
                                            )
                                          ]
                                        )
                                    )
                                    (command.Assignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:res)
                                          op: Equal
                                          rhs: {($ VSub_QMark '$?')}
                                        )
                                      ]
                                    )
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (C {(test)} {($ VSub_DollarName '$res')} {(-gt)} {(0)})
                                          ]
                                          action: [
                                            (command.Assignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (lhs_expr.LhsName name:die_msg)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (word_part.CommandSub
                                                          left_token: <Left_DollarParen '$('>
                                                          command_list: 
                                                            (command.CommandList
                                                              children: [
                                                                (C {(eval_gettext)} 
                                                                  {
                                                                    (DQ 
                                                                      (
"Failed to recurse into submodule path '"
                                                                      ) (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) ("displaypath'")
                                                                    )
                                                                  }
                                                                )
                                                              ]
                                                            )
                                                        )
                                                      )
                                                    }
                                                )
                                              ]
                                            )
                                            (command.If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (C {(test)} {($ VSub_DollarName '$res')} {(-ne)} 
                                                      {(2)}
                                                    )
                                                  ]
                                                  action: [
                                                    (command.Assignment
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (lhs_expr.LhsName name:err)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ (${ VSub_Name err) (';') 
                                                                ($ VSub_DollarName '$die_msg')
                                                              )
                                                            }
                                                        )
                                                      ]
                                                    )
                                                    (command.ControlFlow
                                                      token: <ControlFlow_Continue continue>
                                                    )
                                                  ]
                                                )
                                              ]
                                              else_action: [
                                                (C {(die_with_status)} {($ VSub_DollarName '$res')} 
                                                  {(DQ ($ VSub_DollarName '$die_msg'))}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                    )
                    (command.If
                      arms: [
                        (if_arm
                          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$err'))})]
                          action: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:OIFS)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$IFS')}
                                )
                              ]
                            )
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:IFS)
                                  op: Equal
                                  rhs: {(SQ <';'>)}
                                )
                              ]
                            )
                            (command.ForEach
                              iter_name: e
                              iter_words: [{($ VSub_DollarName '$err')}]
                              do_arg_iter: F
                              body: 
                                (command.DoGroup
                                  children: [
                                    (command.If
                                      arms: [
                                        (if_arm
                                          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$e'))})]
                                          action: [
                                            (command.Simple
                                              words: [{(echo)} {(DQ ($ VSub_DollarName '$e'))}]
                                              redirects: [
                                                (redir.Redir
                                                  op: <Redir_GreatAnd '>&'>
                                                  fd: 16777215
                                                  arg_word: {(2)}
                                                )
                                              ]
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                            )
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:IFS)
                                  op: Equal
                                  rhs: {($ VSub_DollarName '$OIFS')}
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Exit exit>
                              arg_word: {(1)}
                            )
                          ]
                        )
                      ]
                    )
                  ]
                )
              ]
              negated: F
            )
          ]
        )
    )
    (command.FuncDef
      name: set_name_rev
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:revname)
                  op: Equal
                  rhs: 
                    {
                      (word_part.CommandSub
                        left_token: <Left_DollarParen '$('>
                        command_list: 
                          (command.CommandList
                            children: [
                              (command.Subshell
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(sanitize_submodule_env)})
                                      (command.AndOr
                                        ops: [Op_DAmp]
                                        children: [
                                          (C {(cd)} {(DQ ($ VSub_Number '$1'))})
                                          (command.BraceGroup
                                            children: [
                                              (command.AndOr
                                                ops: [Op_DPipe Op_DPipe Op_DPipe]
                                                children: [
                                                  (command.Simple
                                                    words: [
                                                      {(git)}
                                                      {(describe)}
                                                      {(DQ ($ VSub_Number '$2'))}
                                                    ]
                                                    redirects: [
                                                      (redir.Redir
                                                        op: <Redir_Great '2>'>
                                                        fd: 2
                                                        arg_word: {(/dev/null)}
                                                      )
                                                    ]
                                                  )
                                                  (command.Simple
                                                    words: [
                                                      {(git)}
                                                      {(describe)}
                                                      {(--tags)}
                                                      {(DQ ($ VSub_Number '$2'))}
                                                    ]
                                                    redirects: [
                                                      (redir.Redir
                                                        op: <Redir_Great '2>'>
                                                        fd: 2
                                                        arg_word: {(/dev/null)}
                                                      )
                                                    ]
                                                  )
                                                  (command.Simple
                                                    words: [
                                                      {(git)}
                                                      {(describe)}
                                                      {(--contains)}
                                                      {(DQ ($ VSub_Number '$2'))}
                                                    ]
                                                    redirects: [
                                                      (redir.Redir
                                                        op: <Redir_Great '2>'>
                                                        fd: 2
                                                        arg_word: {(/dev/null)}
                                                      )
                                                    ]
                                                  )
                                                  (C {(git)} {(describe)} {(--all)} {(--always)} 
                                                    {(DQ ($ VSub_Number '$2'))}
                                                  )
                                                ]
                                              )
                                            ]
                                          )
                                        ]
                                      )
                                    ]
                                  )
                              )
                            ]
                          )
                      )
                    }
                )
              ]
            )
            (command.AndOr
              ops: [Op_DPipe]
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$revname'))})
                (command.Assignment
                  pairs: [
                    (assign_pair
                      lhs: (lhs_expr.LhsName name:revname)
                      op: Equal
                      rhs: {(DQ (' (') ($ VSub_DollarName '$revname') (')'))}
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.FuncDef
      name: cmd_summary
      body: 
        (command.BraceGroup
          children: [
            (command.Assignment
              pairs: [(assign_pair lhs:(lhs_expr.LhsName name:summary_limit) op:Equal rhs:{(-1)})]
            )
            (command.Assignment
              pairs: [(assign_pair lhs:(lhs_expr.LhsName name:for_status) op:Equal rhs:(word.Empty))]
            )
            (command.Assignment
              pairs: [(assign_pair lhs:(lhs_expr.LhsName name:diff_cmd) op:Equal rhs:{(diff-index)})]
            )
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [(C {(test)} {($ VSub_Pound '$#')} {(-ne)} {(0)})]
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ VSub_Number '$1'))}
                      arms: [
                        (case_arm
                          pat_list: [{(--cached)}]
                          action: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:cached)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Number '$1'))}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--files)}]
                          action: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:files)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Number '$1'))}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--for-status)}]
                          action: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:for_status)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Number '$1'))}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(-n)} {(--summary-limit)}]
                          action: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:summary_limit)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Number '$2'))}
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {(isnumber)} {(DQ ($ VSub_DollarName '$summary_limit'))})
                                (C {(usage)})
                              ]
                            )
                            (C {(shift)})
                          ]
                        )
                        (case_arm
                          pat_list: [{(--summary-limit) (Lit_Other '=') (Lit_Star '*')}]
                          action: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:summary_limit)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (word_part.BracedVarSub
                                          token: <VSub_Number 1>
                                          suffix_op: 
                                            (suffix_op.Unary
                                              op_id: VOp1_Pound
                                              arg_word: {('--summary-limit=')}
                                            )
                                        )
                                      )
                                    }
                                )
                              ]
                            )
                            (command.AndOr
                              ops: [Op_DPipe]
                              children: [
                                (C {(isnumber)} {(DQ ($ VSub_DollarName '$summary_limit'))})
                                (C {(usage)})
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--)}]
                          action: [(C {(shift)}) (command.ControlFlow token:<ControlFlow_Break break>)]
                        )
                        (case_arm
                          pat_list: [{(-) (Lit_Star '*')}]
                          action: [(C {(usage)})]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*')}]
                          action: [(command.ControlFlow token:<ControlFlow_Break break>)]
                        )
                      ]
                    )
                    (C {(shift)})
                  ]
                )
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {($ VSub_DollarName '$summary_limit')} {(Lit_Other '=')} {(0)})
                (command.ControlFlow token:<ControlFlow_Return return>)
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Assignment
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:rev)
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSub
                                left_token: <Left_DollarParen '$('>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(git)} {(rev-parse)} {(-q)} {(--verify)} {(--default)} {(HEAD)} 
                                        {
                                          (word_part.BracedVarSub
                                            token: <VSub_Number 1>
                                            suffix_op: 
                                              (suffix_op.Unary
                                                op_id: VTest_Plus
                                                arg_word: {(DQ ($ VSub_Number '$1'))}
                                              )
                                          )
                                        }
                                      )
                                    ]
                                  )
                              )
                            }
                        )
                      ]
                    )
                  ]
                  action: [
                    (command.Assignment
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:head)
                          op: Equal
                          rhs: {($ VSub_DollarName '$rev')}
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(test)} {($ VSub_Pound '$#')} {(Lit_Other '=')} {(0)})
                        (C {(shift)})
                      ]
                    )
                  ]
                )
                (if_arm
                  cond: [
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_Number '$1'))})
                        (C {(test)} {(DQ ($ VSub_Number '$1'))} {(Lit_Other '=')} {(DQ (HEAD))})
                      ]
                    )
                  ]
                  action: [
                    (command.Assignment
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:head)
                          op: Equal
                          rhs: 
                            {
                              (word_part.CommandSub
                                left_token: <Left_DollarParen '$('>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (command.Simple
                                        words: [{(git)} {(hash-object)} {(-w)} {(-t)} {(tree)} {(--stdin)}]
                                        redirects: [
                                          (redir.Redir
                                            op: <Redir_Less '<'>
                                            fd: 16777215
                                            arg_word: {(/dev/null)}
                                          )
                                        ]
                                      )
                                    ]
                                  )
                              )
                            }
                        )
                      ]
                    )
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [(C {(test)} {(-z)} {(DQ ($ VSub_Number '$1'))}) (C {(shift)})]
                    )
                  ]
                )
              ]
              else_action: [
                (command.Assignment
                  pairs: [(assign_pair lhs:(lhs_expr.LhsName name:head) op:Equal rhs:{(DQ (HEAD))})]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (C {(Lit_LBracket '[')} {(-n)} {(DQ ($ VSub_DollarName '$files'))} 
                      {(Lit_RBracket ']')}
                    )
                  ]
                  action: [
                    (command.AndOr
                      ops: [Op_DAmp]
                      children: [
                        (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$cached'))})
                        (C {(die)} 
                          {
                            (DQ 
                              (word_part.CommandSub
                                left_token: <Left_DollarParen '$('>
                                command_list: 
                                  (command.CommandList
                                    children: [
                                      (C {(gettext)} 
                                        {
                                          (DQ 
                                            (
'The --cached option cannot be used with the --files option'
                                            )
                                          )
                                        }
                                      )
                                    ]
                                  )
                              )
                            )
                          }
                        )
                      ]
                    )
                    (command.Assignment
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:diff_cmd)
                          op: Equal
                          rhs: {(diff-files)}
                        )
                      ]
                    )
                    (command.Assignment
                      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:head) op:Equal rhs:(word.Empty))]
                    )
                  ]
                )
              ]
            )
            (C {(cd_to_toplevel)})
            (C {(eval)} 
              {
                (DQ ('set ') 
                  (word_part.CommandSub
                    left_token: <Left_DollarParen '$('>
                    command_list: 
                      (command.CommandList
                        children: [
                          (C {(git)} {(rev-parse)} {(--sq)} {(--prefix)} 
                            {(DQ ($ VSub_DollarName '$wt_prefix'))} {(--)} {(DQ ($ VSub_At '$@'))}
                          )
                        ]
                      )
                  )
                )
              }
            )
            (command.Assignment
              pairs: [
                (assign_pair
                  lhs: (lhs_expr.LhsName name:modules)
                  op: Equal
                  rhs: 
                    {
                      (word_part.CommandSub
                        left_token: <Left_DollarParen '$('>
                        command_list: 
                          (command.CommandList
                            children: [
                              (command.Pipeline
                                children: [
                                  (C {(git)} {($ VSub_DollarName '$diff_cmd')} 
                                    {($ VSub_DollarName '$cached')} {(--ignore-submodules) (Lit_Other '=') (dirty)} {(--raw)} {($ VSub_DollarName '$head')} {(--)} 
                                    {(DQ ($ VSub_At '$@'))}
                                  )
                                  (C {(sane_egrep)} {(SQ <'^:([0-7]* )?160000'>)})
                                  (command.WhileUntil
                                    keyword: <KW_While while>
                                    cond: [
                                      (C {(read)} {(mod_src)} {(mod_dst)} {(sha1_src)} {(sha1_dst)} 
                                        {(status)} {(sm_path)}
                                      )
                                    ]
                                    body: 
                                      (command.DoGroup
                                        children: [
                                          (command.If
                                            arms: [
                                              (if_arm
                                                cond: [
                                                  (command.AndOr
                                                    ops: [Op_DPipe]
                                                    children: [
                                                      (C {(test)} {(DQ ($ VSub_DollarName '$status'))} 
                                                        {(Lit_Other '=')} {(D)}
                                                      )
                                                      (C {(test)} {(DQ ($ VSub_DollarName '$status'))} 
                                                        {(Lit_Other '=')} {(T)}
                                                      )
                                                    ]
                                                  )
                                                ]
                                                action: [
                                                  (C {(printf)} {(SQ <'%s\\n'>)} 
                                                    {(DQ ($ VSub_DollarName '$sm_path'))}
                                                  )
                                                  (command.ControlFlow
                                                    token: <ControlFlow_Continue continue>
                                                  )
                                                ]
                                              )
                                            ]
                                          )
                                          (command.If
                                            arms: [
                                              (if_arm
                                                cond: [
                                                  (C {(test)} {(-n)} 
                                                    {(DQ ($ VSub_DollarName '$for_status'))}
                                                  )
                                                ]
                                                action: [
                                                  (command.Assignment
                                                    pairs: [
                                                      (assign_pair
                                                        lhs: (lhs_expr.LhsName name:name)
                                                        op: Equal
                                                        rhs: 
                                                          {
                                                            (word_part.CommandSub
                                                              left_token: <Left_DollarParen '$('>
                                                              command_list: 
                                                                (command.CommandList
                                                                  children: [
                                                                    (C {(git)} {(submodule--helper)} 
                                                                      {(name)} {(DQ ($ VSub_DollarName '$sm_path'))}
                                                                    )
                                                                  ]
                                                                )
                                                            )
                                                          }
                                                      )
                                                    ]
                                                  )
                                                  (command.Assignment
                                                    pairs: [
                                                      (assign_pair
                                                        lhs: (lhs_expr.LhsName name:ignore_config)
                                                        op: Equal
                                                        rhs: 
                                                          {
                                                            (word_part.CommandSub
                                                              left_token: <Left_DollarParen '$('>
                                                              command_list: 
                                                                (command.CommandList
                                                                  children: [
                                                                    (C {(get_submodule_config)} 
                                                                      {
                                                                        (DQ 
                                                                          ($ VSub_DollarName '$name')
                                                                        )
                                                                      } {(ignore)} {(none)}
                                                                    )
                                                                  ]
                                                                )
                                                            )
                                                          }
                                                      )
                                                    ]
                                                  )
                                                  (command.AndOr
                                                    ops: [Op_DAmp Op_DAmp]
                                                    children: [
                                                      (C {(test)} {($ VSub_DollarName '$status')} 
                                                        {(KW_Bang '!') (Lit_Other '=')} {(A)}
                                                      )
                                                      (C {(test)} 
                                                        {($ VSub_DollarName '$ignore_config')} {(Lit_Other '=')} {(all)}
                                                      )
                                                      (command.ControlFlow
                                                        token: <ControlFlow_Continue continue>
                                                      )
                                                    ]
                                                  )
                                                ]
                                              )
                                            ]
                                          )
                                          (command.AndOr
                                            ops: [Op_DAmp]
                                            children: [
                                              (command.Simple
                                                words: [{(git-rev-parse)} {(--git-dir)}]
                                                redirects: [
                                                  (redir.Redir
                                                    op: <Redir_Great '>'>
                                                    fd: 16777215
                                                    arg_word: {(/dev/null)}
                                                  )
                                                  (redir.Redir
                                                    op: <Redir_GreatAnd '2>&'>
                                                    fd: 2
                                                    arg_word: {(1)}
                                                  )
                                                ]
                                                more_env: [
                                                  (env_pair
                                                    name: GIT_DIR
                                                    val: {(DQ ($ VSub_DollarName '$sm_path') (/.git))}
                                                  )
                                                ]
                                              )
                                              (C {(printf)} {(SQ <'%s\\n'>)} 
                                                {(DQ ($ VSub_DollarName '$sm_path'))}
                                              )
                                            ]
                                          )
                                        ]
                                      )
                                  )
                                ]
                                negated: F
                              )
                            ]
                          )
                      )
                    }
                )
              ]
            )
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$modules'))})
                (command.ControlFlow token:<ControlFlow_Return return>)
              ]
            )
            (command.Pipeline
              children: [
                (C {(git)} {($ VSub_DollarName '$diff_cmd')} {($ VSub_DollarName '$cached')} 
                  {(--ignore-submodules) (Lit_Other '=') (dirty)} {(--raw)} {($ VSub_DollarName '$head')} {(--)} {($ VSub_DollarName '$modules')}
                )
                (C {(sane_egrep)} {(SQ <'^:([0-7]* )?160000'>)})
                (C {(cut)} {(-c2-)})
                (command.WhileUntil
                  keyword: <KW_While while>
                  cond: [
                    (C {(read)} {(mod_src)} {(mod_dst)} {(sha1_src)} {(sha1_dst)} {(status)} {(name)})
                  ]
                  body: 
                    (command.DoGroup
                      children: [
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.AndOr
                                  ops: [Op_DAmp]
                                  children: [
                                    (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$cached'))})
                                    (C {(test)} {($ VSub_DollarName '$sha1_dst')} {(Lit_Other '=')} 
                                      {(0000000000000000000000000000000000000000)}
                                    )
                                  ]
                                )
                              ]
                              action: [
                                (command.Case
                                  to_match: {(DQ ($ VSub_DollarName '$mod_dst'))}
                                  arms: [
                                    (case_arm
                                      pat_list: [{(160000)}]
                                      action: [
                                        (command.Assignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (lhs_expr.LhsName name:sha1_dst)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (word_part.CommandSub
                                                    left_token: <Left_DollarParen '$('>
                                                    command_list: 
                                                      (command.CommandList
                                                        children: [
                                                          (command.Simple
                                                            words: [{(git)} {(rev-parse)} {(HEAD)}]
                                                            more_env: [
                                                              (env_pair
                                                                name: GIT_DIR
                                                                val: 
                                                                  {
                                                                    (DQ ($ VSub_DollarName '$name') 
                                                                      (/.git)
                                                                    )
                                                                  }
                                                              )
                                                            ]
                                                          )
                                                        ]
                                                      )
                                                  )
                                                }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (case_arm
                                      pat_list: [{(100644)} {(100755)} {(120000)}]
                                      action: [
                                        (command.Assignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (lhs_expr.LhsName name:sha1_dst)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (word_part.CommandSub
                                                    left_token: <Left_DollarParen '$('>
                                                    command_list: 
                                                      (command.CommandList
                                                        children: [
                                                          (C {(git)} {(hash-object)} 
                                                            {($ VSub_DollarName '$name')}
                                                          )
                                                        ]
                                                      )
                                                  )
                                                }
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (case_arm
                                      pat_list: [{(000000)}]
                                    )
                                    (case_arm
                                      pat_list: [{(Lit_Star '*')}]
                                      action: [
                                        (command.Simple
                                          words: [
                                            {(eval_gettextln)}
                                            {
                                              (DQ ('unexpected mode ') 
                                                (word_part.EscapedLiteral
                                                  token: <Lit_EscapedChar '\\$'>
                                                ) (mod_dst)
                                              )
                                            }
                                          ]
                                          redirects: [
                                            (redir.Redir
                                              op: <Redir_GreatAnd '>&'>
                                              fd: 16777215
                                              arg_word: {(2)}
                                            )
                                          ]
                                        )
                                        (command.ControlFlow
                                          token: <ControlFlow_Continue continue>
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                        (command.Assignment
                          pairs: [(assign_pair lhs:(lhs_expr.LhsName name:missing_src) op:Equal rhs:(word.Empty))]
                        )
                        (command.Assignment
                          pairs: [(assign_pair lhs:(lhs_expr.LhsName name:missing_dst) op:Equal rhs:(word.Empty))]
                        )
                        (command.AndOr
                          ops: [Op_DAmp Op_DAmp]
                          children: [
                            (C {(test)} {($ VSub_DollarName '$mod_src')} {(Lit_Other '=')} {(160000)})
                            (command.Pipeline
                              children: [
                                (command.Simple
                                  words: [
                                    {(git-rev-parse)}
                                    {(-q)}
                                    {(--verify)}
                                    {($ VSub_DollarName '$sha1_src') (Lit_Other '^') (0)}
                                  ]
                                  redirects: [
                                    (redir.Redir
                                      op: <Redir_Great '>'>
                                      fd: 16777215
                                      arg_word: {(/dev/null)}
                                    )
                                  ]
                                  more_env: [
                                    (env_pair
                                      name: GIT_DIR
                                      val: {(DQ ($ VSub_DollarName '$name') (/.git))}
                                    )
                                  ]
                                )
                              ]
                              negated: T
                            )
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:missing_src)
                                  op: Equal
                                  rhs: {(t)}
                                )
                              ]
                            )
                          ]
                        )
                        (command.AndOr
                          ops: [Op_DAmp Op_DAmp]
                          children: [
                            (C {(test)} {($ VSub_DollarName '$mod_dst')} {(Lit_Other '=')} {(160000)})
                            (command.Pipeline
                              children: [
                                (command.Simple
                                  words: [
                                    {(git-rev-parse)}
                                    {(-q)}
                                    {(--verify)}
                                    {($ VSub_DollarName '$sha1_dst') (Lit_Other '^') (0)}
                                  ]
                                  redirects: [
                                    (redir.Redir
                                      op: <Redir_Great '>'>
                                      fd: 16777215
                                      arg_word: {(/dev/null)}
                                    )
                                  ]
                                  more_env: [
                                    (env_pair
                                      name: GIT_DIR
                                      val: {(DQ ($ VSub_DollarName '$name') (/.git))}
                                    )
                                  ]
                                )
                              ]
                              negated: T
                            )
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:missing_dst)
                                  op: Equal
                                  rhs: {(t)}
                                )
                              ]
                            )
                          ]
                        )
                        (command.Assignment
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:display_name)
                              op: Equal
                              rhs: 
                                {
                                  (word_part.CommandSub
                                    left_token: <Left_DollarParen '$('>
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(git)} {(submodule--helper)} {(relative-path)} 
                                            {(DQ ($ VSub_DollarName '$name'))} {(DQ ($ VSub_DollarName '$wt_prefix'))}
                                          )
                                        ]
                                      )
                                  )
                                }
                            )
                          ]
                        )
                        (command.Assignment
                          pairs: [(assign_pair lhs:(lhs_expr.LhsName name:total_commits) op:Equal rhs:(word.Empty))]
                        )
                        (command.Case
                          to_match: 
                            {
                              (DQ ($ VSub_DollarName '$missing_src') (',') 
                                ($ VSub_DollarName '$missing_dst')
                              )
                            }
                          arms: [
                            (case_arm
                              pat_list: [{(t) (Lit_Comma ',')}]
                              action: [
                                (command.Assignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:errmsg)
                                      op: Equal
                                      rhs: 
                                        {
                                          (DQ 
                                            (word_part.CommandSub
                                              left_token: <Left_DollarParen '$('>
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (C {(eval_gettext)} 
                                                      {
                                                        (DQ ('  Warn: ') 
                                                          (word_part.EscapedLiteral
                                                            token: <Lit_EscapedChar '\\$'>
                                                          ) ("display_name doesn't contain commit ") (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) 
                                                          (sha1_src)
                                                        )
                                                      }
                                                    )
                                                  ]
                                                )
                                            )
                                          )
                                        }
                                    )
                                  ]
                                )
                              ]
                            )
                            (case_arm
                              pat_list: [{(Lit_Comma ',') (t)}]
                              action: [
                                (command.Assignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:errmsg)
                                      op: Equal
                                      rhs: 
                                        {
                                          (DQ 
                                            (word_part.CommandSub
                                              left_token: <Left_DollarParen '$('>
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (C {(eval_gettext)} 
                                                      {
                                                        (DQ ('  Warn: ') 
                                                          (word_part.EscapedLiteral
                                                            token: <Lit_EscapedChar '\\$'>
                                                          ) ("display_name doesn't contain commit ") (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) 
                                                          (sha1_dst)
                                                        )
                                                      }
                                                    )
                                                  ]
                                                )
                                            )
                                          )
                                        }
                                    )
                                  ]
                                )
                              ]
                            )
                            (case_arm
                              pat_list: [{(t) (Lit_Comma ',') (t)}]
                              action: [
                                (command.Assignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:errmsg)
                                      op: Equal
                                      rhs: 
                                        {
                                          (DQ 
                                            (word_part.CommandSub
                                              left_token: <Left_DollarParen '$('>
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (C {(eval_gettext)} 
                                                      {
                                                        (DQ ('  Warn: ') 
                                                          (word_part.EscapedLiteral
                                                            token: <Lit_EscapedChar '\\$'>
                                                          ) ("display_name doesn't contain commits ") (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) 
                                                          ('sha1_src and ') (word_part.EscapedLiteral token:<Lit_EscapedChar '\\$'>) (sha1_dst)
                                                        )
                                                      }
                                                    )
                                                  ]
                                                )
                                            )
                                          )
                                        }
                                    )
                                  ]
                                )
                              ]
                            )
                            (case_arm
                              pat_list: [{(Lit_Star '*')}]
                              action: [
                                (command.Assignment
                                  pairs: [(assign_pair lhs:(lhs_expr.LhsName name:errmsg) op:Equal rhs:(word.Empty))]
                                )
                                (command.Assignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:total_commits)
                                      op: Equal
                                      rhs: 
                                        {
                                          (word_part.CommandSub
                                            left_token: <Left_DollarParen '$('>
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (command.If
                                                    arms: [
                                                      (if_arm
                                                        cond: [
                                                          (command.AndOr
                                                            ops: [Op_DAmp]
                                                            children: [
                                                              (C {(test)} 
                                                                {($ VSub_DollarName '$mod_src')} {(Lit_Other '=')} {(160000)}
                                                              )
                                                              (C {(test)} 
                                                                {($ VSub_DollarName '$mod_dst')} {(Lit_Other '=')} {(160000)}
                                                              )
                                                            ]
                                                          )
                                                        ]
                                                        action: [
                                                          (command.Assignment
                                                            pairs: [
                                                              (assign_pair
                                                                lhs: (lhs_expr.LhsName name:range)
                                                                op: Equal
                                                                rhs: 
                                                                  {
                                                                    (DQ 
                                                                      ($ VSub_DollarName '$sha1_src') (...) ($ VSub_DollarName '$sha1_dst')
                                                                    )
                                                                  }
                                                              )
                                                            ]
                                                          )
                                                        ]
                                                      )
                                                      (if_arm
                                                        cond: [
                                                          (C {(test)} {($ VSub_DollarName '$mod_src')} 
                                                            {(Lit_Other '=')} {(160000)}
                                                          )
                                                        ]
                                                        action: [
                                                          (command.Assignment
                                                            pairs: [
                                                              (assign_pair
                                                                lhs: (lhs_expr.LhsName name:range)
                                                                op: Equal
                                                                rhs: {($ VSub_DollarName '$sha1_src')}
                                                              )
                                                            ]
                                                          )
                                                        ]
                                                      )
                                                    ]
                                                    else_action: [
                                                      (command.Assignment
                                                        pairs: [
                                                          (assign_pair
                                                            lhs: (lhs_expr.LhsName name:range)
                                                            op: Equal
                                                            rhs: {($ VSub_DollarName '$sha1_dst')}
                                                          )
                                                        ]
                                                      )
                                                    ]
                                                  )
                                                  (command.Pipeline
                                                    children: [
                                                      (command.Simple
                                                        words: [
                                                          {(git)}
                                                          {(rev-list)}
                                                          {(--first-parent)}
                                                          {($ VSub_DollarName '$range')}
                                                          {(--)}
                                                        ]
                                                        more_env: [
                                                          (env_pair
                                                            name: GIT_DIR
                                                            val: 
                                                              {
                                                                (DQ ($ VSub_DollarName '$name') 
                                                                  (/.git)
                                                                )
                                                              }
                                                          )
                                                        ]
                                                      )
                                                      (C {(wc)} {(-l)})
                                                    ]
                                                    negated: F
                                                  )
                                                ]
                                              )
                                          )
                                        }
                                    )
                                  ]
                                )
                                (command.Assignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:total_commits)
                                      op: Equal
                                      rhs: 
                                        {
                                          (DQ (' (') 
                                            (word_part.ArithSub
                                              anode: 
                                                (arith_expr.Binary
                                                  op_id: Arith_Plus
                                                  left: 
                                                    (arith_expr.ArithWord
                                                      w: {($ VSub_DollarName '$total_commits')}
                                                    )
                                                  right: (arith_expr.ArithWord w:{(Lit_Digits 0)})
                                                )
                                            ) (')')
                                          )
                                        }
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                        (command.Assignment
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:sha1_abbr_src)
                              op: Equal
                              rhs: 
                                {
                                  (word_part.CommandSub
                                    left_token: <Left_DollarParen '$('>
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (command.Pipeline
                                            children: [
                                              (C {(echo)} {($ VSub_DollarName '$sha1_src')})
                                              (C {(cut)} {(-c1-7)})
                                            ]
                                            negated: F
                                          )
                                        ]
                                      )
                                  )
                                }
                            )
                          ]
                        )
                        (command.Assignment
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:sha1_abbr_dst)
                              op: Equal
                              rhs: 
                                {
                                  (word_part.CommandSub
                                    left_token: <Left_DollarParen '$('>
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (command.Pipeline
                                            children: [
                                              (C {(echo)} {($ VSub_DollarName '$sha1_dst')})
                                              (C {(cut)} {(-c1-7)})
                                            ]
                                            negated: F
                                          )
                                        ]
                                      )
                                  )
                                }
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (C {(test)} {($ VSub_DollarName '$status')} {(Lit_Other '=')} {(T)})
                              ]
                              action: [
                                (command.Assignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:blob)
                                      op: Equal
                                      rhs: 
                                        {
                                          (DQ 
                                            (word_part.CommandSub
                                              left_token: <Left_DollarParen '$('>
                                              command_list: 
                                                (command.CommandList
                                                  children: [(C {(gettext)} {(DQ (blob))})]
                                                )
                                            )
                                          )
                                        }
                                    )
                                  ]
                                )
                                (command.Assignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:submodule)
                                      op: Equal
                                      rhs: 
                                        {
                                          (DQ 
                                            (word_part.CommandSub
                                              left_token: <Left_DollarParen '$('>
                                              command_list: 
                                                (command.CommandList
                                                  children: [(C {(gettext)} {(DQ (submodule))})]
                                                )
                                            )
                                          )
                                        }
                                    )
                                  ]
                                )
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (C {(test)} {($ VSub_DollarName '$mod_dst')} {(Lit_Other '=')} 
                                          {(160000)}
                                        )
                                      ]
                                      action: [
                                        (C {(echo)} 
                                          {
                                            (DQ ('* ') ($ VSub_DollarName '$display_name') (' ') 
                                              ($ VSub_DollarName '$sha1_abbr_src') ('(') ($ VSub_DollarName '$blob') (')->') ($ VSub_DollarName '$sha1_abbr_dst') ('(') 
                                              ($ VSub_DollarName '$submodule') (')') ($ VSub_DollarName '$total_commits') (':')
                                            )
                                          }
                                        )
                                      ]
                                    )
                                  ]
                                  else_action: [
                                    (C {(echo)} 
                                      {
                                        (DQ ('* ') ($ VSub_DollarName '$display_name') (' ') 
                                          ($ VSub_DollarName '$sha1_abbr_src') ('(') ($ VSub_DollarName '$submodule') (')->') ($ VSub_DollarName '$sha1_abbr_dst') ('(') 
                                          ($ VSub_DollarName '$blob') (')') ($ VSub_DollarName '$total_commits') (':')
                                        )
                                      }
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                          else_action: [
                            (C {(echo)} 
                              {
                                (DQ ('* ') ($ VSub_DollarName '$display_name') (' ') 
                                  ($ VSub_DollarName '$sha1_abbr_src') (...) ($ VSub_DollarName '$sha1_abbr_dst') ($ VSub_DollarName '$total_commits') (':')
                                )
                              }
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: [(C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$errmsg'))})]
                              action: [
                                (command.AndOr
                                  ops: [Op_DAmp]
                                  children: [
                                    (C {(test)} {($ VSub_DollarName '$mod_dst')} {(Lit_Other '=')} 
                                      {(160000)}
                                    )
                                    (C {(echo)} {(DQ ($ VSub_DollarName '$errmsg'))})
                                  ]
                                )
                              ]
                            )
                          ]
                          else_action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.AndOr
                                      ops: [Op_DAmp]
                                      children: [
                                        (C {(test)} {($ VSub_DollarName '$mod_src')} {(Lit_Other '=')} 
                                          {(160000)}
                                        )
                                        (C {(test)} {($ VSub_DollarName '$mod_dst')} {(Lit_Other '=')} 
                                          {(160000)}
                                        )
                                      ]
                                    )
                                  ]
                                  action: [
                                    (command.Assignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:limit)
                                          op: Equal
                                          rhs: (word.Empty)
                                        )
                                      ]
                                    )
                                    (command.AndOr
                                      ops: [Op_DAmp]
                                      children: [
                                        (C {(test)} {($ VSub_DollarName '$summary_limit')} {(-gt)} {(0)})
                                        (command.Assignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (lhs_expr.LhsName name:limit)
                                              op: Equal
                                              rhs: {(DQ (-) ($ VSub_DollarName '$summary_limit'))}
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                    (command.Simple
                                      words: [
                                        {(git)}
                                        {(log)}
                                        {($ VSub_DollarName '$limit')}
                                        {(--pretty) (Lit_Other '=') (SQ <'format:  %m %s'>)}
                                        {(--first-parent)}
                                        {($ VSub_DollarName '$sha1_src') (...) 
                                          ($ VSub_DollarName '$sha1_dst')
                                        }
                                      ]
                                      more_env: [
                                        (env_pair
                                          name: GIT_DIR
                                          val: {(DQ ($ VSub_DollarName '$name') (/.git))}
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (if_arm
                                  cond: [
                                    (C {(test)} {($ VSub_DollarName '$mod_dst')} {(Lit_Other '=')} 
                                      {(160000)}
                                    )
                                  ]
                                  action: [
                                    (command.Simple
                                      words: [
                                        {(git)}
                                        {(log)}
                                        {(--pretty) (Lit_Other '=') (SQ <'format:  > %s'>)}
                                        {(-1)}
                                        {($ VSub_DollarName '$sha1_dst')}
                                      ]
                                      more_env: [
                                        (env_pair
                                          name: GIT_DIR
                                          val: {(DQ ($ VSub_DollarName '$name') (/.git))}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                              else_action: [
                                (command.Simple
                                  words: [
                                    {(git)}
                                    {(log)}
                                    {(--pretty) (Lit_Other '=') (SQ <'format:  < %s'>)}
                                    {(-1)}
                                    {($ VSub_DollarName '$sha1_src')}
                                  ]
                                  more_env: [
                                    (env_pair
                                      name: GIT_DIR
                                      val: {(DQ ($ VSub_DollarName '$name') (/.git))}
                                    )
                                  ]
                                )
                              ]
                            )
                            (C {(echo)})
                          ]
                        )
                        (C {(echo)})
                      ]
                    )
                )
              ]
              negated: F
            )
          ]
        )
    )
    (command.FuncDef
      name: cmd_status
      body: 
        (command.BraceGroup
          children: [
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [(C {(test)} {($ VSub_Pound '$#')} {(-ne)} {(0)})]
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ VSub_Number '$1'))}
                      arms: [
                        (case_arm
                          pat_list: [{(-q)} {(--quiet)}]
                          action: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:GIT_QUIET)
                                  op: Equal
                                  rhs: {(1)}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--cached)}]
                          action: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:cached)
                                  op: Equal
                                  rhs: {(1)}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--recursive)}]
                          action: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:recursive)
                                  op: Equal
                                  rhs: {(1)}
                                )
                              ]
                            )
                          ]
                        )
                        (case_arm
                          pat_list: [{(--)}]
                          action: [(C {(shift)}) (command.ControlFlow token:<ControlFlow_Break break>)]
                        )
                        (case_arm
                          pat_list: [{(-) (Lit_Star '*')}]
                          action: [(C {(usage)})]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*')}]
                          action: [(command.ControlFlow token:<ControlFlow_Break break>)]
                        )
                      ]
                    )
                    (C {(shift)})
                  ]
                )
            )
            (command.Pipeline
              children: [
                (command.BraceGroup
                  children: [
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(git)} {(submodule--helper)} {(list)} {(--prefix)} 
                          {(DQ ($ VSub_DollarName '$wt_prefix'))} {(DQ ($ VSub_At '$@'))}
                        )
                        (C {(echo)} {(DQ ('#unmatched'))} {($ VSub_QMark '$?')})
                      ]
                    )
                  ]
                )
                (command.WhileUntil
                  keyword: <KW_While while>
                  cond: [(C {(read)} {(mode)} {(sha1)} {(stage)} {(sm_path)})]
                  body: 
                    (command.DoGroup
                      children: [
                        (C {(die_if_unmatched)} {(DQ ($ VSub_DollarName '$mode'))} 
                          {(DQ ($ VSub_DollarName '$sha1'))}
                        )
                        (command.AndOr
                          ops: [Op_DPipe]
                          children: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:name)
                                  op: Equal
                                  rhs: 
                                    {
                                      (word_part.CommandSub
                                        left_token: <Left_DollarParen '$('>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (C {(git)} {(submodule--helper)} {(name)} 
                                                {(DQ ($ VSub_DollarName '$sm_path'))}
                                              )
                                            ]
                                          )
                                      )
                                    }
                                )
                              ]
                            )
                            (command.ControlFlow
                              token: <ControlFlow_Exit exit>
                            )
                          ]
                        )
                        (command.Assignment
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:url)
                              op: Equal
                              rhs: 
                                {
                                  (word_part.CommandSub
                                    left_token: <Left_DollarParen '$('>
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(git)} {(config)} 
                                            {(submodule.) (DQ ($ VSub_DollarName '$name')) (.url)}
                                          )
                                        ]
                                      )
                                  )
                                }
                            )
                          ]
                        )
                        (command.Assignment
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:displaypath)
                              op: Equal
                              rhs: 
                                {
                                  (word_part.CommandSub
                                    left_token: <Left_DollarParen '$('>
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(git)} {(submodule--helper)} {(relative-path)} 
                                            {
                                              (DQ ($ VSub_DollarName '$prefix') 
                                                ($ VSub_DollarName '$sm_path')
                                              )
                                            } {(DQ ($ VSub_DollarName '$wt_prefix'))}
                                          )
                                        ]
                                      )
                                  )
                                }
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (C {(test)} {(DQ ($ VSub_DollarName '$stage'))} {(Lit_Other '=')} {(U)})
                              ]
                              action: [
                                (C {(say)} 
                                  {
                                    (DQ (U) ($ VSub_DollarName '$sha1') (' ') 
                                      ($ VSub_DollarName '$displaypath')
                                    )
                                  }
                                )
                                (command.ControlFlow
                                  token: <ControlFlow_Continue continue>
                                )
                              ]
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.AndOr
                                  ops: [Op_DPipe]
                                  children: [
                                    (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$url'))})
                                    (command.BraceGroup
                                      children: [
                                        (command.AndOr
                                          ops: [Op_DAmp]
                                          children: [
                                            (command.Pipeline
                                              children: [
                                                (C {(test)} {(-d)} 
                                                  {(DQ ($ VSub_DollarName '$sm_path')) (/.git)}
                                                )
                                              ]
                                              negated: T
                                            )
                                            (command.Pipeline
                                              children: [
                                                (C {(test)} {(-f)} 
                                                  {(DQ ($ VSub_DollarName '$sm_path')) (/.git)}
                                                )
                                              ]
                                              negated: T
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                              action: [
                                (C {(say)} 
                                  {
                                    (DQ (-) ($ VSub_DollarName '$sha1') (' ') 
                                      ($ VSub_DollarName '$displaypath')
                                    )
                                  }
                                )
                                (command.Sentence
                                  child: (command.ControlFlow token:<ControlFlow_Continue continue>)
                                  terminator: <Op_Semi ';'>
                                )
                              ]
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (C {(git)} {(diff-files)} 
                                  {(--ignore-submodules) (Lit_Other '=') (dirty)} {(--quiet)} {(--)} {(DQ ($ VSub_DollarName '$sm_path'))}
                                )
                              ]
                              action: [
                                (C {(set_name_rev)} {(DQ ($ VSub_DollarName '$sm_path'))} 
                                  {(DQ ($ VSub_DollarName '$sha1'))}
                                )
                                (C {(say)} 
                                  {
                                    (DQ (' ') ($ VSub_DollarName '$sha1') (' ') 
                                      ($ VSub_DollarName '$displaypath') ($ VSub_DollarName '$revname')
                                    )
                                  }
                                )
                              ]
                            )
                          ]
                          else_action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$cached'))})]
                                  action: [
                                    (command.Assignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:sha1)
                                          op: Equal
                                          rhs: 
                                            {
                                              (word_part.CommandSub
                                                left_token: <Left_DollarParen '$('>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [
                                                      (command.Sentence
                                                        child: (C {(sanitize_submodule_env)})
                                                        terminator: <Op_Semi ';'>
                                                      )
                                                      (command.AndOr
                                                        ops: [Op_DAmp]
                                                        children: [
                                                          (C {(cd)} 
                                                            {(DQ ($ VSub_DollarName '$sm_path'))}
                                                          )
                                                          (C {(git)} {(rev-parse)} {(--verify)} {(HEAD)})
                                                        ]
                                                      )
                                                    ]
                                                  )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                            (C {(set_name_rev)} {(DQ ($ VSub_DollarName '$sm_path'))} 
                              {(DQ ($ VSub_DollarName '$sha1'))}
                            )
                            (C {(say)} 
                              {
                                (DQ ('+') ($ VSub_DollarName '$sha1') (' ') 
                                  ($ VSub_DollarName '$displaypath') ($ VSub_DollarName '$revname')
                                )
                              }
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: [(C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$recursive'))})]
                              action: [
                                (command.AndOr
                                  ops: [Op_DPipe]
                                  children: [
                                    (command.Subshell
                                      command_list: 
                                        (command.CommandList
                                          children: [
                                            (command.Assignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (lhs_expr.LhsName name:prefix)
                                                  op: Equal
                                                  rhs: {(DQ ($ VSub_DollarName '$displaypath') (/))}
                                                )
                                              ]
                                            )
                                            (C {(sanitize_submodule_env)})
                                            (command.Assignment
                                              pairs: [
                                                (assign_pair
                                                  lhs: (lhs_expr.LhsName name:wt_prefix)
                                                  op: Equal
                                                  rhs: (word.Empty)
                                                )
                                              ]
                                            )
                                            (command.AndOr
                                              ops: [Op_DAmp]
                                              children: [
                                                (C {(cd)} {(DQ ($ VSub_DollarName '$sm_path'))})
                                                (C {(eval)} {(cmd_status)})
                                              ]
                                            )
                                          ]
                                        )
                                    )
                                    (C {(die)} 
                                      {
                                        (DQ 
                                          (word_part.CommandSub
                                            left_token: <Left_DollarParen '$('>
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (C {(eval_gettext)} 
                                                    {
                                                      (DQ ("Failed to recurse into submodule path '") 
                                                        (word_part.EscapedLiteral
                                                          token: <Lit_EscapedChar '\\$'>
                                                        ) ("sm_path'")
                                                      )
                                                    }
                                                  )
                                                ]
                                              )
                                          )
                                        )
                                      }
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                )
              ]
              negated: F
            )
          ]
        )
    )
    (command.FuncDef
      name: cmd_sync
      body: 
        (command.BraceGroup
          children: [
            (command.WhileUntil
              keyword: <KW_While while>
              cond: [(C {(test)} {($ VSub_Pound '$#')} {(-ne)} {(0)})]
              body: 
                (command.DoGroup
                  children: [
                    (command.Case
                      to_match: {(DQ ($ VSub_Number '$1'))}
                      arms: [
                        (case_arm
                          pat_list: [{(-q)} {(--quiet)}]
                          action: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:GIT_QUIET)
                                  op: Equal
                                  rhs: {(1)}
                                )
                              ]
                            )
                            (C {(shift)})
                          ]
                        )
                        (case_arm
                          pat_list: [{(--recursive)}]
                          action: [
                            (command.Assignment
                              pairs: [
                                (assign_pair
                                  lhs: (lhs_expr.LhsName name:recursive)
                                  op: Equal
                                  rhs: {(1)}
                                )
                              ]
                            )
                            (C {(shift)})
                          ]
                        )
                        (case_arm
                          pat_list: [{(--)}]
                          action: [(C {(shift)}) (command.ControlFlow token:<ControlFlow_Break break>)]
                        )
                        (case_arm
                          pat_list: [{(-) (Lit_Star '*')}]
                          action: [(C {(usage)})]
                        )
                        (case_arm
                          pat_list: [{(Lit_Star '*')}]
                          action: [(command.ControlFlow token:<ControlFlow_Break break>)]
                        )
                      ]
                    )
                  ]
                )
            )
            (C {(cd_to_toplevel)})
            (command.Pipeline
              children: [
                (command.BraceGroup
                  children: [
                    (command.AndOr
                      ops: [Op_DPipe]
                      children: [
                        (C {(git)} {(submodule--helper)} {(list)} {(--prefix)} 
                          {(DQ ($ VSub_DollarName '$wt_prefix'))} {(DQ ($ VSub_At '$@'))}
                        )
                        (C {(echo)} {(DQ ('#unmatched'))} {($ VSub_QMark '$?')})
                      ]
                    )
                  ]
                )
                (command.WhileUntil
                  keyword: <KW_While while>
                  cond: [(C {(read)} {(mode)} {(sha1)} {(stage)} {(sm_path)})]
                  body: 
                    (command.DoGroup
                      children: [
                        (C {(die_if_unmatched)} {(DQ ($ VSub_DollarName '$mode'))} 
                          {(DQ ($ VSub_DollarName '$sha1'))}
                        )
                        (command.Assignment
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:name)
                              op: Equal
                              rhs: 
                                {
                                  (word_part.CommandSub
                                    left_token: <Left_DollarParen '$('>
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(git)} {(submodule--helper)} {(name)} 
                                            {(DQ ($ VSub_DollarName '$sm_path'))}
                                          )
                                        ]
                                      )
                                  )
                                }
                            )
                          ]
                        )
                        (command.Assignment
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:url)
                              op: Equal
                              rhs: 
                                {
                                  (word_part.CommandSub
                                    left_token: <Left_DollarParen '$('>
                                    command_list: 
                                      (command.CommandList
                                        children: [
                                          (C {(git)} {(config)} {(-f)} {(.gitmodules)} {(--get)} 
                                            {(submodule.) (DQ ($ VSub_DollarName '$name')) (.url)}
                                          )
                                        ]
                                      )
                                  )
                                }
                            )
                          ]
                        )
                        (command.Case
                          to_match: {(DQ ($ VSub_DollarName '$url'))}
                          arms: [
                            (case_arm
                              pat_list: [{(./) (Lit_Star '*')} {(../) (Lit_Star '*')}]
                              action: [
                                (command.AndOr
                                  ops: [Op_DAmp Op_DAmp Op_DAmp Op_DPipe]
                                  children: [
                                    (command.Assignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:up_path)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (word_part.CommandSub
                                                  left_token: <Left_DollarParen '$('>
                                                  command_list: 
                                                    (command.CommandList
                                                      children: [
                                                        (command.Pipeline
                                                          children: [
                                                            (C {(printf)} {(SQ <'%s\\n'>)} 
                                                              {(DQ ($ VSub_DollarName '$sm_path'))}
                                                            )
                                                            (C {(sed)} {(DQ ('s/[^/][^/]*/../g'))})
                                                          ]
                                                          negated: F
                                                        )
                                                      ]
                                                    )
                                                )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (command.Assignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:up_path)
                                          op: Equal
                                          rhs: 
                                            {
                                              (word_part.BracedVarSub
                                                token: <VSub_Name up_path>
                                                suffix_op: 
                                                  (suffix_op.Unary
                                                    op_id: VOp1_Percent
                                                    arg_word: {(Lit_Slash /)}
                                                  )
                                              ) (/)
                                            }
                                        )
                                      ]
                                    )
                                    (command.Assignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:sub_origin_url)
                                          op: Equal
                                          rhs: 
                                            {
                                              (word_part.CommandSub
                                                left_token: <Left_DollarParen '$('>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [
                                                      (C {(git)} {(submodule--helper)} 
                                                        {(resolve-relative-url)} {(DQ ($ VSub_DollarName '$url'))} {(DQ ($ VSub_DollarName '$up_path'))}
                                                      )
                                                    ]
                                                  )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (command.Assignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (lhs_expr.LhsName name:super_config_url)
                                          op: Equal
                                          rhs: 
                                            {
                                              (word_part.CommandSub
                                                left_token: <Left_DollarParen '$('>
                                                command_list: 
                                                  (command.CommandList
                                                    children: [
                                                      (C {(git)} {(submodule--helper)} 
                                                        {(resolve-relative-url)} {(DQ ($ VSub_DollarName '$url'))}
                                                      )
                                                    ]
                                                  )
                                              )
                                            }
                                        )
                                      ]
                                    )
                                    (command.ControlFlow
                                      token: <ControlFlow_Exit exit>
                                    )
                                  ]
                                )
                              ]
                            )
                            (case_arm
                              pat_list: [{(Lit_Star '*')}]
                              action: [
                                (command.Assignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:sub_origin_url)
                                      op: Equal
                                      rhs: {(DQ ($ VSub_DollarName '$url'))}
                                    )
                                  ]
                                )
                                (command.Assignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:super_config_url)
                                      op: Equal
                                      rhs: {(DQ ($ VSub_DollarName '$url'))}
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Simple
                                  words: [
                                    {(git)}
                                    {(config)}
                                    {(DQ (submodule.) ($ VSub_DollarName '$name') (.url))}
                                  ]
                                  redirects: [
                                    (redir.Redir
                                      op: <Redir_Great '>'>
                                      fd: 16777215
                                      arg_word: {(/dev/null)}
                                    )
                                    (redir.Redir
                                      op: <Redir_Great '2>'>
                                      fd: 2
                                      arg_word: {(/dev/null)}
                                    )
                                  ]
                                )
                              ]
                              action: [
                                (command.Assignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (lhs_expr.LhsName name:displaypath)
                                      op: Equal
                                      rhs: 
                                        {
                                          (word_part.CommandSub
                                            left_token: <Left_DollarParen '$('>
                                            command_list: 
                                              (command.CommandList
                                                children: [
                                                  (C {(git)} {(submodule--helper)} {(relative-path)} 
                                                    {
                                                      (DQ ($ VSub_DollarName '$prefix') 
                                                        ($ VSub_DollarName '$sm_path')
                                                      )
                                                    } {(DQ ($ VSub_DollarName '$wt_prefix'))}
                                                  )
                                                ]
                                              )
                                          )
                                        }
                                    )
                                  ]
                                )
                                (C {(say)} 
                                  {
                                    (DQ 
                                      (word_part.CommandSub
                                        left_token: <Left_DollarParen '$('>
                                        command_list: 
                                          (command.CommandList
                                            children: [
                                              (C {(eval_gettext)} 
                                                {
                                                  (DQ ("Synchronizing submodule url for '") 
                                                    (word_part.EscapedLiteral
                                                      token: <Lit_EscapedChar '\\$'>
                                                    ) ("displaypath'")
                                                  )
                                                }
                                              )
                                            ]
                                          )
                                      )
                                    )
                                  }
                                )
                                (C {(git)} {(config)} 
                                  {(submodule.) (DQ ($ VSub_DollarName '$name')) (.url)} {(DQ ($ VSub_DollarName '$super_config_url'))}
                                )
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (C {(test)} {(-e)} {(DQ ($ VSub_DollarName '$sm_path')) (/.git)})
                                      ]
                                      action: [
                                        (command.Subshell
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {(sanitize_submodule_env)})
                                                (C {(cd)} {(DQ ($ VSub_DollarName '$sm_path'))})
                                                (command.Assignment
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (lhs_expr.LhsName name:remote)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (word_part.CommandSub
                                                            left_token: <Left_DollarParen '$('>
                                                            command_list: 
                                                              (command.CommandList
                                                                children: [(C {(get_default_remote)})]
                                                              )
                                                          )
                                                        }
                                                    )
                                                  ]
                                                )
                                                (C {(git)} {(config)} 
                                                  {(remote.) (DQ ($ VSub_DollarName '$remote')) (.url)} {(DQ ($ VSub_DollarName '$sub_origin_url'))}
                                                )
                                                (command.If
                                                  arms: [
                                                    (if_arm
                                                      cond: [
                                                        (C {(test)} {(-n)} 
                                                          {(DQ ($ VSub_DollarName '$recursive'))}
                                                        )
                                                      ]
                                                      action: [
                                                        (command.Assignment
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (lhs_expr.LhsName name:prefix)
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  (DQ ($ VSub_DollarName '$prefix') 
                                                                    ($ VSub_DollarName '$sm_path') (/)
                                                                  )
                                                                }
                                                            )
                                                          ]
                                                        )
                                                        (C {(eval)} {(cmd_sync)})
                                                      ]
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                    )
                )
              ]
              negated: F
            )
          ]
        )
    )
    (command.WhileUntil
      keyword: <KW_While while>
      cond: [
        (command.AndOr
          ops: [Op_DAmp]
          children: [
            (C {(test)} {($ VSub_Pound '$#')} {(KW_Bang '!') (Lit_Other '=')} {(0)})
            (C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$command'))})
          ]
        )
      ]
      body: 
        (command.DoGroup
          children: [
            (command.Case
              to_match: {(DQ ($ VSub_Number '$1'))}
              arms: [
                (case_arm
                  pat_list: [
                    {(add)}
                    {(foreach)}
                    {(init)}
                    {(deinit)}
                    {(update)}
                    {(status)}
                    {(summary)}
                    {(sync)}
                  ]
                  action: [
                    (command.Assignment
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:command)
                          op: Equal
                          rhs: {($ VSub_Number '$1')}
                        )
                      ]
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(-q)} {(--quiet)}]
                  action: [
                    (command.Assignment
                      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:GIT_QUIET) op:Equal rhs:{(1)})]
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(-b)} {(--branch)}]
                  action: [
                    (command.Case
                      to_match: {(DQ ($ VSub_Number '$2'))}
                      arms: [(case_arm pat_list:[{(SQ )}] action:[(C {(usage)})])]
                    )
                    (command.Sentence
                      child: 
                        (command.Assignment
                          pairs: [
                            (assign_pair
                              lhs: (lhs_expr.LhsName name:branch)
                              op: Equal
                              rhs: {(DQ ($ VSub_Number '$2'))}
                            )
                          ]
                        )
                      terminator: <Op_Semi ';'>
                    )
                    (C {(shift)})
                  ]
                )
                (case_arm
                  pat_list: [{(--cached)}]
                  action: [
                    (command.Assignment
                      pairs: [
                        (assign_pair
                          lhs: (lhs_expr.LhsName name:cached)
                          op: Equal
                          rhs: {(DQ ($ VSub_Number '$1'))}
                        )
                      ]
                    )
                  ]
                )
                (case_arm
                  pat_list: [{(--)}]
                  action: [(command.ControlFlow token:<ControlFlow_Break break>)]
                )
                (case_arm pat_list:[{(-) (Lit_Star '*')}] action:[(C {(usage)})])
                (case_arm
                  pat_list: [{(Lit_Star '*')}]
                  action: [(command.ControlFlow token:<ControlFlow_Break break>)]
                )
              ]
            )
            (C {(shift)})
          ]
        )
    )
    (command.If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-z)} {(DQ ($ VSub_DollarName '$command'))})]
          action: [
            (command.If
              arms: [
                (if_arm
                  cond: [(C {(test)} {($ VSub_Pound '$#')} {(Lit_Other '=')} {(0)})]
                  action: [
                    (command.Assignment
                      pairs: [(assign_pair lhs:(lhs_expr.LhsName name:command) op:Equal rhs:{(status)})]
                    )
                  ]
                )
              ]
              else_action: [(C {(usage)})]
            )
          ]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.AndOr
              ops: [Op_DAmp]
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$branch'))})
                (C {(test)} {(DQ ($ VSub_DollarName '$command'))} {(KW_Bang '!') (Lit_Other '=')} {(add)})
              ]
            )
          ]
          action: [(C {(usage)})]
        )
      ]
    )
    (command.If
      arms: [
        (if_arm
          cond: [
            (command.AndOr
              ops: [Op_DAmp Op_DAmp]
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_DollarName '$cached'))})
                (C {(test)} {(DQ ($ VSub_DollarName '$command'))} {(KW_Bang '!') (Lit_Other '=')} 
                  {(status)}
                )
                (C {(test)} {(DQ ($ VSub_DollarName '$command'))} {(KW_Bang '!') (Lit_Other '=')} 
                  {(summary)}
                )
              ]
            )
          ]
          action: [(C {(usage)})]
        )
      ]
    )
    (C {(DQ (cmd_) ($ VSub_DollarName '$command'))} {(DQ ($ VSub_At '$@'))})
  ]
)