(CommandList
  children: [
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:dashless)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: 
                  (CommandList
                    children: [
                      (Pipeline
                        children: [
                          (C {(basename)} {(DQ ($ VSub_Number "$0"))})
                          (C {(sed)} {(-e)} {(SQ <"s/-/ /">)})
                        ]
                        negated: False
                      )
                    ]
                  )
                left_token: <Left_CommandSub "$(">
                spids: [17 33]
              )
            }
          spids: [16]
        )
      ]
      spids: [16]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:USAGE)
          op: Equal
          rhs: 
            {
              (DQ 
                (
"[--quiet] add [-b <branch>] [-f|--force] [--name <name>] [--reference <repository>] [--] <repository> [<path>]\n"
                ) ("   or: ") ($ VSub_Name "$dashless") (" [--quiet] status [--cached] [--recursive] [--] [<path>...]\n") 
                ("   or: ") ($ VSub_Name "$dashless") (" [--quiet] init [--] [<path>...]\n") ("   or: ") ($ VSub_Name "$dashless") 
                (" [--quiet] deinit [-f|--force] (--all| [--] <path>...)\n") ("   or: ") ($ VSub_Name "$dashless") 
                (
" [--quiet] update [--init] [--remote] [-N|--no-fetch] [-f|--force] [--checkout|--merge|--rebase] [--[no-]recommend-shallow] [--reference <repository>] [--recursive] [--] [<path>...]\n"
                ) ("   or: ") ($ VSub_Name "$dashless") 
                (
" [--quiet] summary [--cached|--files] [--summary-limit <n>] [commit] [--] [<path>...]\n"
                ) ("   or: ") ($ VSub_Name "$dashless") (" [--quiet] foreach [--recursive] <command>\n") ("   or: ") 
                ($ VSub_Name "$dashless") (" [--quiet] sync [--recursive] [--] [<path>...]")
              )
            }
          spids: [35]
        )
      ]
      spids: [35]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:OPTIONS_SPEC) op:Equal rhs:{(SQ )} spids:[61])]
      spids: [61]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:SUBDIRECTORY_OK) op:Equal rhs:{(Yes)} spids:[63])]
      spids: [63]
    )
    (C {(.)} {(git-sh-setup)})
    (C {(.)} {(git-parse-remote)})
    (C {(require_work_tree)})
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:wt_prefix)
          op: Equal
          rhs: 
            {
              (CommandSubPart
                command_list: (CommandList children:[(C {(git)} {(rev-parse)} {(--show-prefix)})])
                left_token: <Left_CommandSub "$(">
                spids: [77 83]
              )
            }
          spids: [76]
        )
      ]
      spids: [76]
    )
    (C {(cd_to_toplevel)})
    (C {(Lit_Other ":")} 
      {
        (BracedVarSub
          token: <VSub_Name GIT_ALLOW_PROTOCOL>
          suffix_op: (StringUnary op_id:VTest_Equals arg_word:{("file:git:http:https:ssh")})
          spids: [108 112]
        )
      }
    )
    (C {(export)} {(GIT_ALLOW_PROTOCOL)})
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:command) op:Equal rhs:{(SQ )} spids:[119])]
      spids: [119]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:branch) op:Equal rhs:{(SQ )} spids:[121])]
      spids: [121]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:force) op:Equal rhs:{(SQ )} spids:[123])]
      spids: [123]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:reference) op:Equal rhs:{(SQ )} spids:[125])]
      spids: [125]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:cached) op:Equal rhs:{(SQ )} spids:[127])]
      spids: [127]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:recursive) op:Equal rhs:{(SQ )} spids:[129])]
      spids: [129]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:init) op:Equal rhs:{(SQ )} spids:[131])]
      spids: [131]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:files) op:Equal rhs:{(SQ )} spids:[133])]
      spids: [133]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:remote) op:Equal rhs:{(SQ )} spids:[135])]
      spids: [135]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:nofetch) op:Equal rhs:{(SQ )} spids:[137])]
      spids: [137]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:update) op:Equal rhs:{(SQ )} spids:[139])]
      spids: [139]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:prefix) op:Equal rhs:{(SQ )} spids:[141])]
      spids: [141]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:custom_name) op:Equal rhs:{(SQ )} spids:[143])]
      spids: [143]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:depth) op:Equal rhs:{(SQ )} spids:[145])]
      spids: [145]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:progress) op:Equal rhs:{(SQ )} spids:[147])]
      spids: [147]
    )
    (FuncDef
      name: die_if_unmatched
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (C {(test)} {(DQ ($ VSub_Number "$1"))} {(Lit_Other "=")} {(DQ ("#unmatched"))})
                  ]
                  action: [
                    (C {(exit)} 
                      {
                        (BracedVarSub
                          token: <VSub_Number 2>
                          suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{(1)})
                          spids: [178 182]
                        )
                      }
                    )
                  ]
                  spids: [-1 173]
                )
              ]
              spids: [-1 185]
            )
          ]
          spids: [155]
        )
      spids: [150 154]
    )
    (FuncDef
      name: get_submodule_config
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:name)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$1"))}
                  spids: [237]
                )
              ]
              spids: [237]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:option)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$2"))}
                  spids: [243]
                )
              ]
              spids: [243]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:default)
                  op: Equal
                  rhs: {(DQ ($ VSub_Number "$3"))}
                  spids: [249]
                )
              ]
              spids: [249]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:value)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(git)} {(config)} 
                                {(submodule.) (DQ ($ VSub_Name "$name")) (.) 
                                  (DQ ($ VSub_Name "$option"))
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [256 269]
                      )
                    }
                  spids: [255]
                )
              ]
              spids: [255]
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$value"))})]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:value)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(git)} {(config)} {(-f)} {(.gitmodules)} 
                                        {(submodule.) (DQ ($ VSub_Name "$name")) (.) 
                                          (DQ ($ VSub_Name "$option"))
                                        }
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [287 304]
                              )
                            }
                          spids: [286]
                        )
                      ]
                      spids: [286]
                    )
                  ]
                  spids: [-1 283]
                )
              ]
              spids: [-1 307]
            )
            (C {(printf)} {(SQ <"%s">)} 
              {
                (DQ 
                  (BracedVarSub
                    token: <VSub_Name value>
                    suffix_op: 
                      (StringUnary
                        op_id: VTest_ColonHyphen
                        arg_word: {($ VSub_Name "$default")}
                      )
                    spids: [317 321]
                  )
                )
              }
            )
          ]
          spids: [234]
        )
      spids: [229 233]
    )
    (FuncDef
      name: isnumber
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:n)
                      op: Equal
                      rhs: 
                        {
                          (ArithSubPart
                            anode: 
                              (ArithBinary
                                op_id: Arith_Plus
                                left: (ArithWord w:{($ VSub_Number "$1")})
                                right: (ArithWord w:{(Lit_Digits 0)})
                              )
                            spids: [335 342]
                          )
                        }
                      spids: [334]
                    )
                  ]
                  spids: [334]
                )
                (C {(test)} {(DQ ($ VSub_Name "$n"))} {(Lit_Other "=")} {(DQ ($ VSub_Number "$1"))})
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [331]
        )
      spids: [327 330]
    )
    (FuncDef
      name: sanitize_submodule_env
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:save_config)
                  op: Equal
                  rhs: {($ VSub_Name "$GIT_CONFIG_PARAMETERS")}
                  spids: [380]
                )
              ]
              spids: [380]
            )
            (C {(clear_local_git_env)})
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:GIT_CONFIG_PARAMETERS)
                  op: Equal
                  rhs: {($ VSub_Name "$save_config")}
                  spids: [387]
                )
              ]
              spids: [387]
            )
            (C {(export)} {(GIT_CONFIG_PARAMETERS)})
          ]
          spids: [377]
        )
      spids: [373 376]
    )
    (FuncDef
      name: cmd_add
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:reference_path)
                  op: Equal
                  rhs: {(SQ )}
                  spids: [430]
                )
              ]
              spids: [430]
            )
            (While
              cond: [(C {(test)} {($ VSub_Pound "$#")} {(-ne)} {(0)})]
              body: 
                (DoGroup
                  children: [
                    (Case
                      to_match: {(DQ ($ VSub_Number "$1"))}
                      arms: [
                        (case_arm
                          pat_list: [{(-b)} {(--branch)}]
                          action: [
                            (Case
                              to_match: {(DQ ($ VSub_Number "$2"))}
                              arms: [
                                (case_arm
                                  pat_list: [{(SQ )}]
                                  action: [(C {(usage)})]
                                  spids: [-1 474 478 -1]
                                )
                              ]
                              spids: [464 470 480]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:branch)
                                  op: Equal
                                  rhs: {($ VSub_Number "$2")}
                                  spids: [483]
                                )
                              ]
                              spids: [483]
                            )
                            (C {(shift)})
                          ]
                          spids: [456 461 490 -1]
                        )
                        (case_arm
                          pat_list: [{(-f)} {(--force)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:force)
                                  op: Equal
                                  rhs: {($ VSub_Number "$1")}
                                  spids: [501]
                                )
                              ]
                              spids: [501]
                            )
                          ]
                          spids: [493 498 505 -1]
                        )
                        (case_arm
                          pat_list: [{(-q)} {(--quiet)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:GIT_QUIET)
                                  op: Equal
                                  rhs: {(1)}
                                  spids: [514]
                                )
                              ]
                              spids: [514]
                            )
                          ]
                          spids: [508 511 518 -1]
                        )
                        (case_arm
                          pat_list: [{(--reference)}]
                          action: [
                            (Case
                              to_match: {(DQ ($ VSub_Number "$2"))}
                              arms: [
                                (case_arm
                                  pat_list: [{(SQ )}]
                                  action: [(C {(usage)})]
                                  spids: [-1 535 539 -1]
                                )
                              ]
                              spids: [525 531 541]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:reference_path)
                                  op: Equal
                                  rhs: {($ VSub_Number "$2")}
                                  spids: [544]
                                )
                              ]
                              spids: [544]
                            )
                            (C {(shift)})
                          ]
                          spids: [521 522 551 -1]
                        )
                        (case_arm
                          pat_list: [{(--reference) (Lit_Other "=") (Lit_Other "*")}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:reference_path)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (BracedVarSub
                                          token: <VSub_Number 1>
                                          suffix_op: 
                                            (StringUnary
                                              op_id: VOp1_Pound
                                              arg_word: {("--reference=")}
                                            )
                                          spids: [562 566]
                                        )
                                      )
                                    }
                                  spids: [560]
                                )
                              ]
                              spids: [560]
                            )
                          ]
                          spids: [554 557 570 -1]
                        )
                        (case_arm
                          pat_list: [{(--name)}]
                          action: [
                            (Case
                              to_match: {(DQ ($ VSub_Number "$2"))}
                              arms: [
                                (case_arm
                                  pat_list: [{(SQ )}]
                                  action: [(C {(usage)})]
                                  spids: [-1 587 591 -1]
                                )
                              ]
                              spids: [577 583 593]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:custom_name)
                                  op: Equal
                                  rhs: {($ VSub_Number "$2")}
                                  spids: [596]
                                )
                              ]
                              spids: [596]
                            )
                            (C {(shift)})
                          ]
                          spids: [573 574 603 -1]
                        )
                        (case_arm
                          pat_list: [{(--depth)}]
                          action: [
                            (Case
                              to_match: {(DQ ($ VSub_Number "$2"))}
                              arms: [
                                (case_arm
                                  pat_list: [{(SQ )}]
                                  action: [(C {(usage)})]
                                  spids: [-1 620 624 -1]
                                )
                              ]
                              spids: [610 616 626]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:depth)
                                  op: Equal
                                  rhs: {(DQ ("--depth=") ($ VSub_Number "$2"))}
                                  spids: [629]
                                )
                              ]
                              spids: [629]
                            )
                            (C {(shift)})
                          ]
                          spids: [606 607 639 -1]
                        )
                        (case_arm
                          pat_list: [{(--depth) (Lit_Other "=") (Lit_Other "*")}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:depth)
                                  op: Equal
                                  rhs: {($ VSub_Number "$1")}
                                  spids: [648]
                                )
                              ]
                              spids: [648]
                            )
                          ]
                          spids: [642 645 652 -1]
                        )
                        (case_arm
                          pat_list: [{(--)}]
                          action: [(C {(shift)}) (ControlFlow token:<ControlFlow_Break break>)]
                          spids: [655 656 665 -1]
                        )
                        (case_arm
                          pat_list: [{(-) (Lit_Other "*")}]
                          action: [(C {(usage)})]
                          spids: [668 670 676 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [(ControlFlow token:<ControlFlow_Break break>)]
                          spids: [679 680 686 -1]
                        )
                      ]
                      spids: [447 453 689]
                    )
                    (C {(shift)})
                  ]
                  spids: [444 695]
                )
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name "$reference_path"))})]
                  action: [
                    (AndOr
                      children: [
                        (C {(is_absolute_path)} {(DQ ($ VSub_Name "$reference_path"))})
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:reference_path)
                              op: Equal
                              rhs: {(DQ ($ VSub_Name "$wt_prefix") ($ VSub_Name "$reference_path"))}
                              spids: [722]
                            )
                          ]
                          spids: [722]
                        )
                      ]
                      op_id: Op_DPipe
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:reference)
                          op: Equal
                          rhs: {(DQ ("--reference=") ($ VSub_Name "$reference_path"))}
                          spids: [730]
                        )
                      ]
                      spids: [730]
                    )
                  ]
                  spids: [-1 710]
                )
              ]
              spids: [-1 737]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:repo)
                  op: Equal
                  rhs: {($ VSub_Number "$1")}
                  spids: [741]
                )
              ]
              spids: [741]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:sm_path)
                  op: Equal
                  rhs: {($ VSub_Number "$2")}
                  spids: [745]
                )
              ]
              spids: [745]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: (C {(test)} {(-z)} {(DQ ($ VSub_Name "$sm_path"))})
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:sm_path)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (Pipeline
                                        children: [
                                          (C {(printf)} {(SQ <"%s\\n">)} {(DQ ($ VSub_Name "$repo"))})
                                          (C {(sed)} {(-e)} {(SQ <"s|/$||">)} {(-e)} 
                                            {(SQ <"s|:*/*\\.git$||">)} {(-e)} {(SQ <"s|.*[/:]||g">)}
                                          )
                                        ]
                                        negated: False
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [765 798]
                              )
                            }
                          spids: [764]
                        )
                      ]
                      spids: [764]
                    )
                  ]
                  spids: [-1 761]
                )
              ]
              spids: [-1 801]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (AndOr
                          children: [
                            (C {(test)} {(-z)} {(DQ ($ VSub_Name "$repo"))})
                            (C {(test)} {(-z)} {(DQ ($ VSub_Name "$sm_path"))})
                          ]
                          op_id: Op_DPipe
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [(C {(usage)})]
                  spids: [-1 826]
                )
              ]
              spids: [-1 832]
            )
            (AndOr
              children: [
                (C {(is_absolute_path)} {(DQ ($ VSub_Name "$sm_path"))})
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:sm_path)
                      op: Equal
                      rhs: {(DQ ($ VSub_Name "$wt_prefix") ($ VSub_Name "$sm_path"))}
                      spids: [844]
                    )
                  ]
                  spids: [844]
                )
              ]
              op_id: Op_DPipe
            )
            (Case
              to_match: {(DQ ($ VSub_Name "$repo"))}
              arms: [
                (case_arm
                  pat_list: [{(./) (Lit_Other "*")} {(../) (Lit_Other "*")}]
                  action: [
                    (AndOr
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_Name "$wt_prefix"))})
                        (C {(die)} 
                          {
                            (DQ 
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(gettext)} 
                                        {
                                          (DQ 
                                            (
"Relative path can only be used from the toplevel of the working tree"
                                            )
                                          )
                                        }
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [887 893]
                              )
                            )
                          }
                        )
                      ]
                      op_id: Op_DPipe
                    )
                    (AndOr
                      children: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:realrepo)
                              op: Equal
                              rhs: 
                                {
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(git)} {(submodule--helper)} {(resolve-relative-url)} 
                                            {(DQ ($ VSub_Name "$repo"))}
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [903 913]
                                  )
                                }
                              spids: [902]
                            )
                          ]
                          spids: [902]
                        )
                        (C {(exit)})
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  spids: [865 870 920 -1]
                )
                (case_arm
                  pat_list: [{(Lit_Other "*") (Lit_Other ":") (Lit_Other "*")} {(/) (Lit_Other "*")}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:realrepo)
                          op: Equal
                          rhs: {($ VSub_Name "$repo")}
                          spids: [936]
                        )
                      ]
                      spids: [936]
                    )
                  ]
                  spids: [923 929 940 -1]
                )
                (case_arm
                  pat_list: [{(Lit_Other "*")}]
                  action: [
                    (C {(die)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ ("repo URL: '") 
                                        (EscapedLiteralPart
                                          token: <Lit_EscapedChar "\\$">
                                        ) ("repo' must be absolute or begin with ./|../")
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [950 958]
                          )
                        )
                      }
                    )
                  ]
                  spids: [943 944 962 -1]
                )
              ]
              spids: [856 862 965]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:sm_path)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (Pipeline
                                children: [
                                  (C {(printf)} {(SQ <"%s/\\n">)} {(DQ ($ VSub_Name "$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: False
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [978 1007]
                      )
                    }
                  spids: [977]
                )
              ]
              spids: [977]
            )
            (AndOr
              children: [
                (SimpleCommand
                  words: [{(git)} {(ls-files)} {(--error-unmatch)} {(DQ ($ VSub_Name "$sm_path"))}]
                  redirects: [
                    (Redir
                      op_id: Redir_Great
                      fd: -1
                      arg_word: {(/dev/null)}
                      spids: [1020]
                    )
                    (Redir op_id:Redir_GreatAnd fd:2 arg_word:{(1)} spids:[1024])
                  ]
                )
                (C {(die)} 
                  {
                    (DQ 
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(eval_gettext)} 
                                {
                                  (DQ ("'") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) 
                                    ("sm_path' already exists in the index")
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [1033 1041]
                      )
                    )
                  }
                )
              ]
              op_id: Op_DAmp
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (AndOr
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_Name "$force"))})
                        (Pipeline
                          children: [
                            (SimpleCommand
                              words: [
                                {(git)}
                                {(add)}
                                {(--dry-run)}
                                {(--ignore-missing)}
                                {(DQ ($ VSub_Name "$sm_path"))}
                              ]
                              redirects: [
                                (Redir
                                  op_id: Redir_Great
                                  fd: -1
                                  arg_word: {(/dev/null)}
                                  spids: [1072]
                                )
                                (Redir
                                  op_id: Redir_GreatAnd
                                  fd: 2
                                  arg_word: {(1)}
                                  spids: [1076]
                                )
                              ]
                            )
                          ]
                          negated: True
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  action: [
                    (SimpleCommand
                      words: [
                        {(eval_gettextln)}
                        {
                          (DQ ("The following path is ignored by one of your .gitignore files:\n") 
                            (EscapedLiteralPart
                              token: <Lit_EscapedChar "\\$">
                            ) ("sm_path\n") ("Use -f if you really want to add it.")
                          )
                        }
                      ]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[1092])]
                    )
                    (C {(exit)} {(1)})
                  ]
                  spids: [-1 1080]
                )
              ]
              spids: [-1 1101]
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name "$custom_name"))})]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:sm_name)
                          op: Equal
                          rhs: {(DQ ($ VSub_Name "$custom_name"))}
                          spids: [1119]
                        )
                      ]
                      spids: [1119]
                    )
                  ]
                  spids: [-1 1116]
                )
              ]
              else_action: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:sm_name)
                      op: Equal
                      rhs: {(DQ ($ VSub_Name "$sm_path"))}
                      spids: [1128]
                    )
                  ]
                  spids: [1128]
                )
              ]
              spids: [1125 1134]
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-e)} {(DQ ($ VSub_Name "$sm_path"))})]
                  action: [
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (AndOr
                              children: [
                                (C {(test)} {(-d)} {(DQ ($ VSub_Name "$sm_path")) (/.git)})
                                (C {(test)} {(-f)} {(DQ ($ VSub_Name "$sm_path")) (/.git)})
                              ]
                              op_id: Op_DPipe
                            )
                          ]
                          action: [
                            (C {(eval_gettextln)} 
                              {
                                (DQ ("Adding existing repo at '") 
                                  (EscapedLiteralPart
                                    token: <Lit_EscapedChar "\\$">
                                  ) ("sm_path' to the index")
                                )
                              }
                            )
                          ]
                          spids: [-1 1179]
                        )
                      ]
                      else_action: [
                        (C {(die)} 
                          {
                            (DQ 
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(eval_gettext)} 
                                        {
                                          (DQ ("'") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) 
                                            ("sm_path' already exists and is not a valid git repo")
                                          )
                                        }
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [1197 1205]
                              )
                            )
                          }
                        )
                      ]
                      spids: [1191 1209]
                    )
                  ]
                  spids: [-1 1153]
                )
              ]
              else_action: [
                (If
                  arms: [
                    (if_arm
                      cond: [(C {(test)} {(-d)} {(DQ (.git/modules/) ($ VSub_Name "$sm_name"))})]
                      action: [
                        (If
                          arms: [
                            (if_arm
                              cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$force"))})]
                              action: [
                                (SimpleCommand
                                  words: [
                                    {(eval_gettextln)}
                                    {
                                      (DQ ("A git directory for '") 
                                        (EscapedLiteralPart
                                          token: <Lit_EscapedChar "\\$">
                                        ) ("sm_name' is found locally with remote(s):")
                                      )
                                    }
                                  ]
                                  redirects: [
                                    (Redir
                                      op_id: Redir_GreatAnd
                                      fd: -1
                                      arg_word: {(2)}
                                      spids: [1247]
                                    )
                                  ]
                                )
                                (Pipeline
                                  children: [
                                    (SimpleCommand
                                      words: [{(git)} {(remote)} {(-v)}]
                                      more_env: [
                                        (env_pair
                                          name: GIT_DIR
                                          val: {(DQ (.git/modules/) ($ VSub_Name "$sm_name"))}
                                          spids: [1257]
                                        )
                                        (env_pair
                                          name: GIT_WORK_TREE
                                          val: {(.)}
                                          spids: [1263]
                                        )
                                      ]
                                    )
                                    (C {(grep)} {(SQ <"(fetch)">)})
                                    (SimpleCommand
                                      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
                                          op_id: Redir_GreatAnd
                                          fd: -1
                                          arg_word: {(2)}
                                          spids: [1305]
                                        )
                                      ]
                                    )
                                  ]
                                  negated: False
                                )
                                (C {(die)} 
                                  {
                                    (DQ 
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (C {(eval_gettextln)} 
                                                {
                                                  (DQ 
                                                    (
"If you want to reuse this local git directory instead of cloning again from\n"
                                                    ) ("  ") (EscapedLiteralPart 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.")
                                                  )
                                                }
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub "$(">
                                        spids: [1312 1324]
                                      )
                                    )
                                  }
                                )
                              ]
                              spids: [-1 1242]
                            )
                          ]
                          else_action: [
                            (C {(eval_gettextln)} 
                              {
                                (DQ ("Reactivating local git directory for submodule '") 
                                  (EscapedLiteralPart
                                    token: <Lit_EscapedChar "\\$">
                                  ) ("sm_name'.")
                                )
                              }
                            )
                          ]
                          spids: [1328 1340]
                        )
                      ]
                      spids: [-1 1228]
                    )
                  ]
                  spids: [-1 1343]
                )
                (AndOr
                  children: [
                    (C {(git)} {(submodule--helper)} {(clone)} 
                      {
                        (BracedVarSub
                          token: <VSub_Name GIT_QUIET>
                          suffix_op: (StringUnary op_id:VTest_ColonPlus arg_word:{(--quiet)})
                          spids: [1352 1356]
                        )
                      } {(--prefix)} {(DQ ($ VSub_Name "$wt_prefix"))} {(--path)} {(DQ ($ VSub_Name "$sm_path"))} {(--name)} 
                      {(DQ ($ VSub_Name "$sm_name"))} {(--url)} {(DQ ($ VSub_Name "$realrepo"))} 
                      {
                        (BracedVarSub
                          token: <VSub_Name reference>
                          suffix_op: 
                            (StringUnary
                              op_id: VTest_ColonPlus
                              arg_word: {(DQ ($ VSub_Name "$reference"))}
                            )
                          spids: [1382 1388]
                        )
                      } 
                      {
                        (BracedVarSub
                          token: <VSub_Name depth>
                          suffix_op: 
                            (StringUnary
                              op_id: VTest_ColonPlus
                              arg_word: {(DQ ($ VSub_Name "$depth"))}
                            )
                          spids: [1390 1396]
                        )
                      }
                    )
                    (C {(exit)})
                  ]
                  op_id: Op_DPipe
                )
                (AndOr
                  children: [
                    (Subshell
                      child: 
                        (CommandList
                          children: [
                            (C {(sanitize_submodule_env)})
                            (AndOr
                              children: [
                                (C {(cd)} {(DQ ($ VSub_Name "$sm_path"))})
                                (Case
                                  to_match: {(DQ ($ VSub_Name "$branch"))}
                                  arms: [
                                    (case_arm
                                      pat_list: [{(SQ )}]
                                      action: [(C {(git)} {(checkout)} {(-f)} {(-q)})]
                                      spids: [-1 1433 1443 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(Lit_Other "?") (Lit_Other "*")}]
                                      action: [
                                        (C {(git)} {(checkout)} {(-f)} {(-q)} {(-B)} 
                                          {(DQ ($ VSub_Name "$branch"))} {(DQ (origin/) ($ VSub_Name "$branch"))}
                                        )
                                      ]
                                      spids: [1446 1448 1469 -1]
                                    )
                                  ]
                                  spids: [1422 1428 1472]
                                )
                              ]
                              op_id: Op_DAmp
                            )
                          ]
                        )
                      spids: [1403 1475]
                    )
                    (C {(die)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ ("Unable to checkout submodule '") 
                                        (EscapedLiteralPart
                                          token: <Lit_EscapedChar "\\$">
                                        ) ("sm_path'")
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [1482 1490]
                          )
                        )
                      }
                    )
                  ]
                  op_id: Op_DPipe
                )
              ]
              spids: [1213 1494]
            )
            (C {(git)} {(config)} {(submodule.) (DQ ($ VSub_Name "$sm_name")) (.url)} 
              {(DQ ($ VSub_Name "$realrepo"))}
            )
            (AndOr
              children: [
                (C {(git)} {(add)} {($ VSub_Name "$force")} {(DQ ($ VSub_Name "$sm_path"))})
                (C {(die)} 
                  {
                    (DQ 
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (C {(eval_gettext)} 
                                {
                                  (DQ ("Failed to add submodule '") 
                                    (EscapedLiteralPart
                                      token: <Lit_EscapedChar "\\$">
                                    ) ("sm_path'")
                                  )
                                }
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [1529 1537]
                      )
                    )
                  }
                )
              ]
              op_id: Op_DPipe
            )
            (AndOr
              children: [
                (C {(git)} {(config)} {(-f)} {(.gitmodules)} 
                  {(submodule.) (DQ ($ VSub_Name "$sm_name")) (.path)} {(DQ ($ VSub_Name "$sm_path"))}
                )
                (AndOr
                  children: [
                    (C {(git)} {(config)} {(-f)} {(.gitmodules)} 
                      {(submodule.) (DQ ($ VSub_Name "$sm_name")) (.url)} {(DQ ($ VSub_Name "$repo"))}
                    )
                    (AndOr
                      children: [
                        (If
                          arms: [
                            (if_arm
                              cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name "$branch"))})]
                              action: [
                                (C {(git)} {(config)} {(-f)} {(.gitmodules)} 
                                  {(submodule.) (DQ ($ VSub_Name "$sm_name")) (.branch)} {(DQ ($ VSub_Name "$branch"))}
                                )
                              ]
                              spids: [-1 1595]
                            )
                          ]
                          spids: [-1 1617]
                        )
                        (AndOr
                          children: [
                            (C {(git)} {(add)} {(--force)} {(.gitmodules)})
                            (C {(die)} 
                              {
                                (DQ 
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(eval_gettext)} 
                                            {
                                              (DQ ("Failed to register submodule '") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\$">
                                                ) ("sm_path'")
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [1636 1644]
                                  )
                                )
                              }
                            )
                          ]
                          op_id: Op_DPipe
                        )
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
          ]
          spids: [423]
        )
      spids: [419 422]
    )
    (FuncDef
      name: cmd_foreach
      body: 
        (BraceGroup
          children: [
            (While
              cond: [(C {(test)} {($ VSub_Pound "$#")} {(-ne)} {(0)})]
              body: 
                (DoGroup
                  children: [
                    (Case
                      to_match: {(DQ ($ VSub_Number "$1"))}
                      arms: [
                        (case_arm
                          pat_list: [{(-q)} {(--quiet)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:GIT_QUIET)
                                  op: Equal
                                  rhs: {(1)}
                                  spids: [1708]
                                )
                              ]
                              spids: [1708]
                            )
                          ]
                          spids: [1702 1705 1712 -1]
                        )
                        (case_arm
                          pat_list: [{(--recursive)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:recursive)
                                  op: Equal
                                  rhs: {(1)}
                                  spids: [1719]
                                )
                              ]
                              spids: [1719]
                            )
                          ]
                          spids: [1715 1716 1723 -1]
                        )
                        (case_arm
                          pat_list: [{(-) (Lit_Other "*")}]
                          action: [(C {(usage)})]
                          spids: [1726 1728 1734 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [(ControlFlow token:<ControlFlow_Break break>)]
                          spids: [1737 1738 1744 -1]
                        )
                      ]
                      spids: [1693 1699 1747]
                    )
                    (C {(shift)})
                  ]
                  spids: [1690 1753]
                )
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:toplevel)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: (CommandList children:[(C {(pwd)})])
                        left_token: <Left_CommandSub "$(">
                        spids: [1758 1760]
                      )
                    }
                  spids: [1757]
                )
              ]
              spids: [1757]
            )
            (SimpleCommand
              words: [{(exec)}]
              redirects: [(Redir op_id:Redir_LessAnd fd:3 arg_word:{(0)} spids:[1774])]
            )
            (Pipeline
              children: [
                (BraceGroup
                  children: [
                    (AndOr
                      children: [
                        (C {(git)} {(submodule--helper)} {(list)} {(--prefix)} 
                          {(DQ ($ VSub_Name "$wt_prefix"))}
                        )
                        (C {(echo)} {(DQ ("#unmatched"))} {($ VSub_QMark "$?")})
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  spids: [1779]
                )
                (While
                  cond: [(C {(read)} {(mode)} {(sha1)} {(stage)} {(sm_path)})]
                  body: 
                    (DoGroup
                      children: [
                        (C {(die_if_unmatched)} {(DQ ($ VSub_Name "$mode"))} {(DQ ($ VSub_Name "$sha1"))})
                        (If
                          arms: [
                            (if_arm
                              cond: [(C {(test)} {(-e)} {(DQ ($ VSub_Name "$sm_path")) (/.git)})]
                              action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:displaypath)
                                      op: Equal
                                      rhs: 
                                        {
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (C {(git)} {(submodule--helper)} {(relative-path)} 
                                                    {
                                                      (DQ ($ VSub_Name "$prefix") 
                                                        ($ VSub_Name "$sm_path")
                                                      )
                                                    } {(DQ ($ VSub_Name "$wt_prefix"))}
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub "$(">
                                            spids: [1854 1869]
                                          )
                                        }
                                      spids: [1853]
                                    )
                                  ]
                                  spids: [1853]
                                )
                                (C {(say)} 
                                  {
                                    (DQ 
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (C {(eval_gettext)} 
                                                {
                                                  (DQ ("Entering '") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\$">
                                                    ) ("displaypath'")
                                                  )
                                                }
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub "$(">
                                        spids: [1875 1883]
                                      )
                                    )
                                  }
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:name)
                                      op: Equal
                                      rhs: 
                                        {
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (C {(git)} {(submodule--helper)} {(name)} 
                                                    {(DQ ($ VSub_Name "$sm_path"))}
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub "$(">
                                            spids: [1888 1898]
                                          )
                                        }
                                      spids: [1887]
                                    )
                                  ]
                                  spids: [1887]
                                )
                                (AndOr
                                  children: [
                                    (Subshell
                                      child: 
                                        (CommandList
                                          children: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:prefix)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ($ VSub_Name "$prefix") 
                                                        ($ VSub_Name "$sm_path") (/)
                                                      )
                                                    }
                                                  spids: [1904]
                                                )
                                              ]
                                              spids: [1904]
                                            )
                                            (C {(sanitize_submodule_env)})
                                            (AndOr
                                              children: [
                                                (C {(cd)} {(DQ ($ VSub_Name "$sm_path"))})
                                                (AndOr
                                                  children: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:sm_path)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (CommandSubPart
                                                                command_list: 
                                                                  (CommandList
                                                                    children: [
                                                                      (C {(git)} {(submodule--helper)} 
                                                                        {(relative-path)} {(DQ ($ VSub_Name "$sm_path"))} {(DQ ($ VSub_Name "$wt_prefix"))}
                                                                      )
                                                                    ]
                                                                  )
                                                                left_token: <Left_CommandSub "$(">
                                                                spids: [1925 1939]
                                                              )
                                                            }
                                                          spids: [1924]
                                                        )
                                                      ]
                                                      spids: [1924]
                                                    )
                                                    (AndOr
                                                      children: [
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:path)
                                                              op: Equal
                                                              rhs: {($ VSub_Name "$sm_path")}
                                                              spids: [1948]
                                                            )
                                                          ]
                                                          spids: [1948]
                                                        )
                                                        (AndOr
                                                          children: [
                                                            (If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (C {(test)} {($ VSub_Pound "$#")} 
                                                                      {(-eq)} {(1)}
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (C {(eval)} 
                                                                      {(DQ ($ VSub_Number "$1"))}
                                                                    )
                                                                  ]
                                                                  spids: [-1 1965]
                                                                )
                                                              ]
                                                              else_action: [(C {(DQ ($ VSub_At "$@"))})]
                                                              spids: [1975 1983]
                                                            )
                                                            (If
                                                              arms: [
                                                                (if_arm
                                                                  cond: [
                                                                    (C {(test)} {(-n)} 
                                                                      {
                                                                        (DQ 
                                                                          ($ VSub_Name "$recursive")
                                                                        )
                                                                      }
                                                                    )
                                                                  ]
                                                                  action: [
                                                                    (C {(cmd_foreach)} 
                                                                      {(DQ (--recursive))} {(DQ ($ VSub_At "$@"))}
                                                                    )
                                                                  ]
                                                                  spids: [-1 1999]
                                                                )
                                                              ]
                                                              spids: [-1 2013]
                                                            )
                                                          ]
                                                          op_id: Op_DAmp
                                                        )
                                                      ]
                                                      op_id: Op_DAmp
                                                    )
                                                  ]
                                                  op_id: Op_DAmp
                                                )
                                              ]
                                              op_id: Op_DAmp
                                            )
                                          ]
                                        )
                                      redirects: [
                                        (Redir
                                          op_id: Redir_LessAnd
                                          fd: -1
                                          arg_word: {(3)}
                                          spids: [2018]
                                        )
                                        (Redir
                                          op_id: Redir_LessAnd
                                          fd: 3
                                          arg_word: {(-)}
                                          spids: [2021]
                                        )
                                      ]
                                      spids: [1901 2016]
                                    )
                                    (C {(die)} 
                                      {
                                        (DQ 
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (C {(eval_gettext)} 
                                                    {
                                                      (DQ ("Stopping at '") 
                                                        (EscapedLiteralPart
                                                          token: <Lit_EscapedChar "\\$">
                                                        ) ("displaypath'; script returned non-zero status.")
                                                      )
                                                    }
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub "$(">
                                            spids: [2030 2038]
                                          )
                                        )
                                      }
                                    )
                                  ]
                                  op_id: Op_DPipe
                                )
                              ]
                              spids: [-1 1850]
                            )
                          ]
                          spids: [-1 2042]
                        )
                      ]
                      spids: [1824 2045]
                    )
                )
              ]
              negated: False
            )
          ]
          spids: [1672]
        )
      spids: [1668 1671]
    )
    (FuncDef
      name: cmd_init
      body: 
        (BraceGroup
          children: [
            (While
              cond: [(C {(test)} {($ VSub_Pound "$#")} {(-ne)} {(0)})]
              body: 
                (DoGroup
                  children: [
                    (Case
                      to_match: {(DQ ($ VSub_Number "$1"))}
                      arms: [
                        (case_arm
                          pat_list: [{(-q)} {(--quiet)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:GIT_QUIET)
                                  op: Equal
                                  rhs: {(1)}
                                  spids: [2105]
                                )
                              ]
                              spids: [2105]
                            )
                          ]
                          spids: [2099 2102 2109 -1]
                        )
                        (case_arm
                          pat_list: [{(--)}]
                          action: [(C {(shift)}) (ControlFlow token:<ControlFlow_Break break>)]
                          spids: [2112 2113 2122 -1]
                        )
                        (case_arm
                          pat_list: [{(-) (Lit_Other "*")}]
                          action: [(C {(usage)})]
                          spids: [2125 2127 2133 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [(ControlFlow token:<ControlFlow_Break break>)]
                          spids: [2136 2137 2143 -1]
                        )
                      ]
                      spids: [2090 2096 2146]
                    )
                    (C {(shift)})
                  ]
                  spids: [2087 2152]
                )
            )
            (C {(git)} 
              {
                (BracedVarSub
                  token: <VSub_Name wt_prefix>
                  suffix_op: 
                    (StringUnary
                      op_id: VTest_ColonPlus
                      arg_word: {("-C ") (DQ ($ VSub_Name "$wt_prefix"))}
                    )
                  spids: [2158 2165]
                )
              } {(submodule--helper)} {(init)} 
              {
                (BracedVarSub
                  token: <VSub_Name GIT_QUIET>
                  suffix_op: (StringUnary op_id:VTest_ColonPlus arg_word:{(--quiet)})
                  spids: [2171 2175]
                )
              } 
              {
                (BracedVarSub
                  token: <VSub_Name prefix>
                  suffix_op: 
                    (StringUnary
                      op_id: VTest_ColonPlus
                      arg_word: {("--prefix ") (DQ ($ VSub_Name "$prefix"))}
                    )
                  spids: [2177 2184]
                )
              } {(DQ ($ VSub_At "$@"))}
            )
          ]
          spids: [2069]
        )
      spids: [2065 2068]
    )
    (FuncDef
      name: cmd_deinit
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:deinit_all) op:Equal rhs:{(SQ )} spids:[2213])]
              spids: [2213]
            )
            (While
              cond: [(C {(test)} {($ VSub_Pound "$#")} {(-ne)} {(0)})]
              body: 
                (DoGroup
                  children: [
                    (Case
                      to_match: {(DQ ($ VSub_Number "$1"))}
                      arms: [
                        (case_arm
                          pat_list: [{(-f)} {(--force)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:force)
                                  op: Equal
                                  rhs: {($ VSub_Number "$1")}
                                  spids: [2245]
                                )
                              ]
                              spids: [2245]
                            )
                          ]
                          spids: [2239 2242 2249 -1]
                        )
                        (case_arm
                          pat_list: [{(-q)} {(--quiet)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:GIT_QUIET)
                                  op: Equal
                                  rhs: {(1)}
                                  spids: [2258]
                                )
                              ]
                              spids: [2258]
                            )
                          ]
                          spids: [2252 2255 2262 -1]
                        )
                        (case_arm
                          pat_list: [{(--all)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:deinit_all)
                                  op: Equal
                                  rhs: {(t)}
                                  spids: [2269]
                                )
                              ]
                              spids: [2269]
                            )
                          ]
                          spids: [2265 2266 2273 -1]
                        )
                        (case_arm
                          pat_list: [{(--)}]
                          action: [(C {(shift)}) (ControlFlow token:<ControlFlow_Break break>)]
                          spids: [2276 2277 2286 -1]
                        )
                        (case_arm
                          pat_list: [{(-) (Lit_Other "*")}]
                          action: [(C {(usage)})]
                          spids: [2289 2291 2297 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [(ControlFlow token:<ControlFlow_Break break>)]
                          spids: [2300 2301 2307 -1]
                        )
                      ]
                      spids: [2230 2236 2310]
                    )
                    (C {(shift)})
                  ]
                  spids: [2227 2316]
                )
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (AndOr
                      children: [
                        (C {(test)} {(-n)} {(DQ ($ VSub_Name "$deinit_all"))})
                        (C {(test)} {(DQ ($ VSub_Pound "$#"))} {(-ne)} {(0)})
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  action: [
                    (SimpleCommand
                      words: [
                        {(echo)}
                        {
                          (DQ 
                            (CommandSubPart
                              command_list: 
                                (CommandList
                                  children: [
                                    (C {(eval_gettext)} {(DQ ("pathspec and --all are incompatible"))})
                                  ]
                                )
                              left_token: <Left_CommandSub "$(">
                              spids: [2352 2358]
                            )
                          )
                        }
                      ]
                      redirects: [(Redir op_id:Redir_GreatAnd fd:-1 arg_word:{(2)} spids:[2348])]
                    )
                    (C {(usage)})
                  ]
                  spids: [-1 2343]
                )
              ]
              spids: [-1 2365]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (AndOr
                      children: [
                        (C {(test)} {($ VSub_Pound "$#")} {(Lit_Other "=")} {(0)})
                        (C {(test)} {(-z)} {(DQ ($ VSub_Name "$deinit_all"))})
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  action: [
                    (C {(die)} 
                      {
                        (DQ 
                          (CommandSubPart
                            command_list: 
                              (CommandList
                                children: [
                                  (C {(eval_gettext)} 
                                    {
                                      (DQ 
                                        (
"Use '--all' if you really want to deinitialize all submodules"
                                        )
                                      )
                                    }
                                  )
                                ]
                              )
                            left_token: <Left_CommandSub "$(">
                            spids: [2395 2401]
                          )
                        )
                      }
                    )
                  ]
                  spids: [-1 2389]
                )
              ]
              spids: [-1 2405]
            )
            (Pipeline
              children: [
                (BraceGroup
                  children: [
                    (AndOr
                      children: [
                        (C {(git)} {(submodule--helper)} {(list)} {(--prefix)} 
                          {(DQ ($ VSub_Name "$wt_prefix"))} {(DQ ($ VSub_At "$@"))}
                        )
                        (C {(echo)} {(DQ ("#unmatched"))} {($ VSub_QMark "$?")})
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  spids: [2409]
                )
                (While
                  cond: [(C {(read)} {(mode)} {(sha1)} {(stage)} {(sm_path)})]
                  body: 
                    (DoGroup
                      children: [
                        (C {(die_if_unmatched)} {(DQ ($ VSub_Name "$mode"))} {(DQ ($ VSub_Name "$sha1"))})
                        (AndOr
                          children: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:name)
                                  op: Equal
                                  rhs: 
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (C {(git)} {(submodule--helper)} {(name)} 
                                                {(DQ ($ VSub_Name "$sm_path"))}
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub "$(">
                                        spids: [2473 2483]
                                      )
                                    }
                                  spids: [2472]
                                )
                              ]
                              spids: [2472]
                            )
                            (C {(exit)})
                          ]
                          op_id: Op_DPipe
                        )
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:displaypath)
                              op: Equal
                              rhs: 
                                {
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(git)} {(submodule--helper)} {(relative-path)} 
                                            {(DQ ($ VSub_Name "$sm_path"))} {(DQ ($ VSub_Name "$wt_prefix"))}
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [2492 2506]
                                  )
                                }
                              spids: [2491]
                            )
                          ]
                          spids: [2491]
                        )
                        (If
                          arms: [
                            (if_arm
                              cond: [(C {(test)} {(-d)} {(DQ ($ VSub_Name "$sm_path"))})]
                              action: [
                                (If
                                  arms: [
                                    (if_arm
                                      cond: [(C {(test)} {(-d)} {(DQ ($ VSub_Name "$sm_path") (/.git))})]
                                      action: [
                                        (C {(die)} 
                                          {
                                            (DQ 
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (C {(eval_gettext)} 
                                                        {
                                                          (DQ ("Submodule work tree '") 
                                                            (EscapedLiteralPart
                                                              token: <Lit_EscapedChar "\\$">
                                                            ) ("displaypath' contains a .git directory\n") 
                                                            (
"(use 'rm -rf' if you really want to remove it including all of its history)"
                                                            )
                                                          )
                                                        }
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_CommandSub "$(">
                                                spids: [2550 2560]
                                              )
                                            )
                                          }
                                        )
                                      ]
                                      spids: [-1 2544]
                                    )
                                  ]
                                  spids: [-1 2564]
                                )
                                (If
                                  arms: [
                                    (if_arm
                                      cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$force"))})]
                                      action: [
                                        (AndOr
                                          children: [
                                            (C {(git)} {(rm)} {(-qn)} {(DQ ($ VSub_Name "$sm_path"))})
                                            (C {(die)} 
                                              {
                                                (DQ 
                                                  (CommandSubPart
                                                    command_list: 
                                                      (CommandList
                                                        children: [
                                                          (C {(eval_gettext)} 
                                                            {
                                                              (DQ ("Submodule work tree '") 
                                                                (EscapedLiteralPart
                                                                  token: <Lit_EscapedChar "\\$">
                                                                ) ("displaypath' contains local modifications; use '-f' to discard them")
                                                              )
                                                            }
                                                          )
                                                        ]
                                                      )
                                                    left_token: <Left_CommandSub "$(">
                                                    spids: [2598 2606]
                                                  )
                                                )
                                              }
                                            )
                                          ]
                                          op_id: Op_DPipe
                                        )
                                      ]
                                      spids: [-1 2579]
                                    )
                                  ]
                                  spids: [-1 2610]
                                )
                                (AndOr
                                  children: [
                                    (C {(rm)} {(-rf)} {(DQ ($ VSub_Name "$sm_path"))})
                                    (AndOr
                                      children: [
                                        (C {(say)} 
                                          {
                                            (DQ 
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (C {(eval_gettext)} 
                                                        {
                                                          (DQ ("Cleared directory '") 
                                                            (EscapedLiteralPart
                                                              token: <Lit_EscapedChar "\\$">
                                                            ) ("displaypath'")
                                                          )
                                                        }
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_CommandSub "$(">
                                                spids: [2627 2635]
                                              )
                                            )
                                          }
                                        )
                                        (C {(say)} 
                                          {
                                            (DQ 
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (C {(eval_gettext)} 
                                                        {
                                                          (DQ 
                                                            (
"Could not remove submodule work tree '"
                                                            ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("displaypath'")
                                                          )
                                                        }
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_CommandSub "$(">
                                                spids: [2644 2652]
                                              )
                                            )
                                          }
                                        )
                                      ]
                                      op_id: Op_DPipe
                                    )
                                  ]
                                  op_id: Op_DAmp
                                )
                              ]
                              spids: [-1 2525]
                            )
                          ]
                          spids: [-1 2656]
                        )
                        (AndOr
                          children: [
                            (C {(mkdir)} {(DQ ($ VSub_Name "$sm_path"))})
                            (C {(say)} 
                              {
                                (DQ 
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(eval_gettext)} 
                                            {
                                              (DQ ("Could not create empty submodule directory '") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\$">
                                                ) ("displaypath'")
                                              )
                                            }
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [2671 2679]
                                  )
                                )
                              }
                            )
                          ]
                          op_id: Op_DPipe
                        )
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (C {(test)} {(-n)} 
                                  {
                                    (DQ 
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (C {(git)} {(config)} {(--get-regexp)} 
                                                {(submodule.) 
                                                  (DQ ($ VSub_Name "$name") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\.">
                                                    )
                                                  )
                                                }
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub "$(">
                                        spids: [2695 2707]
                                      )
                                    )
                                  }
                                )
                              ]
                              action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:url)
                                      op: Equal
                                      rhs: 
                                        {
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (C {(git)} {(config)} 
                                                    {(submodule.) (DQ ($ VSub_Name "$name")) (.url)}
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub "$(">
                                            spids: [2723 2733]
                                          )
                                        }
                                      spids: [2722]
                                    )
                                  ]
                                  spids: [2722]
                                )
                                (AndOr
                                  children: [
                                    (SimpleCommand
                                      words: [
                                        {(git)}
                                        {(config)}
                                        {(--remove-section)}
                                        {(submodule.) (DQ ($ VSub_Name "$name"))}
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_Great
                                          fd: 2
                                          arg_word: {(/dev/null)}
                                          spids: [2747]
                                        )
                                      ]
                                    )
                                    (C {(say)} 
                                      {
                                        (DQ 
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (C {(eval_gettext)} 
                                                    {
                                                      (DQ ("Submodule '") 
                                                        (EscapedLiteralPart
                                                          token: <Lit_EscapedChar "\\$">
                                                        ) ("name' (") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("url) unregistered for path '") 
                                                        (EscapedLiteralPart
                                                          token: <Lit_EscapedChar "\\$">
                                                        ) ("displaypath'")
                                                      )
                                                    }
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub "$(">
                                            spids: [2756 2768]
                                          )
                                        )
                                      }
                                    )
                                  ]
                                  op_id: Op_DAmp
                                )
                              ]
                              spids: [-1 2711]
                            )
                          ]
                          spids: [-1 2772]
                        )
                      ]
                      spids: [2458 2775]
                    )
                )
              ]
              negated: False
            )
          ]
          spids: [2206]
        )
      spids: [2202 2205]
    )
    (FuncDef
      name: is_tip_reachable
      body: 
        (Subshell
          child: 
            (AndOr
              children: [
                (C {(sanitize_submodule_env)})
                (AndOr
                  children: [
                    (C {(cd)} {(DQ ($ VSub_Number "$1"))})
                    (AndOr
                      children: [
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:rev)
                              op: Equal
                              rhs: 
                                {
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (SimpleCommand
                                            words: [
                                              {(git)}
                                              {(rev-list)}
                                              {(-n)}
                                              {(1)}
                                              {(DQ ($ VSub_Number "$2"))}
                                              {(--not)}
                                              {(--all)}
                                            ]
                                            redirects: [
                                              (Redir
                                                op_id: Redir_Great
                                                fd: 2
                                                arg_word: {(/dev/null)}
                                                spids: [2820]
                                              )
                                            ]
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [2803 2822]
                                  )
                                }
                              spids: [2802]
                            )
                          ]
                          spids: [2802]
                        )
                        (C {(test)} {(-z)} {(DQ ($ VSub_Name "$rev"))})
                      ]
                      op_id: Op_DAmp
                    )
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
          spids: [2785 2835]
        )
      spids: [2780 2784]
    )
    (FuncDef
      name: fetch_in_submodule
      body: 
        (Subshell
          child: 
            (AndOr
              children: [
                (C {(sanitize_submodule_env)})
                (AndOr
                  children: [
                    (C {(cd)} {(DQ ($ VSub_Number "$1"))})
                    (Case
                      to_match: {(DQ ($ VSub_Number "$2"))}
                      arms: [
                        (case_arm
                          pat_list: [{(SQ )}]
                          action: [(C {(git)} {(fetch)})]
                          spids: [-1 2871 2878 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [
                            (C {(shift)})
                            (C {(git)} {(fetch)} 
                              {
                                (CommandSubPart
                                  command_list: (CommandList children:[(C {(get_default_remote)})])
                                  left_token: <Left_CommandSub "$(">
                                  spids: [2892 2894]
                                )
                              } {(DQ ($ VSub_At "$@"))}
                            )
                          ]
                          spids: [2881 2882 2900 -1]
                        )
                      ]
                      spids: [2860 2866 2903]
                    )
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
          spids: [2843 2905]
        )
      spids: [2838 2842]
    )
    (FuncDef
      name: cmd_update
      body: 
        (BraceGroup
          children: [
            (While
              cond: [(C {(test)} {($ VSub_Pound "$#")} {(-ne)} {(0)})]
              body: 
                (DoGroup
                  children: [
                    (Case
                      to_match: {(DQ ($ VSub_Number "$1"))}
                      arms: [
                        (case_arm
                          pat_list: [{(-q)} {(--quiet)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:GIT_QUIET)
                                  op: Equal
                                  rhs: {(1)}
                                  spids: [2963]
                                )
                              ]
                              spids: [2963]
                            )
                          ]
                          spids: [2957 2960 2967 -1]
                        )
                        (case_arm
                          pat_list: [{(--progress)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:progress)
                                  op: Equal
                                  rhs: {(DQ (--progress))}
                                  spids: [2974]
                                )
                              ]
                              spids: [2974]
                            )
                          ]
                          spids: [2970 2971 2980 -1]
                        )
                        (case_arm
                          pat_list: [{(-i)} {(--init)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:init)
                                  op: Equal
                                  rhs: {(1)}
                                  spids: [2989]
                                )
                              ]
                              spids: [2989]
                            )
                          ]
                          spids: [2983 2986 2993 -1]
                        )
                        (case_arm
                          pat_list: [{(--remote)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:remote)
                                  op: Equal
                                  rhs: {(1)}
                                  spids: [3000]
                                )
                              ]
                              spids: [3000]
                            )
                          ]
                          spids: [2996 2997 3004 -1]
                        )
                        (case_arm
                          pat_list: [{(-N)} {(--no-fetch)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:nofetch)
                                  op: Equal
                                  rhs: {(1)}
                                  spids: [3013]
                                )
                              ]
                              spids: [3013]
                            )
                          ]
                          spids: [3007 3010 3017 -1]
                        )
                        (case_arm
                          pat_list: [{(-f)} {(--force)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:force)
                                  op: Equal
                                  rhs: {($ VSub_Number "$1")}
                                  spids: [3026]
                                )
                              ]
                              spids: [3026]
                            )
                          ]
                          spids: [3020 3023 3030 -1]
                        )
                        (case_arm
                          pat_list: [{(-r)} {(--rebase)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:update)
                                  op: Equal
                                  rhs: {(DQ (rebase))}
                                  spids: [3039]
                                )
                              ]
                              spids: [3039]
                            )
                          ]
                          spids: [3033 3036 3045 -1]
                        )
                        (case_arm
                          pat_list: [{(--reference)}]
                          action: [
                            (Case
                              to_match: {(DQ ($ VSub_Number "$2"))}
                              arms: [
                                (case_arm
                                  pat_list: [{(SQ )}]
                                  action: [(C {(usage)})]
                                  spids: [-1 3062 3066 -1]
                                )
                              ]
                              spids: [3052 3058 3068]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:reference)
                                  op: Equal
                                  rhs: {(DQ ("--reference=") ($ VSub_Number "$2"))}
                                  spids: [3071]
                                )
                              ]
                              spids: [3071]
                            )
                            (C {(shift)})
                          ]
                          spids: [3048 3049 3081 -1]
                        )
                        (case_arm
                          pat_list: [{(--reference) (Lit_Other "=") (Lit_Other "*")}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:reference)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Number "$1"))}
                                  spids: [3090]
                                )
                              ]
                              spids: [3090]
                            )
                          ]
                          spids: [3084 3087 3096 -1]
                        )
                        (case_arm
                          pat_list: [{(-m)} {(--merge)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:update)
                                  op: Equal
                                  rhs: {(DQ (merge))}
                                  spids: [3105]
                                )
                              ]
                              spids: [3105]
                            )
                          ]
                          spids: [3099 3102 3111 -1]
                        )
                        (case_arm
                          pat_list: [{(--recursive)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:recursive)
                                  op: Equal
                                  rhs: {(1)}
                                  spids: [3118]
                                )
                              ]
                              spids: [3118]
                            )
                          ]
                          spids: [3114 3115 3122 -1]
                        )
                        (case_arm
                          pat_list: [{(--checkout)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:update)
                                  op: Equal
                                  rhs: {(DQ (checkout))}
                                  spids: [3129]
                                )
                              ]
                              spids: [3129]
                            )
                          ]
                          spids: [3125 3126 3135 -1]
                        )
                        (case_arm
                          pat_list: [{(--recommend-shallow)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:recommend_shallow)
                                  op: Equal
                                  rhs: {(DQ (--recommend-shallow))}
                                  spids: [3142]
                                )
                              ]
                              spids: [3142]
                            )
                          ]
                          spids: [3138 3139 3148 -1]
                        )
                        (case_arm
                          pat_list: [{(--no-recommend-shallow)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:recommend_shallow)
                                  op: Equal
                                  rhs: {(DQ (--no-recommend-shallow))}
                                  spids: [3155]
                                )
                              ]
                              spids: [3155]
                            )
                          ]
                          spids: [3151 3152 3161 -1]
                        )
                        (case_arm
                          pat_list: [{(--depth)}]
                          action: [
                            (Case
                              to_match: {(DQ ($ VSub_Number "$2"))}
                              arms: [
                                (case_arm
                                  pat_list: [{(SQ )}]
                                  action: [(C {(usage)})]
                                  spids: [-1 3178 3182 -1]
                                )
                              ]
                              spids: [3168 3174 3184]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:depth)
                                  op: Equal
                                  rhs: {(DQ ("--depth=") ($ VSub_Number "$2"))}
                                  spids: [3187]
                                )
                              ]
                              spids: [3187]
                            )
                            (C {(shift)})
                          ]
                          spids: [3164 3165 3197 -1]
                        )
                        (case_arm
                          pat_list: [{(--depth) (Lit_Other "=") (Lit_Other "*")}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:depth)
                                  op: Equal
                                  rhs: {($ VSub_Number "$1")}
                                  spids: [3206]
                                )
                              ]
                              spids: [3206]
                            )
                          ]
                          spids: [3200 3203 3210 -1]
                        )
                        (case_arm
                          pat_list: [{(-j)} {(--jobs)}]
                          action: [
                            (Case
                              to_match: {(DQ ($ VSub_Number "$2"))}
                              arms: [
                                (case_arm
                                  pat_list: [{(SQ )}]
                                  action: [(C {(usage)})]
                                  spids: [-1 3229 3233 -1]
                                )
                              ]
                              spids: [3219 3225 3235]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:jobs)
                                  op: Equal
                                  rhs: {(DQ ("--jobs=") ($ VSub_Number "$2"))}
                                  spids: [3238]
                                )
                              ]
                              spids: [3238]
                            )
                            (C {(shift)})
                          ]
                          spids: [3213 3216 3248 -1]
                        )
                        (case_arm
                          pat_list: [{(--jobs) (Lit_Other "=") (Lit_Other "*")}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:jobs)
                                  op: Equal
                                  rhs: {($ VSub_Number "$1")}
                                  spids: [3257]
                                )
                              ]
                              spids: [3257]
                            )
                          ]
                          spids: [3251 3254 3261 -1]
                        )
                        (case_arm
                          pat_list: [{(--)}]
                          action: [(C {(shift)}) (ControlFlow token:<ControlFlow_Break break>)]
                          spids: [3264 3265 3274 -1]
                        )
                        (case_arm
                          pat_list: [{(-) (Lit_Other "*")}]
                          action: [(C {(usage)})]
                          spids: [3277 3279 3285 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [(ControlFlow token:<ControlFlow_Break break>)]
                          spids: [3288 3289 3295 -1]
                        )
                      ]
                      spids: [2948 2954 3298]
                    )
                    (C {(shift)})
                  ]
                  spids: [2945 3304]
                )
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name "$init"))})]
                  action: [
                    (AndOr
                      children: [
                        (C {(cmd_init)} {(DQ (--))} {(DQ ($ VSub_At "$@"))})
                        (ControlFlow token:<ControlFlow_Return return>)
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  spids: [-1 3319]
                )
              ]
              spids: [-1 3337]
            )
            (Pipeline
              children: [
                (BraceGroup
                  children: [
                    (AndOr
                      children: [
                        (C {(git)} {(submodule--helper)} {(update-clone)} 
                          {
                            (BracedVarSub
                              token: <VSub_Name GIT_QUIET>
                              suffix_op: (StringUnary op_id:VTest_ColonPlus arg_word:{(--quiet)})
                              spids: [3350 3354]
                            )
                          } 
                          {
                            (BracedVarSub
                              token: <VSub_Name progress>
                              suffix_op: 
                                (StringUnary
                                  op_id: VTest_ColonPlus
                                  arg_word: {(DQ ($ VSub_Name "$progress"))}
                                )
                              spids: [3358 3364]
                            )
                          } 
                          {
                            (BracedVarSub
                              token: <VSub_Name wt_prefix>
                              suffix_op: 
                                (StringUnary
                                  op_id: VTest_ColonPlus
                                  arg_word: {("--prefix ") (DQ ($ VSub_Name "$wt_prefix"))}
                                )
                              spids: [3368 3375]
                            )
                          } 
                          {
                            (BracedVarSub
                              token: <VSub_Name prefix>
                              suffix_op: 
                                (StringUnary
                                  op_id: VTest_ColonPlus
                                  arg_word: {("--recursive-prefix ") (DQ ($ VSub_Name "$prefix"))}
                                )
                              spids: [3379 3386]
                            )
                          } 
                          {
                            (BracedVarSub
                              token: <VSub_Name update>
                              suffix_op: 
                                (StringUnary
                                  op_id: VTest_ColonPlus
                                  arg_word: {("--update ") (DQ ($ VSub_Name "$update"))}
                                )
                              spids: [3390 3397]
                            )
                          } 
                          {
                            (BracedVarSub
                              token: <VSub_Name reference>
                              suffix_op: 
                                (StringUnary
                                  op_id: VTest_ColonPlus
                                  arg_word: {(DQ ($ VSub_Name "$reference"))}
                                )
                              spids: [3401 3407]
                            )
                          } 
                          {
                            (BracedVarSub
                              token: <VSub_Name depth>
                              suffix_op: 
                                (StringUnary
                                  op_id: VTest_ColonPlus
                                  arg_word: {("--depth ") (DQ ($ VSub_Name "$depth"))}
                                )
                              spids: [3411 3418]
                            )
                          } 
                          {
                            (BracedVarSub
                              token: <VSub_Name recommend_shallow>
                              suffix_op: 
                                (StringUnary
                                  op_id: VTest_ColonPlus
                                  arg_word: {(DQ ($ VSub_Name "$recommend_shallow"))}
                                )
                              spids: [3422 3428]
                            )
                          } 
                          {
                            (BracedVarSub
                              token: <VSub_Name jobs>
                              suffix_op: 
                                (StringUnary
                                  op_id: VTest_ColonPlus
                                  arg_word: {($ VSub_Name "$jobs")}
                                )
                              spids: [3432 3436]
                            )
                          } {(DQ ($ VSub_At "$@"))}
                        )
                        (C {(echo)} {(DQ ("#unmatched"))} {($ VSub_QMark "$?")})
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  spids: [3341]
                )
                (BraceGroup
                  children: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(LhsName name:err) op:Equal rhs:{(SQ )} spids:[3462])]
                      spids: [3462]
                    )
                    (While
                      cond: [(C {(read)} {(mode)} {(sha1)} {(stage)} {(just_cloned)} {(sm_path)})]
                      body: 
                        (DoGroup
                          children: [
                            (C {(die_if_unmatched)} {(DQ ($ VSub_Name "$mode"))} 
                              {(DQ ($ VSub_Name "$sha1"))}
                            )
                            (AndOr
                              children: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:name)
                                      op: Equal
                                      rhs: 
                                        {
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (C {(git)} {(submodule--helper)} {(name)} 
                                                    {(DQ ($ VSub_Name "$sm_path"))}
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub "$(">
                                            spids: [3496 3506]
                                          )
                                        }
                                      spids: [3495]
                                    )
                                  ]
                                  spids: [3495]
                                )
                                (C {(exit)})
                              ]
                              op_id: Op_DPipe
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:url)
                                  op: Equal
                                  rhs: 
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (C {(git)} {(config)} 
                                                {(submodule.) (DQ ($ VSub_Name "$name")) (.url)}
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub "$(">
                                        spids: [3514 3524]
                                      )
                                    }
                                  spids: [3513]
                                )
                              ]
                              spids: [3513]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (Pipeline
                                      children: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$update"))})]
                                      negated: True
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:update_module)
                                          op: Equal
                                          rhs: {($ VSub_Name "$update")}
                                          spids: [3543]
                                        )
                                      ]
                                      spids: [3543]
                                    )
                                  ]
                                  spids: [-1 3540]
                                )
                              ]
                              else_action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:update_module)
                                      op: Equal
                                      rhs: 
                                        {
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (C {(git)} {(config)} 
                                                    {(submodule.) (DQ ($ VSub_Name "$name")) 
                                                      (.update)
                                                    }
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub "$(">
                                            spids: [3551 3561]
                                          )
                                        }
                                      spids: [3550]
                                    )
                                  ]
                                  spids: [3550]
                                )
                                (If
                                  arms: [
                                    (if_arm
                                      cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$update_module"))})]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:update_module)
                                              op: Equal
                                              rhs: {(DQ (checkout))}
                                              spids: [3578]
                                            )
                                          ]
                                          spids: [3578]
                                        )
                                      ]
                                      spids: [-1 3575]
                                    )
                                  ]
                                  spids: [-1 3584]
                                )
                              ]
                              spids: [3547 3587]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:displaypath)
                                  op: Equal
                                  rhs: 
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (C {(git)} {(submodule--helper)} {(relative-path)} 
                                                {
                                                  (DQ ($ VSub_Name "$prefix") ($ VSub_Name "$sm_path"))
                                                } {(DQ ($ VSub_Name "$wt_prefix"))}
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub "$(">
                                        spids: [3592 3607]
                                      )
                                    }
                                  spids: [3591]
                                )
                              ]
                              spids: [3591]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [(C {(test)} {($ VSub_Name "$just_cloned")} {(-eq)} {(1)})]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:subsha1)
                                          op: Equal
                                          rhs: {(SQ )}
                                          spids: [3625]
                                        )
                                      ]
                                      spids: [3625]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:update_module)
                                          op: Equal
                                          rhs: {(checkout)}
                                          spids: [3628]
                                        )
                                      ]
                                      spids: [3628]
                                    )
                                  ]
                                  spids: [-1 3622]
                                )
                              ]
                              else_action: [
                                (AndOr
                                  children: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:subsha1)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Sentence
                                                        child: (C {(sanitize_submodule_env)})
                                                        terminator: <Op_Semi ";">
                                                      )
                                                      (AndOr
                                                        children: [
                                                          (C {(cd)} {(DQ ($ VSub_Name "$sm_path"))})
                                                          (C {(git)} {(rev-parse)} {(--verify)} {(HEAD)})
                                                        ]
                                                        op_id: Op_DAmp
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_CommandSub "$(">
                                                spids: [3636 3656]
                                              )
                                            }
                                          spids: [3635]
                                        )
                                      ]
                                      spids: [3635]
                                    )
                                    (C {(die)} 
                                      {
                                        (DQ 
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (C {(eval_gettext)} 
                                                    {
                                                      (DQ 
                                                        (
"Unable to find current revision in submodule path '"
                                                        ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("displaypath'")
                                                      )
                                                    }
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub "$(">
                                            spids: [3664 3672]
                                          )
                                        )
                                      }
                                    )
                                  ]
                                  op_id: Op_DPipe
                                )
                              ]
                              spids: [3632 3676]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name "$remote"))})]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:branch)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (C {(git)} {(submodule--helper)} {(remote-branch)} 
                                                        {(DQ ($ VSub_Name "$sm_path"))}
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_CommandSub "$(">
                                                spids: [3695 3705]
                                              )
                                            }
                                          spids: [3694]
                                        )
                                      ]
                                      spids: [3694]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$nofetch"))})]
                                          action: [
                                            (AndOr
                                              children: [
                                                (C {(fetch_in_submodule)} 
                                                  {(DQ ($ VSub_Name "$sm_path"))} {($ VSub_Name "$depth")}
                                                )
                                                (C {(die)} 
                                                  {
                                                    (DQ 
                                                      (CommandSubPart
                                                        command_list: 
                                                          (CommandList
                                                            children: [
                                                              (C {(eval_gettext)} 
                                                                {
                                                                  (DQ 
                                                                    (
"Unable to fetch in submodule path '"
                                                                    ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("sm_path'")
                                                                  )
                                                                }
                                                              )
                                                            ]
                                                          )
                                                        left_token: <Left_CommandSub "$(">
                                                        spids: [3740 3748]
                                                      )
                                                    )
                                                  }
                                                )
                                              ]
                                              op_id: Op_DPipe
                                            )
                                          ]
                                          spids: [-1 3719]
                                        )
                                      ]
                                      spids: [-1 3752]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:remote_name)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Sentence
                                                        child: (C {(sanitize_submodule_env)})
                                                        terminator: <Op_Semi ";">
                                                      )
                                                      (AndOr
                                                        children: [
                                                          (C {(cd)} {(DQ ($ VSub_Name "$sm_path"))})
                                                          (C {(get_default_remote)})
                                                        ]
                                                        op_id: Op_DAmp
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_CommandSub "$(">
                                                spids: [3756 3769]
                                              )
                                            }
                                          spids: [3755]
                                        )
                                      ]
                                      spids: [3755]
                                    )
                                    (AndOr
                                      children: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:sha1)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (CommandSubPart
                                                    command_list: 
                                                      (CommandList
                                                        children: [
                                                          (Sentence
                                                            child: (C {(sanitize_submodule_env)})
                                                            terminator: <Op_Semi ";">
                                                          )
                                                          (AndOr
                                                            children: [
                                                              (C {(cd)} {(DQ ($ VSub_Name "$sm_path"))})
                                                              (C {(git)} {(rev-parse)} {(--verify)} 
                                                                {
                                                                  (DQ (${ VSub_Name remote_name) (/) 
                                                                    (${ VSub_Name branch)
                                                                  )
                                                                }
                                                              )
                                                            ]
                                                            op_id: Op_DAmp
                                                          )
                                                        ]
                                                      )
                                                    left_token: <Left_CommandSub "$(">
                                                    spids: [3773 3801]
                                                  )
                                                }
                                              spids: [3772]
                                            )
                                          ]
                                          spids: [3772]
                                        )
                                        (C {(die)} 
                                          {
                                            (DQ 
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (C {(eval_gettext)} 
                                                        {
                                                          (DQ ("Unable to find current ") 
                                                            (EscapedLiteralPart
                                                              token: <Lit_EscapedChar "\\$">
                                                            ) ("{remote_name}/") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) 
                                                            (
"{branch} revision in submodule path '"
                                                            ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("sm_path'")
                                                          )
                                                        }
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_CommandSub "$(">
                                                spids: [3809 3821]
                                              )
                                            )
                                          }
                                        )
                                      ]
                                      op_id: Op_DPipe
                                    )
                                  ]
                                  spids: [-1 3691]
                                )
                              ]
                              spids: [-1 3825]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (AndOr
                                      children: [
                                        (C {(test)} {(DQ ($ VSub_Name "$subsha1"))} 
                                          {(KW_Bang "!") (Lit_Other "=")} {(DQ ($ VSub_Name "$sha1"))}
                                        )
                                        (C {(test)} {(-n)} {(DQ ($ VSub_Name "$force"))})
                                      ]
                                      op_id: Op_DPipe
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:subforce)
                                          op: Equal
                                          rhs: {($ VSub_Name "$force")}
                                          spids: [3858]
                                        )
                                      ]
                                      spids: [3858]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (AndOr
                                              children: [
                                                (C {(test)} {(-z)} {(DQ ($ VSub_Name "$subsha1"))})
                                                (C {(test)} {(-z)} {(DQ ($ VSub_Name "$force"))})
                                              ]
                                              op_id: Op_DAmp
                                            )
                                          ]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:subforce)
                                                  op: Equal
                                                  rhs: {(DQ (-f))}
                                                  spids: [3890]
                                                )
                                              ]
                                              spids: [3890]
                                            )
                                          ]
                                          spids: [-1 3887]
                                        )
                                      ]
                                      spids: [-1 3896]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$nofetch"))})]
                                          action: [
                                            (AndOr
                                              children: [
                                                (C {(is_tip_reachable)} {(DQ ($ VSub_Name "$sm_path"))} 
                                                  {(DQ ($ VSub_Name "$sha1"))}
                                                )
                                                (AndOr
                                                  children: [
                                                    (C {(fetch_in_submodule)} 
                                                      {(DQ ($ VSub_Name "$sm_path"))} {($ VSub_Name "$depth")}
                                                    )
                                                    (C {(die)} 
                                                      {
                                                        (DQ 
                                                          (CommandSubPart
                                                            command_list: 
                                                              (CommandList
                                                                children: [
                                                                  (C {(eval_gettext)} 
                                                                    {
                                                                      (DQ 
                                                                        (
"Unable to fetch in submodule path '"
                                                                        ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("displaypath'")
                                                                      )
                                                                    }
                                                                  )
                                                                ]
                                                              )
                                                            left_token: <Left_CommandSub "$(">
                                                            spids: [3949 3957]
                                                          )
                                                        )
                                                      }
                                                    )
                                                  ]
                                                  op_id: Op_DPipe
                                                )
                                              ]
                                              op_id: Op_DPipe
                                            )
                                            (AndOr
                                              children: [
                                                (C {(is_tip_reachable)} {(DQ ($ VSub_Name "$sm_path"))} 
                                                  {(DQ ($ VSub_Name "$sha1"))}
                                                )
                                                (AndOr
                                                  children: [
                                                    (C {(fetch_in_submodule)} 
                                                      {(DQ ($ VSub_Name "$sm_path"))} {($ VSub_Name "$depth")} {(DQ ($ VSub_Name "$sha1"))}
                                                    )
                                                    (C {(die)} 
                                                      {
                                                        (DQ 
                                                          (CommandSubPart
                                                            command_list: 
                                                              (CommandList
                                                                children: [
                                                                  (C {(eval_gettext)} 
                                                                    {
                                                                      (DQ 
                                                                        (
"Fetched in submodule path '"
                                                                        ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("displaypath', but it did not contain ") 
                                                                        (EscapedLiteralPart
                                                                          token: 
                                                                            <Lit_EscapedChar "\\$">
                                                                        ) ("sha1. Direct fetching of that commit failed.")
                                                                      )
                                                                    }
                                                                  )
                                                                ]
                                                              )
                                                            left_token: <Left_CommandSub "$(">
                                                            spids: [4001 4011]
                                                          )
                                                        )
                                                      }
                                                    )
                                                  ]
                                                  op_id: Op_DPipe
                                                )
                                              ]
                                              op_id: Op_DPipe
                                            )
                                          ]
                                          spids: [-1 3911]
                                        )
                                      ]
                                      spids: [-1 4015]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:must_die_on_failure)
                                          op: Equal
                                          rhs: {(SQ )}
                                          spids: [4019]
                                        )
                                      ]
                                      spids: [4019]
                                    )
                                    (Case
                                      to_match: {(DQ ($ VSub_Name "$update_module"))}
                                      arms: [
                                        (case_arm
                                          pat_list: [{(checkout)}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:command)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ ("git checkout ") ($ VSub_Name "$subforce") 
                                                        (" -q")
                                                      )
                                                    }
                                                  spids: [4035]
                                                )
                                              ]
                                              spids: [4035]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:die_msg)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (CommandSubPart
                                                          command_list: 
                                                            (CommandList
                                                              children: [
                                                                (C {(eval_gettext)} 
                                                                  {
                                                                    (DQ ("Unable to checkout '") 
                                                                      (EscapedLiteralPart
                                                                        token: 
                                                                          <Lit_EscapedChar "\\$">
                                                                      ) ("sha1' in submodule path '") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("displaypath'")
                                                                    )
                                                                  }
                                                                )
                                                              ]
                                                            )
                                                          left_token: <Left_CommandSub "$(">
                                                          spids: [4045 4055]
                                                        )
                                                      )
                                                    }
                                                  spids: [4043]
                                                )
                                              ]
                                              spids: [4043]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:say_msg)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (CommandSubPart
                                                          command_list: 
                                                            (CommandList
                                                              children: [
                                                                (C {(eval_gettext)} 
                                                                  {
                                                                    (DQ ("Submodule path '") 
                                                                      (EscapedLiteralPart
                                                                        token: 
                                                                          <Lit_EscapedChar "\\$">
                                                                      ) ("displaypath': checked out '") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("sha1'")
                                                                    )
                                                                  }
                                                                )
                                                              ]
                                                            )
                                                          left_token: <Left_CommandSub "$(">
                                                          spids: [4061 4071]
                                                        )
                                                      )
                                                    }
                                                  spids: [4059]
                                                )
                                              ]
                                              spids: [4059]
                                            )
                                          ]
                                          spids: [4031 4032 4075 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(rebase)}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:command)
                                                  op: Equal
                                                  rhs: {(DQ ("git rebase"))}
                                                  spids: [4082]
                                                )
                                              ]
                                              spids: [4082]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:die_msg)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (CommandSubPart
                                                          command_list: 
                                                            (CommandList
                                                              children: [
                                                                (C {(eval_gettext)} 
                                                                  {
                                                                    (DQ ("Unable to rebase '") 
                                                                      (EscapedLiteralPart
                                                                        token: 
                                                                          <Lit_EscapedChar "\\$">
                                                                      ) ("sha1' in submodule path '") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("displaypath'")
                                                                    )
                                                                  }
                                                                )
                                                              ]
                                                            )
                                                          left_token: <Left_CommandSub "$(">
                                                          spids: [4090 4100]
                                                        )
                                                      )
                                                    }
                                                  spids: [4088]
                                                )
                                              ]
                                              spids: [4088]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:say_msg)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (CommandSubPart
                                                          command_list: 
                                                            (CommandList
                                                              children: [
                                                                (C {(eval_gettext)} 
                                                                  {
                                                                    (DQ ("Submodule path '") 
                                                                      (EscapedLiteralPart
                                                                        token: 
                                                                          <Lit_EscapedChar "\\$">
                                                                      ) ("displaypath': rebased into '") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("sha1'")
                                                                    )
                                                                  }
                                                                )
                                                              ]
                                                            )
                                                          left_token: <Left_CommandSub "$(">
                                                          spids: [4106 4116]
                                                        )
                                                      )
                                                    }
                                                  spids: [4104]
                                                )
                                              ]
                                              spids: [4104]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:must_die_on_failure)
                                                  op: Equal
                                                  rhs: {(yes)}
                                                  spids: [4120]
                                                )
                                              ]
                                              spids: [4120]
                                            )
                                          ]
                                          spids: [4078 4079 4124 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(merge)}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:command)
                                                  op: Equal
                                                  rhs: {(DQ ("git merge"))}
                                                  spids: [4131]
                                                )
                                              ]
                                              spids: [4131]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:die_msg)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (CommandSubPart
                                                          command_list: 
                                                            (CommandList
                                                              children: [
                                                                (C {(eval_gettext)} 
                                                                  {
                                                                    (DQ ("Unable to merge '") 
                                                                      (EscapedLiteralPart
                                                                        token: 
                                                                          <Lit_EscapedChar "\\$">
                                                                      ) ("sha1' in submodule path '") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("displaypath'")
                                                                    )
                                                                  }
                                                                )
                                                              ]
                                                            )
                                                          left_token: <Left_CommandSub "$(">
                                                          spids: [4139 4149]
                                                        )
                                                      )
                                                    }
                                                  spids: [4137]
                                                )
                                              ]
                                              spids: [4137]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:say_msg)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (CommandSubPart
                                                          command_list: 
                                                            (CommandList
                                                              children: [
                                                                (C {(eval_gettext)} 
                                                                  {
                                                                    (DQ ("Submodule path '") 
                                                                      (EscapedLiteralPart
                                                                        token: 
                                                                          <Lit_EscapedChar "\\$">
                                                                      ) ("displaypath': merged in '") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("sha1'")
                                                                    )
                                                                  }
                                                                )
                                                              ]
                                                            )
                                                          left_token: <Left_CommandSub "$(">
                                                          spids: [4155 4165]
                                                        )
                                                      )
                                                    }
                                                  spids: [4153]
                                                )
                                              ]
                                              spids: [4153]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:must_die_on_failure)
                                                  op: Equal
                                                  rhs: {(yes)}
                                                  spids: [4169]
                                                )
                                              ]
                                              spids: [4169]
                                            )
                                          ]
                                          spids: [4127 4128 4173 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(KW_Bang "!") (Lit_Other "*")}]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:command)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (BracedVarSub
                                                          token: <VSub_Name update_module>
                                                          suffix_op: 
                                                            (StringUnary
                                                              op_id: VOp1_Pound
                                                              arg_word: {("!")}
                                                            )
                                                          spids: [4183 4187]
                                                        )
                                                      )
                                                    }
                                                  spids: [4181]
                                                )
                                              ]
                                              spids: [4181]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:die_msg)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (CommandSubPart
                                                          command_list: 
                                                            (CommandList
                                                              children: [
                                                                (C {(eval_gettext)} 
                                                                  {
                                                                    (DQ ("Execution of '") 
                                                                      (EscapedLiteralPart
                                                                        token: 
                                                                          <Lit_EscapedChar "\\$">
                                                                      ) ("command ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("sha1' failed in submodule path '") 
                                                                      (EscapedLiteralPart
                                                                        token: 
                                                                          <Lit_EscapedChar "\\$">
                                                                      ) ("displaypath'")
                                                                    )
                                                                  }
                                                                )
                                                              ]
                                                            )
                                                          left_token: <Left_CommandSub "$(">
                                                          spids: [4193 4205]
                                                        )
                                                      )
                                                    }
                                                  spids: [4191]
                                                )
                                              ]
                                              spids: [4191]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:say_msg)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (CommandSubPart
                                                          command_list: 
                                                            (CommandList
                                                              children: [
                                                                (C {(eval_gettext)} 
                                                                  {
                                                                    (DQ ("Submodule path '") 
                                                                      (EscapedLiteralPart
                                                                        token: 
                                                                          <Lit_EscapedChar "\\$">
                                                                      ) ("displaypath': '") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("command ") 
                                                                      (EscapedLiteralPart
                                                                        token: 
                                                                          <Lit_EscapedChar "\\$">
                                                                      ) ("sha1'")
                                                                    )
                                                                  }
                                                                )
                                                              ]
                                                            )
                                                          left_token: <Left_CommandSub "$(">
                                                          spids: [4211 4223]
                                                        )
                                                      )
                                                    }
                                                  spids: [4209]
                                                )
                                              ]
                                              spids: [4209]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:must_die_on_failure)
                                                  op: Equal
                                                  rhs: {(yes)}
                                                  spids: [4227]
                                                )
                                              ]
                                              spids: [4227]
                                            )
                                          ]
                                          spids: [4176 4178 4231 -1]
                                        )
                                        (case_arm
                                          pat_list: [{(Lit_Other "*")}]
                                          action: [
                                            (C {(die)} 
                                              {
                                                (DQ 
                                                  (CommandSubPart
                                                    command_list: 
                                                      (CommandList
                                                        children: [
                                                          (C {(eval_gettext)} 
                                                            {
                                                              (DQ ("Invalid update mode '") 
                                                                ($ VSub_Name "$update_module") ("' for submodule '") ($ VSub_Name "$name") ("'")
                                                              )
                                                            }
                                                          )
                                                        ]
                                                      )
                                                    left_token: <Left_CommandSub "$(">
                                                    spids: [4241 4251]
                                                  )
                                                )
                                              }
                                            )
                                          ]
                                          spids: [4234 4235 -1 4255]
                                        )
                                      ]
                                      spids: [4022 4028 4255]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [
                                            (Subshell
                                              child: 
                                                (CommandList
                                                  children: [
                                                    (Sentence
                                                      child: (C {(sanitize_submodule_env)})
                                                      terminator: <Op_Semi ";">
                                                    )
                                                    (AndOr
                                                      children: [
                                                        (C {(cd)} {(DQ ($ VSub_Name "$sm_path"))})
                                                        (C {($ VSub_Name "$command")} 
                                                          {(DQ ($ VSub_Name "$sha1"))}
                                                        )
                                                      ]
                                                      op_id: Op_DAmp
                                                    )
                                                  ]
                                                )
                                              spids: [4261 4278]
                                            )
                                          ]
                                          action: [(C {(say)} {(DQ ($ VSub_Name "$say_msg"))})]
                                          spids: [-1 4281]
                                        )
                                        (if_arm
                                          cond: [
                                            (C {(test)} {(-n)} 
                                              {(DQ ($ VSub_Name "$must_die_on_failure"))}
                                            )
                                          ]
                                          action: [
                                            (C {(die_with_status)} {(2)} {(DQ ($ VSub_Name "$die_msg"))})
                                          ]
                                          spids: [4291 4302]
                                        )
                                      ]
                                      else_action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:err)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (DQ (${ VSub_Name err) (";") ($ VSub_Name "$die_msg"))
                                                }
                                              spids: [4317]
                                            )
                                          ]
                                          spids: [4317]
                                        )
                                        (ControlFlow
                                          token: <ControlFlow_Continue continue>
                                        )
                                      ]
                                      spids: [4314 4330]
                                    )
                                  ]
                                  spids: [-1 3855]
                                )
                              ]
                              spids: [-1 4333]
                            )
                            (If
                              arms: [
                                (if_arm
                                  cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name "$recursive"))})]
                                  action: [
                                    (Subshell
                                      child: 
                                        (CommandList
                                          children: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:prefix)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (CommandSubPart
                                                        command_list: 
                                                          (CommandList
                                                            children: [
                                                              (C {(git)} {(submodule--helper)} 
                                                                {(relative-path)} {(DQ ($ VSub_Name "$prefix") ($ VSub_Name "$sm_path") (/))} {(DQ ($ VSub_Name "$wt_prefix"))}
                                                              )
                                                            ]
                                                          )
                                                        left_token: <Left_CommandSub "$(">
                                                        spids: [4355 4371]
                                                      )
                                                    }
                                                  spids: [4354]
                                                )
                                              ]
                                              spids: [4354]
                                            )
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:wt_prefix)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [4374]
                                                )
                                              ]
                                              spids: [4374]
                                            )
                                            (C {(sanitize_submodule_env)})
                                            (AndOr
                                              children: [
                                                (C {(cd)} {(DQ ($ VSub_Name "$sm_path"))})
                                                (C {(eval)} {(cmd_update)})
                                              ]
                                              op_id: Op_DAmp
                                            )
                                          ]
                                        )
                                      spids: [4351 4394]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:res)
                                          op: Equal
                                          rhs: {($ VSub_QMark "$?")}
                                          spids: [4397]
                                        )
                                      ]
                                      spids: [4397]
                                    )
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [(C {(test)} {($ VSub_Name "$res")} {(-gt)} {(0)})]
                                          action: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:die_msg)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (DQ 
                                                        (CommandSubPart
                                                          command_list: 
                                                            (CommandList
                                                              children: [
                                                                (C {(eval_gettext)} 
                                                                  {
                                                                    (DQ 
                                                                      (
"Failed to recurse into submodule path '"
                                                                      ) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) ("displaypath'")
                                                                    )
                                                                  }
                                                                )
                                                              ]
                                                            )
                                                          left_token: <Left_CommandSub "$(">
                                                          spids: [4417 4425]
                                                        )
                                                      )
                                                    }
                                                  spids: [4415]
                                                )
                                              ]
                                              spids: [4415]
                                            )
                                            (If
                                              arms: [
                                                (if_arm
                                                  cond: [
                                                    (C {(test)} {($ VSub_Name "$res")} {(-ne)} {(2)})
                                                  ]
                                                  action: [
                                                    (Assignment
                                                      keyword: Assign_None
                                                      pairs: [
                                                        (assign_pair
                                                          lhs: (LhsName name:err)
                                                          op: Equal
                                                          rhs: 
                                                            {
                                                              (DQ (${ VSub_Name err) (";") 
                                                                ($ VSub_Name "$die_msg")
                                                              )
                                                            }
                                                          spids: [4443]
                                                        )
                                                      ]
                                                      spids: [4443]
                                                    )
                                                    (ControlFlow
                                                      token: <ControlFlow_Continue continue>
                                                    )
                                                  ]
                                                  spids: [-1 4440]
                                                )
                                              ]
                                              else_action: [
                                                (C {(die_with_status)} {($ VSub_Name "$res")} 
                                                  {(DQ ($ VSub_Name "$die_msg"))}
                                                )
                                              ]
                                              spids: [4456 4468]
                                            )
                                          ]
                                          spids: [-1 4412]
                                        )
                                      ]
                                      spids: [-1 4471]
                                    )
                                  ]
                                  spids: [-1 4348]
                                )
                              ]
                              spids: [-1 4474]
                            )
                          ]
                          spids: [3480 4477]
                        )
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name "$err"))})]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:OIFS)
                                  op: Equal
                                  rhs: {($ VSub_Name "$IFS")}
                                  spids: [4495]
                                )
                              ]
                              spids: [4495]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:IFS)
                                  op: Equal
                                  rhs: {(SQ <";">)}
                                  spids: [4499]
                                )
                              ]
                              spids: [4499]
                            )
                            (ForEach
                              iter_name: e
                              iter_words: [{($ VSub_Name "$err")}]
                              do_arg_iter: False
                              body: 
                                (DoGroup
                                  children: [
                                    (If
                                      arms: [
                                        (if_arm
                                          cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name "$e"))})]
                                          action: [
                                            (SimpleCommand
                                              words: [{(echo)} {(DQ ($ VSub_Name "$e"))}]
                                              redirects: [
                                                (Redir
                                                  op_id: Redir_GreatAnd
                                                  fd: -1
                                                  arg_word: {(2)}
                                                  spids: [4533]
                                                )
                                              ]
                                            )
                                          ]
                                          spids: [-1 4528]
                                        )
                                      ]
                                      spids: [-1 4541]
                                    )
                                  ]
                                  spids: [4514 4544]
                                )
                              spids: [4510 -1]
                            )
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:IFS)
                                  op: Equal
                                  rhs: {($ VSub_Name "$OIFS")}
                                  spids: [4547]
                                )
                              ]
                              spids: [4547]
                            )
                            (C {(exit)} {(1)})
                          ]
                          spids: [-1 4492]
                        )
                      ]
                      spids: [-1 4556]
                    )
                  ]
                  spids: [3459]
                )
              ]
              negated: False
            )
          ]
          spids: [2927]
        )
      spids: [2923 2926]
    )
    (FuncDef
      name: set_name_rev
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:revname)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (Subshell
                                child: 
                                  (CommandList
                                    children: [
                                      (C {(sanitize_submodule_env)})
                                      (AndOr
                                        children: [
                                          (C {(cd)} {(DQ ($ VSub_Number "$1"))})
                                          (BraceGroup
                                            children: [
                                              (AndOr
                                                children: [
                                                  (SimpleCommand
                                                    words: [
                                                      {(git)}
                                                      {(describe)}
                                                      {(DQ ($ VSub_Number "$2"))}
                                                    ]
                                                    redirects: [
                                                      (Redir
                                                        op_id: Redir_Great
                                                        fd: 2
                                                        arg_word: {(/dev/null)}
                                                        spids: [4600]
                                                      )
                                                    ]
                                                  )
                                                  (AndOr
                                                    children: [
                                                      (SimpleCommand
                                                        words: [
                                                          {(git)}
                                                          {(describe)}
                                                          {(--tags)}
                                                          {(DQ ($ VSub_Number "$2"))}
                                                        ]
                                                        redirects: [
                                                          (Redir
                                                            op_id: Redir_Great
                                                            fd: 2
                                                            arg_word: {(/dev/null)}
                                                            spids: [4616]
                                                          )
                                                        ]
                                                      )
                                                      (AndOr
                                                        children: [
                                                          (SimpleCommand
                                                            words: [
                                                              {(git)}
                                                              {(describe)}
                                                              {(--contains)}
                                                              {(DQ ($ VSub_Number "$2"))}
                                                            ]
                                                            redirects: [
                                                              (Redir
                                                                op_id: Redir_Great
                                                                fd: 2
                                                                arg_word: {(/dev/null)}
                                                                spids: [4632]
                                                              )
                                                            ]
                                                          )
                                                          (C {(git)} {(describe)} {(--all)} {(--always)} 
                                                            {(DQ ($ VSub_Number "$2"))}
                                                          )
                                                        ]
                                                        op_id: Op_DPipe
                                                      )
                                                    ]
                                                    op_id: Op_DPipe
                                                  )
                                                ]
                                                op_id: Op_DPipe
                                              )
                                            ]
                                            spids: [4589]
                                          )
                                        ]
                                        op_id: Op_DAmp
                                      )
                                    ]
                                  )
                                spids: [4575 4654]
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [4573 4656]
                      )
                    }
                  spids: [4572]
                )
              ]
              spids: [4572]
            )
            (AndOr
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_Name "$revname"))})
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:revname)
                      op: Equal
                      rhs: {(DQ (" (") ($ VSub_Name "$revname") (")"))}
                      spids: [4669]
                    )
                  ]
                  spids: [4669]
                )
              ]
              op_id: Op_DPipe
            )
          ]
          spids: [4569]
        )
      spids: [4564 4568]
    )
    (FuncDef
      name: cmd_summary
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:summary_limit) op:Equal rhs:{(-1)} spids:[4709])]
              spids: [4709]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:for_status) op:Equal rhs:{(SQ )} spids:[4713])]
              spids: [4713]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:diff_cmd)
                  op: Equal
                  rhs: {(diff-index)}
                  spids: [4716]
                )
              ]
              spids: [4716]
            )
            (While
              cond: [(C {(test)} {($ VSub_Pound "$#")} {(-ne)} {(0)})]
              body: 
                (DoGroup
                  children: [
                    (Case
                      to_match: {(DQ ($ VSub_Number "$1"))}
                      arms: [
                        (case_arm
                          pat_list: [{(--cached)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:cached)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Number "$1"))}
                                  spids: [4752]
                                )
                              ]
                              spids: [4752]
                            )
                          ]
                          spids: [4748 4749 4758 -1]
                        )
                        (case_arm
                          pat_list: [{(--files)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:files)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Number "$1"))}
                                  spids: [4765]
                                )
                              ]
                              spids: [4765]
                            )
                          ]
                          spids: [4761 4762 4771 -1]
                        )
                        (case_arm
                          pat_list: [{(--for-status)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:for_status)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Number "$1"))}
                                  spids: [4778]
                                )
                              ]
                              spids: [4778]
                            )
                          ]
                          spids: [4774 4775 4784 -1]
                        )
                        (case_arm
                          pat_list: [{(-n)} {(--summary-limit)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:summary_limit)
                                  op: Equal
                                  rhs: {(DQ ($ VSub_Number "$2"))}
                                  spids: [4793]
                                )
                              ]
                              spids: [4793]
                            )
                            (AndOr
                              children: [
                                (C {(isnumber)} {(DQ ($ VSub_Name "$summary_limit"))})
                                (C {(usage)})
                              ]
                              op_id: Op_DPipe
                            )
                            (C {(shift)})
                          ]
                          spids: [4787 4790 4813 -1]
                        )
                        (case_arm
                          pat_list: [{(--summary-limit) (Lit_Other "=") (Lit_Other "*")}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:summary_limit)
                                  op: Equal
                                  rhs: 
                                    {
                                      (DQ 
                                        (BracedVarSub
                                          token: <VSub_Number 1>
                                          suffix_op: 
                                            (StringUnary
                                              op_id: VOp1_Pound
                                              arg_word: {("--summary-limit=")}
                                            )
                                          spids: [4824 4828]
                                        )
                                      )
                                    }
                                  spids: [4822]
                                )
                              ]
                              spids: [4822]
                            )
                            (AndOr
                              children: [
                                (C {(isnumber)} {(DQ ($ VSub_Name "$summary_limit"))})
                                (C {(usage)})
                              ]
                              op_id: Op_DPipe
                            )
                          ]
                          spids: [4816 4819 4843 -1]
                        )
                        (case_arm
                          pat_list: [{(--)}]
                          action: [(C {(shift)}) (ControlFlow token:<ControlFlow_Break break>)]
                          spids: [4846 4847 4856 -1]
                        )
                        (case_arm
                          pat_list: [{(-) (Lit_Other "*")}]
                          action: [(C {(usage)})]
                          spids: [4859 4861 4867 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [(ControlFlow token:<ControlFlow_Break break>)]
                          spids: [4870 4871 4877 -1]
                        )
                      ]
                      spids: [4739 4745 4880]
                    )
                    (C {(shift)})
                  ]
                  spids: [4736 4886]
                )
            )
            (AndOr
              children: [
                (C {(test)} {($ VSub_Name "$summary_limit")} {(Lit_Other "=")} {(0)})
                (ControlFlow token:<ControlFlow_Return return>)
              ]
              op_id: Op_DAmp
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:rev)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(git)} {(rev-parse)} {(-q)} {(--verify)} {(--default)} {(HEAD)} 
                                        {
                                          (BracedVarSub
                                            token: <VSub_Number 1>
                                            suffix_op: 
                                              (StringUnary
                                                op_id: VTest_Plus
                                                arg_word: {(DQ ($ VSub_Number "$1"))}
                                              )
                                            spids: [4920 4926]
                                          )
                                        }
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [4907 4927]
                              )
                            }
                          spids: [4906]
                        )
                      ]
                      spids: [4906]
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:head)
                          op: Equal
                          rhs: {($ VSub_Name "$rev")}
                          spids: [4933]
                        )
                      ]
                      spids: [4933]
                    )
                    (AndOr
                      children: [
                        (C {(test)} {($ VSub_Pound "$#")} {(Lit_Other "=")} {(0)})
                        (C {(shift)})
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  spids: [-1 4930]
                )
                (if_arm
                  cond: [
                    (AndOr
                      children: [
                        (C {(test)} {(-z)} {(DQ ($ VSub_Number "$1"))})
                        (C {(test)} {(DQ ($ VSub_Number "$1"))} {(Lit_Other "=")} {(DQ (HEAD))})
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:head)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (SimpleCommand
                                        words: [{(git)} {(hash-object)} {(-w)} {(-t)} {(tree)} {(--stdin)}]
                                        redirects: [
                                          (Redir
                                            op_id: Redir_Less
                                            fd: -1
                                            arg_word: {(/dev/null)}
                                            spids: [4996]
                                          )
                                        ]
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [4983 4998]
                              )
                            }
                          spids: [4982]
                        )
                      ]
                      spids: [4982]
                    )
                    (AndOr
                      children: [(C {(test)} {(-z)} {(DQ ($ VSub_Number "$1"))}) (C {(shift)})]
                      op_id: Op_DPipe
                    )
                  ]
                  spids: [4950 4975]
                )
              ]
              else_action: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:head)
                      op: Equal
                      rhs: {(DQ (HEAD))}
                      spids: [5017]
                    )
                  ]
                  spids: [5017]
                )
              ]
              spids: [5014 5023]
            )
            (If
              arms: [
                (if_arm
                  cond: [(C {(Lit_Other "[")} {(-n)} {(DQ ($ VSub_Name "$files"))} {(Lit_Other "]")})]
                  action: [
                    (AndOr
                      children: [
                        (C {(test)} {(-n)} {(DQ ($ VSub_Name "$cached"))})
                        (C {(die)} 
                          {
                            (DQ 
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (C {(gettext)} 
                                        {
                                          (DQ 
                                            (
"The --cached option cannot be used with the --files option"
                                            )
                                          )
                                        }
                                      )
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [5057 5063]
                              )
                            )
                          }
                        )
                      ]
                      op_id: Op_DAmp
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:diff_cmd)
                          op: Equal
                          rhs: {(diff-files)}
                          spids: [5067]
                        )
                      ]
                      spids: [5067]
                    )
                    (Assignment
                      keyword: Assign_None
                      pairs: [(assign_pair lhs:(LhsName name:head) op:Equal rhs:{(SQ )} spids:[5071])]
                      spids: [5071]
                    )
                  ]
                  spids: [-1 5040]
                )
              ]
              spids: [-1 5074]
            )
            (C {(cd_to_toplevel)})
            (C {(eval)} 
              {
                (DQ ("set ") 
                  (CommandSubPart
                    command_list: 
                      (CommandList
                        children: [
                          (C {(git)} {(rev-parse)} {(--sq)} {(--prefix)} {(DQ ($ VSub_Name "$wt_prefix"))} 
                            {(--)} {(DQ ($ VSub_At "$@"))}
                          )
                        ]
                      )
                    left_token: <Left_CommandSub "$(">
                    spids: [5085 5103]
                  )
                )
              }
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:modules)
                  op: Equal
                  rhs: 
                    {
                      (CommandSubPart
                        command_list: 
                          (CommandList
                            children: [
                              (Pipeline
                                children: [
                                  (C {(git)} {($ VSub_Name "$diff_cmd")} {($ VSub_Name "$cached")} 
                                    {(--ignore-submodules) (Lit_Other "=") (dirty)} {(--raw)} {($ VSub_Name "$head")} {(--)} {(DQ ($ VSub_At "$@"))}
                                  )
                                  (C {(sane_egrep)} {(SQ <"^:([0-7]* )?160000">)})
                                  (While
                                    cond: [
                                      (C {(read)} {(mod_src)} {(mod_dst)} {(sha1_src)} {(sha1_dst)} 
                                        {(status)} {(sm_path)}
                                      )
                                    ]
                                    body: 
                                      (DoGroup
                                        children: [
                                          (If
                                            arms: [
                                              (if_arm
                                                cond: [
                                                  (AndOr
                                                    children: [
                                                      (C {(test)} {(DQ ($ VSub_Name "$status"))} 
                                                        {(Lit_Other "=")} {(D)}
                                                      )
                                                      (C {(test)} {(DQ ($ VSub_Name "$status"))} 
                                                        {(Lit_Other "=")} {(T)}
                                                      )
                                                    ]
                                                    op_id: Op_DPipe
                                                  )
                                                ]
                                                action: [
                                                  (C {(printf)} {(SQ <"%s\\n">)} 
                                                    {(DQ ($ VSub_Name "$sm_path"))}
                                                  )
                                                  (ControlFlow
                                                    token: <ControlFlow_Continue continue>
                                                  )
                                                ]
                                                spids: [-1 5194]
                                              )
                                            ]
                                            spids: [-1 5211]
                                          )
                                          (If
                                            arms: [
                                              (if_arm
                                                cond: [
                                                  (C {(test)} {(-n)} {(DQ ($ VSub_Name "$for_status"))})
                                                ]
                                                action: [
                                                  (Assignment
                                                    keyword: Assign_None
                                                    pairs: [
                                                      (assign_pair
                                                        lhs: (LhsName name:name)
                                                        op: Equal
                                                        rhs: 
                                                          {
                                                            (CommandSubPart
                                                              command_list: 
                                                                (CommandList
                                                                  children: [
                                                                    (C {(git)} {(submodule--helper)} 
                                                                      {(name)} {(DQ ($ VSub_Name "$sm_path"))}
                                                                    )
                                                                  ]
                                                                )
                                                              left_token: <Left_CommandSub "$(">
                                                              spids: [5233 5243]
                                                            )
                                                          }
                                                        spids: [5232]
                                                      )
                                                    ]
                                                    spids: [5232]
                                                  )
                                                  (Assignment
                                                    keyword: Assign_None
                                                    pairs: [
                                                      (assign_pair
                                                        lhs: (LhsName name:ignore_config)
                                                        op: Equal
                                                        rhs: 
                                                          {
                                                            (CommandSubPart
                                                              command_list: 
                                                                (CommandList
                                                                  children: [
                                                                    (C {(get_submodule_config)} 
                                                                      {(DQ ($ VSub_Name "$name"))} {(ignore)} {(none)}
                                                                    )
                                                                  ]
                                                                )
                                                              left_token: <Left_CommandSub "$(">
                                                              spids: [5247 5257]
                                                            )
                                                          }
                                                        spids: [5246]
                                                      )
                                                    ]
                                                    spids: [5246]
                                                  )
                                                  (AndOr
                                                    children: [
                                                      (C {(test)} {($ VSub_Name "$status")} 
                                                        {(KW_Bang "!") (Lit_Other "=")} {(A)}
                                                      )
                                                      (AndOr
                                                        children: [
                                                          (C {(test)} {($ VSub_Name "$ignore_config")} 
                                                            {(Lit_Other "=")} {(all)}
                                                          )
                                                          (ControlFlow
                                                            token: <ControlFlow_Continue continue>
                                                          )
                                                        ]
                                                        op_id: Op_DAmp
                                                      )
                                                    ]
                                                    op_id: Op_DAmp
                                                  )
                                                ]
                                                spids: [-1 5229]
                                              )
                                            ]
                                            spids: [-1 5284]
                                          )
                                          (AndOr
                                            children: [
                                              (SimpleCommand
                                                words: [{(git-rev-parse)} {(--git-dir)}]
                                                redirects: [
                                                  (Redir
                                                    op_id: Redir_Great
                                                    fd: -1
                                                    arg_word: {(/dev/null)}
                                                    spids: [5301]
                                                  )
                                                  (Redir
                                                    op_id: Redir_GreatAnd
                                                    fd: 2
                                                    arg_word: {(1)}
                                                    spids: [5304]
                                                  )
                                                ]
                                                more_env: [
                                                  (env_pair
                                                    name: GIT_DIR
                                                    val: {(DQ ($ VSub_Name "$sm_path") (/.git))}
                                                    spids: [5291]
                                                  )
                                                ]
                                              )
                                              (C {(printf)} {(SQ <"%s\\n">)} 
                                                {(DQ ($ VSub_Name "$sm_path"))}
                                              )
                                            ]
                                            op_id: Op_DAmp
                                          )
                                        ]
                                        spids: [5162 5321]
                                      )
                                  )
                                ]
                                negated: False
                              )
                            ]
                          )
                        left_token: <Left_CommandSub "$(">
                        spids: [5112 5324]
                      )
                    }
                  spids: [5111]
                )
              ]
              spids: [5111]
            )
            (AndOr
              children: [
                (C {(test)} {(-z)} {(DQ ($ VSub_Name "$modules"))})
                (ControlFlow token:<ControlFlow_Return return>)
              ]
              op_id: Op_DAmp
            )
            (Pipeline
              children: [
                (C {(git)} {($ VSub_Name "$diff_cmd")} {($ VSub_Name "$cached")} 
                  {(--ignore-submodules) (Lit_Other "=") (dirty)} {(--raw)} {($ VSub_Name "$head")} {(--)} {($ VSub_Name "$modules")}
                )
                (C {(sane_egrep)} {(SQ <"^:([0-7]* )?160000">)})
                (C {(cut)} {(-c2-)})
                (While
                  cond: [
                    (C {(read)} {(mod_src)} {(mod_dst)} {(sha1_src)} {(sha1_dst)} {(status)} {(name)})
                  ]
                  body: 
                    (DoGroup
                      children: [
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (AndOr
                                  children: [
                                    (C {(test)} {(-z)} {(DQ ($ VSub_Name "$cached"))})
                                    (C {(test)} {($ VSub_Name "$sha1_dst")} {(Lit_Other "=")} 
                                      {(0000000000000000000000000000000000000000)}
                                    )
                                  ]
                                  op_id: Op_DAmp
                                )
                              ]
                              action: [
                                (Case
                                  to_match: {(DQ ($ VSub_Name "$mod_dst"))}
                                  arms: [
                                    (case_arm
                                      pat_list: [{(160000)}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:sha1_dst)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (CommandSubPart
                                                    command_list: 
                                                      (CommandList
                                                        children: [
                                                          (SimpleCommand
                                                            words: [{(git)} {(rev-parse)} {(HEAD)}]
                                                            more_env: [
                                                              (env_pair
                                                                name: GIT_DIR
                                                                val: 
                                                                  {
                                                                    (DQ ($ VSub_Name "$name") (/.git))
                                                                  }
                                                                spids: [5439]
                                                              )
                                                            ]
                                                          )
                                                        ]
                                                      )
                                                    left_token: <Left_CommandSub "$(">
                                                    spids: [5438 5450]
                                                  )
                                                }
                                              spids: [5437]
                                            )
                                          ]
                                          spids: [5437]
                                        )
                                      ]
                                      spids: [5433 5434 5453 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(100644)} {(100755)} {(120000)}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:sha1_dst)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (CommandSubPart
                                                    command_list: 
                                                      (CommandList
                                                        children: [
                                                          (C {(git)} {(hash-object)} 
                                                            {($ VSub_Name "$name")}
                                                          )
                                                        ]
                                                      )
                                                    left_token: <Left_CommandSub "$(">
                                                    spids: [5469 5475]
                                                  )
                                                }
                                              spids: [5468]
                                            )
                                          ]
                                          spids: [5468]
                                        )
                                      ]
                                      spids: [5456 5465 5478 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(000000)}]
                                      spids: [5481 5482 5485 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(Lit_Other "*")}]
                                      action: [
                                        (SimpleCommand
                                          words: [
                                            {(eval_gettextln)}
                                            {
                                              (DQ ("unexpected mode ") 
                                                (EscapedLiteralPart
                                                  token: <Lit_EscapedChar "\\$">
                                                ) (mod_dst)
                                              )
                                            }
                                          ]
                                          redirects: [
                                            (Redir
                                              op_id: Redir_GreatAnd
                                              fd: -1
                                              arg_word: {(2)}
                                              spids: [5507]
                                            )
                                          ]
                                        )
                                        (ControlFlow
                                          token: <ControlFlow_Continue continue>
                                        )
                                      ]
                                      spids: [5491 5492 5513 -1]
                                    )
                                  ]
                                  spids: [5424 5430 5516]
                                )
                              ]
                              spids: [-1 5421]
                            )
                          ]
                          spids: [-1 5519]
                        )
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:missing_src)
                              op: Equal
                              rhs: {(SQ )}
                              spids: [5522]
                            )
                          ]
                          spids: [5522]
                        )
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:missing_dst)
                              op: Equal
                              rhs: {(SQ )}
                              spids: [5525]
                            )
                          ]
                          spids: [5525]
                        )
                        (AndOr
                          children: [
                            (C {(test)} {($ VSub_Name "$mod_src")} {(Lit_Other "=")} {(160000)})
                            (AndOr
                              children: [
                                (Pipeline
                                  children: [
                                    (SimpleCommand
                                      words: [
                                        {(git-rev-parse)}
                                        {(-q)}
                                        {(--verify)}
                                        {($ VSub_Name "$sha1_src") (Lit_Other "^") (0)}
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_Great
                                          fd: -1
                                          arg_word: {(/dev/null)}
                                          spids: [5558]
                                        )
                                      ]
                                      more_env: [
                                        (env_pair
                                          name: GIT_DIR
                                          val: {(DQ ($ VSub_Name "$name") (/.git))}
                                          spids: [5542]
                                        )
                                      ]
                                    )
                                  ]
                                  negated: True
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:missing_src)
                                      op: Equal
                                      rhs: {(t)}
                                      spids: [5564]
                                    )
                                  ]
                                  spids: [5564]
                                )
                              ]
                              op_id: Op_DAmp
                            )
                          ]
                          op_id: Op_DAmp
                        )
                        (AndOr
                          children: [
                            (C {(test)} {($ VSub_Name "$mod_dst")} {(Lit_Other "=")} {(160000)})
                            (AndOr
                              children: [
                                (Pipeline
                                  children: [
                                    (SimpleCommand
                                      words: [
                                        {(git-rev-parse)}
                                        {(-q)}
                                        {(--verify)}
                                        {($ VSub_Name "$sha1_dst") (Lit_Other "^") (0)}
                                      ]
                                      redirects: [
                                        (Redir
                                          op_id: Redir_Great
                                          fd: -1
                                          arg_word: {(/dev/null)}
                                          spids: [5598]
                                        )
                                      ]
                                      more_env: [
                                        (env_pair
                                          name: GIT_DIR
                                          val: {(DQ ($ VSub_Name "$name") (/.git))}
                                          spids: [5582]
                                        )
                                      ]
                                    )
                                  ]
                                  negated: True
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:missing_dst)
                                      op: Equal
                                      rhs: {(t)}
                                      spids: [5604]
                                    )
                                  ]
                                  spids: [5604]
                                )
                              ]
                              op_id: Op_DAmp
                            )
                          ]
                          op_id: Op_DAmp
                        )
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:display_name)
                              op: Equal
                              rhs: 
                                {
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(git)} {(submodule--helper)} {(relative-path)} 
                                            {(DQ ($ VSub_Name "$name"))} {(DQ ($ VSub_Name "$wt_prefix"))}
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [5610 5624]
                                  )
                                }
                              spids: [5609]
                            )
                          ]
                          spids: [5609]
                        )
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:total_commits)
                              op: Equal
                              rhs: {(SQ )}
                              spids: [5628]
                            )
                          ]
                          spids: [5628]
                        )
                        (Case
                          to_match: 
                            {(DQ ($ VSub_Name "$missing_src") (",") ($ VSub_Name "$missing_dst"))}
                          arms: [
                            (case_arm
                              pat_list: [{(t) (Lit_Comma ",")}]
                              action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:errmsg)
                                      op: Equal
                                      rhs: 
                                        {
                                          (DQ 
                                            (CommandSubPart
                                              command_list: 
                                                (CommandList
                                                  children: [
                                                    (C {(eval_gettext)} 
                                                      {
                                                        (DQ ("  Warn: ") 
                                                          (EscapedLiteralPart
                                                            token: <Lit_EscapedChar "\\$">
                                                          ) ("display_name doesn't contain commit ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (sha1_src)
                                                        )
                                                      }
                                                    )
                                                  ]
                                                )
                                              left_token: <Left_CommandSub "$(">
                                              spids: [5649 5659]
                                            )
                                          )
                                        }
                                      spids: [5647]
                                    )
                                  ]
                                  spids: [5647]
                                )
                              ]
                              spids: [5642 5644 5663 -1]
                            )
                            (case_arm
                              pat_list: [{(Lit_Comma ",") (t)}]
                              action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:errmsg)
                                      op: Equal
                                      rhs: 
                                        {
                                          (DQ 
                                            (CommandSubPart
                                              command_list: 
                                                (CommandList
                                                  children: [
                                                    (C {(eval_gettext)} 
                                                      {
                                                        (DQ ("  Warn: ") 
                                                          (EscapedLiteralPart
                                                            token: <Lit_EscapedChar "\\$">
                                                          ) ("display_name doesn't contain commit ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (sha1_dst)
                                                        )
                                                      }
                                                    )
                                                  ]
                                                )
                                              left_token: <Left_CommandSub "$(">
                                              spids: [5673 5683]
                                            )
                                          )
                                        }
                                      spids: [5671]
                                    )
                                  ]
                                  spids: [5671]
                                )
                              ]
                              spids: [5666 5668 5687 -1]
                            )
                            (case_arm
                              pat_list: [{(t) (Lit_Comma ",") (t)}]
                              action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:errmsg)
                                      op: Equal
                                      rhs: 
                                        {
                                          (DQ 
                                            (CommandSubPart
                                              command_list: 
                                                (CommandList
                                                  children: [
                                                    (C {(eval_gettext)} 
                                                      {
                                                        (DQ ("  Warn: ") 
                                                          (EscapedLiteralPart
                                                            token: <Lit_EscapedChar "\\$">
                                                          ) ("display_name doesn't contain commits ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) 
                                                          ("sha1_src and ") (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) (sha1_dst)
                                                        )
                                                      }
                                                    )
                                                  ]
                                                )
                                              left_token: <Left_CommandSub "$(">
                                              spids: [5698 5710]
                                            )
                                          )
                                        }
                                      spids: [5696]
                                    )
                                  ]
                                  spids: [5696]
                                )
                              ]
                              spids: [5690 5693 5714 -1]
                            )
                            (case_arm
                              pat_list: [{(Lit_Other "*")}]
                              action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:errmsg)
                                      op: Equal
                                      rhs: {(SQ )}
                                      spids: [5721]
                                    )
                                  ]
                                  spids: [5721]
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:total_commits)
                                      op: Equal
                                      rhs: 
                                        {
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (If
                                                    arms: [
                                                      (if_arm
                                                        cond: [
                                                          (AndOr
                                                            children: [
                                                              (C {(test)} {($ VSub_Name "$mod_src")} 
                                                                {(Lit_Other "=")} {(160000)}
                                                              )
                                                              (C {(test)} {($ VSub_Name "$mod_dst")} 
                                                                {(Lit_Other "=")} {(160000)}
                                                              )
                                                            ]
                                                            op_id: Op_DAmp
                                                          )
                                                        ]
                                                        action: [
                                                          (Assignment
                                                            keyword: Assign_None
                                                            pairs: [
                                                              (assign_pair
                                                                lhs: (LhsName name:range)
                                                                op: Equal
                                                                rhs: 
                                                                  {
                                                                    (DQ ($ VSub_Name "$sha1_src") 
                                                                      (...) ($ VSub_Name "$sha1_dst")
                                                                    )
                                                                  }
                                                                spids: [5752]
                                                              )
                                                            ]
                                                            spids: [5752]
                                                          )
                                                        ]
                                                        spids: [-1 5749]
                                                      )
                                                      (if_arm
                                                        cond: [
                                                          (C {(test)} {($ VSub_Name "$mod_src")} 
                                                            {(Lit_Other "=")} {(160000)}
                                                          )
                                                        ]
                                                        action: [
                                                          (Assignment
                                                            keyword: Assign_None
                                                            pairs: [
                                                              (assign_pair
                                                                lhs: (LhsName name:range)
                                                                op: Equal
                                                                rhs: {($ VSub_Name "$sha1_src")}
                                                                spids: [5774]
                                                              )
                                                            ]
                                                            spids: [5774]
                                                          )
                                                        ]
                                                        spids: [5760 5771]
                                                      )
                                                    ]
                                                    else_action: [
                                                      (Assignment
                                                        keyword: Assign_None
                                                        pairs: [
                                                          (assign_pair
                                                            lhs: (LhsName name:range)
                                                            op: Equal
                                                            rhs: {($ VSub_Name "$sha1_dst")}
                                                            spids: [5781]
                                                          )
                                                        ]
                                                        spids: [5781]
                                                      )
                                                    ]
                                                    spids: [5778 5785]
                                                  )
                                                  (Pipeline
                                                    children: [
                                                      (SimpleCommand
                                                        words: [
                                                          {(git)}
                                                          {(rev-list)}
                                                          {(--first-parent)}
                                                          {($ VSub_Name "$range")}
                                                          {(--)}
                                                        ]
                                                        more_env: [
                                                          (env_pair
                                                            name: GIT_DIR
                                                            val: {(DQ ($ VSub_Name "$name") (/.git))}
                                                            spids: [5788]
                                                          )
                                                        ]
                                                      )
                                                      (C {(wc)} {(-l)})
                                                    ]
                                                    negated: False
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub "$(">
                                            spids: [5725 5813]
                                          )
                                        }
                                      spids: [5724]
                                    )
                                  ]
                                  spids: [5724]
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:total_commits)
                                      op: Equal
                                      rhs: 
                                        {
                                          (DQ (" (") 
                                            (ArithSubPart
                                              anode: 
                                                (ArithBinary
                                                  op_id: Arith_Plus
                                                  left: (ArithWord w:{($ VSub_Name "$total_commits")})
                                                  right: (ArithWord w:{(Lit_Digits 0)})
                                                )
                                              spids: [5819 5826]
                                            ) (")")
                                          )
                                        }
                                      spids: [5816]
                                    )
                                  ]
                                  spids: [5816]
                                )
                              ]
                              spids: [5717 5718 5831 -1]
                            )
                          ]
                          spids: [5631 5639 5834]
                        )
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:sha1_abbr_src)
                              op: Equal
                              rhs: 
                                {
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (Pipeline
                                            children: [
                                              (C {(echo)} {($ VSub_Name "$sha1_src")})
                                              (C {(cut)} {(-c1-7)})
                                            ]
                                            negated: False
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [5839 5849]
                                  )
                                }
                              spids: [5838]
                            )
                          ]
                          spids: [5838]
                        )
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:sha1_abbr_dst)
                              op: Equal
                              rhs: 
                                {
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (Pipeline
                                            children: [
                                              (C {(echo)} {($ VSub_Name "$sha1_dst")})
                                              (C {(cut)} {(-c1-7)})
                                            ]
                                            negated: False
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [5853 5863]
                                  )
                                }
                              spids: [5852]
                            )
                          ]
                          spids: [5852]
                        )
                        (If
                          arms: [
                            (if_arm
                              cond: [(C {(test)} {($ VSub_Name "$status")} {(Lit_Other "=")} {(T)})]
                              action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:blob)
                                      op: Equal
                                      rhs: 
                                        {
                                          (DQ 
                                            (CommandSubPart
                                              command_list: 
                                                (CommandList
                                                  children: [(C {(gettext)} {(DQ (blob))})]
                                                )
                                              left_token: <Left_CommandSub "$(">
                                              spids: [5882 5888]
                                            )
                                          )
                                        }
                                      spids: [5880]
                                    )
                                  ]
                                  spids: [5880]
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:submodule)
                                      op: Equal
                                      rhs: 
                                        {
                                          (DQ 
                                            (CommandSubPart
                                              command_list: 
                                                (CommandList
                                                  children: [(C {(gettext)} {(DQ (submodule))})]
                                                )
                                              left_token: <Left_CommandSub "$(">
                                              spids: [5894 5900]
                                            )
                                          )
                                        }
                                      spids: [5892]
                                    )
                                  ]
                                  spids: [5892]
                                )
                                (If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (C {(test)} {($ VSub_Name "$mod_dst")} {(Lit_Other "=")} 
                                          {(160000)}
                                        )
                                      ]
                                      action: [
                                        (C {(echo)} 
                                          {
                                            (DQ ("* ") ($ VSub_Name "$display_name") (" ") 
                                              ($ VSub_Name "$sha1_abbr_src") ("(") ($ VSub_Name "$blob") (")->") ($ VSub_Name "$sha1_abbr_dst") ("(") ($ VSub_Name "$submodule") (")") 
                                              ($ VSub_Name "$total_commits") (":")
                                            )
                                          }
                                        )
                                      ]
                                      spids: [-1 5915]
                                    )
                                  ]
                                  else_action: [
                                    (C {(echo)} 
                                      {
                                        (DQ ("* ") ($ VSub_Name "$display_name") (" ") 
                                          ($ VSub_Name "$sha1_abbr_src") ("(") ($ VSub_Name "$submodule") (")->") ($ VSub_Name "$sha1_abbr_dst") ("(") ($ VSub_Name "$blob") (")") 
                                          ($ VSub_Name "$total_commits") (":")
                                        )
                                      }
                                    )
                                  ]
                                  spids: [5937 5959]
                                )
                              ]
                              spids: [-1 5877]
                            )
                          ]
                          else_action: [
                            (C {(echo)} 
                              {
                                (DQ ("* ") ($ VSub_Name "$display_name") (" ") 
                                  ($ VSub_Name "$sha1_abbr_src") (...) ($ VSub_Name "$sha1_abbr_dst") ($ VSub_Name "$total_commits") (":")
                                )
                              }
                            )
                          ]
                          spids: [5962 5979]
                        )
                        (If
                          arms: [
                            (if_arm
                              cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name "$errmsg"))})]
                              action: [
                                (AndOr
                                  children: [
                                    (C {(test)} {($ VSub_Name "$mod_dst")} {(Lit_Other "=")} {(160000)})
                                    (C {(echo)} {(DQ ($ VSub_Name "$errmsg"))})
                                  ]
                                  op_id: Op_DAmp
                                )
                              ]
                              spids: [-1 5993]
                            )
                          ]
                          else_action: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [
                                    (AndOr
                                      children: [
                                        (C {(test)} {($ VSub_Name "$mod_src")} {(Lit_Other "=")} 
                                          {(160000)}
                                        )
                                        (C {(test)} {($ VSub_Name "$mod_dst")} {(Lit_Other "=")} 
                                          {(160000)}
                                        )
                                      ]
                                      op_id: Op_DAmp
                                    )
                                  ]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:limit)
                                          op: Equal
                                          rhs: {(SQ )}
                                          spids: [6048]
                                        )
                                      ]
                                      spids: [6048]
                                    )
                                    (AndOr
                                      children: [
                                        (C {(test)} {($ VSub_Name "$summary_limit")} {(-gt)} {(0)})
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:limit)
                                              op: Equal
                                              rhs: {(DQ (-) ($ VSub_Name "$summary_limit"))}
                                              spids: [6061]
                                            )
                                          ]
                                          spids: [6061]
                                        )
                                      ]
                                      op_id: Op_DAmp
                                    )
                                    (SimpleCommand
                                      words: [
                                        {(git)}
                                        {(log)}
                                        {($ VSub_Name "$limit")}
                                        {(--pretty) (Lit_Other "=") (SQ <"format:  %m %s">)}
                                        {(--first-parent)}
                                        {($ VSub_Name "$sha1_src") (...) ($ VSub_Name "$sha1_dst")}
                                      ]
                                      more_env: [
                                        (env_pair
                                          name: GIT_DIR
                                          val: {(DQ ($ VSub_Name "$name") (/.git))}
                                          spids: [6068]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [-1 6045]
                                )
                                (if_arm
                                  cond: [
                                    (C {(test)} {($ VSub_Name "$mod_dst")} {(Lit_Other "=")} {(160000)})
                                  ]
                                  action: [
                                    (SimpleCommand
                                      words: [
                                        {(git)}
                                        {(log)}
                                        {(--pretty) (Lit_Other "=") (SQ <"format:  > %s">)}
                                        {(-1)}
                                        {($ VSub_Name "$sha1_dst")}
                                      ]
                                      more_env: [
                                        (env_pair
                                          name: GIT_DIR
                                          val: {(DQ ($ VSub_Name "$name") (/.git))}
                                          spids: [6111]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [6097 6108]
                                )
                              ]
                              else_action: [
                                (SimpleCommand
                                  words: [
                                    {(git)}
                                    {(log)}
                                    {(--pretty) (Lit_Other "=") (SQ <"format:  < %s">)}
                                    {(-1)}
                                    {($ VSub_Name "$sha1_src")}
                                  ]
                                  more_env: [
                                    (env_pair
                                      name: GIT_DIR
                                      val: {(DQ ($ VSub_Name "$name") (/.git))}
                                      spids: [6137]
                                    )
                                  ]
                                )
                              ]
                              spids: [6134 6160]
                            )
                            (C {(echo)})
                          ]
                          spids: [6021 6166]
                        )
                        (C {(echo)})
                      ]
                      spids: [5396 6172]
                    )
                )
              ]
              negated: False
            )
          ]
          spids: [4706]
        )
      spids: [4702 4705]
    )
    (FuncDef
      name: cmd_status
      body: 
        (BraceGroup
          children: [
            (While
              cond: [(C {(test)} {($ VSub_Pound "$#")} {(-ne)} {(0)})]
              body: 
                (DoGroup
                  children: [
                    (Case
                      to_match: {(DQ ($ VSub_Number "$1"))}
                      arms: [
                        (case_arm
                          pat_list: [{(-q)} {(--quiet)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:GIT_QUIET)
                                  op: Equal
                                  rhs: {(1)}
                                  spids: [6246]
                                )
                              ]
                              spids: [6246]
                            )
                          ]
                          spids: [6240 6243 6250 -1]
                        )
                        (case_arm
                          pat_list: [{(--cached)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:cached)
                                  op: Equal
                                  rhs: {(1)}
                                  spids: [6257]
                                )
                              ]
                              spids: [6257]
                            )
                          ]
                          spids: [6253 6254 6261 -1]
                        )
                        (case_arm
                          pat_list: [{(--recursive)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:recursive)
                                  op: Equal
                                  rhs: {(1)}
                                  spids: [6268]
                                )
                              ]
                              spids: [6268]
                            )
                          ]
                          spids: [6264 6265 6272 -1]
                        )
                        (case_arm
                          pat_list: [{(--)}]
                          action: [(C {(shift)}) (ControlFlow token:<ControlFlow_Break break>)]
                          spids: [6275 6276 6285 -1]
                        )
                        (case_arm
                          pat_list: [{(-) (Lit_Other "*")}]
                          action: [(C {(usage)})]
                          spids: [6288 6290 6296 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [(ControlFlow token:<ControlFlow_Break break>)]
                          spids: [6299 6300 6306 -1]
                        )
                      ]
                      spids: [6231 6237 6309]
                    )
                    (C {(shift)})
                  ]
                  spids: [6228 6315]
                )
            )
            (Pipeline
              children: [
                (BraceGroup
                  children: [
                    (AndOr
                      children: [
                        (C {(git)} {(submodule--helper)} {(list)} {(--prefix)} 
                          {(DQ ($ VSub_Name "$wt_prefix"))} {(DQ ($ VSub_At "$@"))}
                        )
                        (C {(echo)} {(DQ ("#unmatched"))} {($ VSub_QMark "$?")})
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  spids: [6319]
                )
                (While
                  cond: [(C {(read)} {(mode)} {(sha1)} {(stage)} {(sm_path)})]
                  body: 
                    (DoGroup
                      children: [
                        (C {(die_if_unmatched)} {(DQ ($ VSub_Name "$mode"))} {(DQ ($ VSub_Name "$sha1"))})
                        (AndOr
                          children: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:name)
                                  op: Equal
                                  rhs: 
                                    {
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (C {(git)} {(submodule--helper)} {(name)} 
                                                {(DQ ($ VSub_Name "$sm_path"))}
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub "$(">
                                        spids: [6383 6393]
                                      )
                                    }
                                  spids: [6382]
                                )
                              ]
                              spids: [6382]
                            )
                            (C {(exit)})
                          ]
                          op_id: Op_DPipe
                        )
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:url)
                              op: Equal
                              rhs: 
                                {
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(git)} {(config)} 
                                            {(submodule.) (DQ ($ VSub_Name "$name")) (.url)}
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [6401 6411]
                                  )
                                }
                              spids: [6400]
                            )
                          ]
                          spids: [6400]
                        )
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:displaypath)
                              op: Equal
                              rhs: 
                                {
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(git)} {(submodule--helper)} {(relative-path)} 
                                            {(DQ ($ VSub_Name "$prefix") ($ VSub_Name "$sm_path"))} {(DQ ($ VSub_Name "$wt_prefix"))}
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [6415 6430]
                                  )
                                }
                              spids: [6414]
                            )
                          ]
                          spids: [6414]
                        )
                        (If
                          arms: [
                            (if_arm
                              cond: [(C {(test)} {(DQ ($ VSub_Name "$stage"))} {(Lit_Other "=")} {(U)})]
                              action: [
                                (C {(say)} 
                                  {(DQ (U) ($ VSub_Name "$sha1") (" ") ($ VSub_Name "$displaypath"))}
                                )
                                (ControlFlow
                                  token: <ControlFlow_Continue continue>
                                )
                              ]
                              spids: [-1 6446]
                            )
                          ]
                          spids: [-1 6462]
                        )
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (AndOr
                                  children: [
                                    (C {(test)} {(-z)} {(DQ ($ VSub_Name "$url"))})
                                    (BraceGroup
                                      children: [
                                        (AndOr
                                          children: [
                                            (Pipeline
                                              children: [
                                                (C {(test)} {(-d)} 
                                                  {(DQ ($ VSub_Name "$sm_path")) (/.git)}
                                                )
                                              ]
                                              negated: True
                                            )
                                            (Pipeline
                                              children: [
                                                (C {(test)} {(-f)} 
                                                  {(DQ ($ VSub_Name "$sm_path")) (/.git)}
                                                )
                                              ]
                                              negated: True
                                            )
                                          ]
                                          op_id: Op_DAmp
                                        )
                                      ]
                                      spids: [6478]
                                    )
                                  ]
                                  op_id: Op_DPipe
                                )
                              ]
                              action: [
                                (C {(say)} 
                                  {(DQ (-) ($ VSub_Name "$sha1") (" ") ($ VSub_Name "$displaypath"))}
                                )
                                (Sentence
                                  child: (ControlFlow token:<ControlFlow_Continue continue>)
                                  terminator: <Op_Semi ";">
                                )
                              ]
                              spids: [-1 6510]
                            )
                          ]
                          spids: [-1 6527]
                        )
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (C {(git)} {(diff-files)} 
                                  {(--ignore-submodules) (Lit_Other "=") (dirty)} {(--quiet)} {(--)} {(DQ ($ VSub_Name "$sm_path"))}
                                )
                              ]
                              action: [
                                (C {(set_name_rev)} {(DQ ($ VSub_Name "$sm_path"))} 
                                  {(DQ ($ VSub_Name "$sha1"))}
                                )
                                (C {(say)} 
                                  {
                                    (DQ (" ") ($ VSub_Name "$sha1") (" ") ($ VSub_Name "$displaypath") 
                                      ($ VSub_Name "$revname")
                                    )
                                  }
                                )
                              ]
                              spids: [-1 6549]
                            )
                          ]
                          else_action: [
                            (If
                              arms: [
                                (if_arm
                                  cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$cached"))})]
                                  action: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:sha1)
                                          op: Equal
                                          rhs: 
                                            {
                                              (CommandSubPart
                                                command_list: 
                                                  (CommandList
                                                    children: [
                                                      (Sentence
                                                        child: (C {(sanitize_submodule_env)})
                                                        terminator: <Op_Semi ";">
                                                      )
                                                      (AndOr
                                                        children: [
                                                          (C {(cd)} {(DQ ($ VSub_Name "$sm_path"))})
                                                          (C {(git)} {(rev-parse)} {(--verify)} {(HEAD)})
                                                        ]
                                                        op_id: Op_DAmp
                                                      )
                                                    ]
                                                  )
                                                left_token: <Left_CommandSub "$(">
                                                spids: [6592 6611]
                                              )
                                            }
                                          spids: [6591]
                                        )
                                      ]
                                      spids: [6591]
                                    )
                                  ]
                                  spids: [-1 6588]
                                )
                              ]
                              spids: [-1 6614]
                            )
                            (C {(set_name_rev)} {(DQ ($ VSub_Name "$sm_path"))} 
                              {(DQ ($ VSub_Name "$sha1"))}
                            )
                            (C {(say)} 
                              {
                                (DQ ("+") ($ VSub_Name "$sha1") (" ") ($ VSub_Name "$displaypath") 
                                  ($ VSub_Name "$revname")
                                )
                              }
                            )
                          ]
                          spids: [6574 6639]
                        )
                        (If
                          arms: [
                            (if_arm
                              cond: [(C {(test)} {(-n)} {(DQ ($ VSub_Name "$recursive"))})]
                              action: [
                                (AndOr
                                  children: [
                                    (Subshell
                                      child: 
                                        (CommandList
                                          children: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:prefix)
                                                  op: Equal
                                                  rhs: {(DQ ($ VSub_Name "$displaypath") (/))}
                                                  spids: [6660]
                                                )
                                              ]
                                              spids: [6660]
                                            )
                                            (C {(sanitize_submodule_env)})
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:wt_prefix)
                                                  op: Equal
                                                  rhs: {(SQ )}
                                                  spids: [6670]
                                                )
                                              ]
                                              spids: [6670]
                                            )
                                            (AndOr
                                              children: [
                                                (C {(cd)} {(DQ ($ VSub_Name "$sm_path"))})
                                                (C {(eval)} {(cmd_status)})
                                              ]
                                              op_id: Op_DAmp
                                            )
                                          ]
                                        )
                                      spids: [6657 6687]
                                    )
                                    (C {(die)} 
                                      {
                                        (DQ 
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (C {(eval_gettext)} 
                                                    {
                                                      (DQ ("Failed to recurse into submodule path '") 
                                                        (EscapedLiteralPart
                                                          token: <Lit_EscapedChar "\\$">
                                                        ) ("sm_path'")
                                                      )
                                                    }
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub "$(">
                                            spids: [6695 6703]
                                          )
                                        )
                                      }
                                    )
                                  ]
                                  op_id: Op_DPipe
                                )
                              ]
                              spids: [-1 6654]
                            )
                          ]
                          spids: [-1 6707]
                        )
                      ]
                      spids: [6368 6710]
                    )
                )
              ]
              negated: False
            )
          ]
          spids: [6210]
        )
      spids: [6206 6209]
    )
    (FuncDef
      name: cmd_sync
      body: 
        (BraceGroup
          children: [
            (While
              cond: [(C {(test)} {($ VSub_Pound "$#")} {(-ne)} {(0)})]
              body: 
                (DoGroup
                  children: [
                    (Case
                      to_match: {(DQ ($ VSub_Number "$1"))}
                      arms: [
                        (case_arm
                          pat_list: [{(-q)} {(--quiet)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:GIT_QUIET)
                                  op: Equal
                                  rhs: {(1)}
                                  spids: [6765]
                                )
                              ]
                              spids: [6765]
                            )
                            (C {(shift)})
                          ]
                          spids: [6759 6762 6772 -1]
                        )
                        (case_arm
                          pat_list: [{(--recursive)}]
                          action: [
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:recursive)
                                  op: Equal
                                  rhs: {(1)}
                                  spids: [6779]
                                )
                              ]
                              spids: [6779]
                            )
                            (C {(shift)})
                          ]
                          spids: [6775 6776 6786 -1]
                        )
                        (case_arm
                          pat_list: [{(--)}]
                          action: [(C {(shift)}) (ControlFlow token:<ControlFlow_Break break>)]
                          spids: [6789 6790 6799 -1]
                        )
                        (case_arm
                          pat_list: [{(-) (Lit_Other "*")}]
                          action: [(C {(usage)})]
                          spids: [6802 6804 6810 -1]
                        )
                        (case_arm
                          pat_list: [{(Lit_Other "*")}]
                          action: [(ControlFlow token:<ControlFlow_Break break>)]
                          spids: [6813 6814 6820 -1]
                        )
                      ]
                      spids: [6750 6756 6823]
                    )
                  ]
                  spids: [6747 6826]
                )
            )
            (C {(cd_to_toplevel)})
            (Pipeline
              children: [
                (BraceGroup
                  children: [
                    (AndOr
                      children: [
                        (C {(git)} {(submodule--helper)} {(list)} {(--prefix)} 
                          {(DQ ($ VSub_Name "$wt_prefix"))} {(DQ ($ VSub_At "$@"))}
                        )
                        (C {(echo)} {(DQ ("#unmatched"))} {($ VSub_QMark "$?")})
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  spids: [6832]
                )
                (While
                  cond: [(C {(read)} {(mode)} {(sha1)} {(stage)} {(sm_path)})]
                  body: 
                    (DoGroup
                      children: [
                        (C {(die_if_unmatched)} {(DQ ($ VSub_Name "$mode"))} {(DQ ($ VSub_Name "$sha1"))})
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:name)
                              op: Equal
                              rhs: 
                                {
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(git)} {(submodule--helper)} {(name)} 
                                            {(DQ ($ VSub_Name "$sm_path"))}
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [6896 6906]
                                  )
                                }
                              spids: [6895]
                            )
                          ]
                          spids: [6895]
                        )
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:url)
                              op: Equal
                              rhs: 
                                {
                                  (CommandSubPart
                                    command_list: 
                                      (CommandList
                                        children: [
                                          (C {(git)} {(config)} {(-f)} {(.gitmodules)} {(--get)} 
                                            {(submodule.) (DQ ($ VSub_Name "$name")) (.url)}
                                          )
                                        ]
                                      )
                                    left_token: <Left_CommandSub "$(">
                                    spids: [6910 6926]
                                  )
                                }
                              spids: [6909]
                            )
                          ]
                          spids: [6909]
                        )
                        (Case
                          to_match: {(DQ ($ VSub_Name "$url"))}
                          arms: [
                            (case_arm
                              pat_list: [{(./) (Lit_Other "*")} {(../) (Lit_Other "*")}]
                              action: [
                                (AndOr
                                  children: [
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:up_path)
                                          op: Equal
                                          rhs: 
                                            {
                                              (DQ 
                                                (CommandSubPart
                                                  command_list: 
                                                    (CommandList
                                                      children: [
                                                        (Pipeline
                                                          children: [
                                                            (C {(printf)} {(SQ <"%s\\n">)} 
                                                              {(DQ ($ VSub_Name "$sm_path"))}
                                                            )
                                                            (C {(sed)} {(DQ ("s/[^/][^/]*/../g"))})
                                                          ]
                                                          negated: False
                                                        )
                                                      ]
                                                    )
                                                  left_token: <Left_CommandSub "$(">
                                                  spids: [6961 6979]
                                                )
                                              )
                                            }
                                          spids: [6959]
                                        )
                                      ]
                                      spids: [6959]
                                    )
                                    (AndOr
                                      children: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:up_path)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (BracedVarSub
                                                    token: <VSub_Name up_path>
                                                    suffix_op: 
                                                      (StringUnary
                                                        op_id: VOp1_Percent
                                                        arg_word: {(Lit_Slash /)}
                                                      )
                                                    spids: [6990 6994]
                                                  ) (/)
                                                }
                                              spids: [6989]
                                            )
                                          ]
                                          spids: [6989]
                                        )
                                        (AndOr
                                          children: [
                                            (Assignment
                                              keyword: Assign_None
                                              pairs: [
                                                (assign_pair
                                                  lhs: (LhsName name:sub_origin_url)
                                                  op: Equal
                                                  rhs: 
                                                    {
                                                      (CommandSubPart
                                                        command_list: 
                                                          (CommandList
                                                            children: [
                                                              (C {(git)} {(submodule--helper)} 
                                                                {(resolve-relative-url)} {(DQ ($ VSub_Name "$url"))} {(DQ ($ VSub_Name "$up_path"))}
                                                              )
                                                            ]
                                                          )
                                                        left_token: <Left_CommandSub "$(">
                                                        spids: [7005 7019]
                                                      )
                                                    }
                                                  spids: [7004]
                                                )
                                              ]
                                              spids: [7004]
                                            )
                                            (AndOr
                                              children: [
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:super_config_url)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (CommandSubPart
                                                            command_list: 
                                                              (CommandList
                                                                children: [
                                                                  (C {(git)} {(submodule--helper)} 
                                                                    {(resolve-relative-url)} {(DQ ($ VSub_Name "$url"))}
                                                                  )
                                                                ]
                                                              )
                                                            left_token: <Left_CommandSub "$(">
                                                            spids: [7029 7039]
                                                          )
                                                        }
                                                      spids: [7028]
                                                    )
                                                  ]
                                                  spids: [7028]
                                                )
                                                (C {(exit)})
                                              ]
                                              op_id: Op_DPipe
                                            )
                                          ]
                                          op_id: Op_DAmp
                                        )
                                      ]
                                      op_id: Op_DAmp
                                    )
                                  ]
                                  op_id: Op_DAmp
                                )
                              ]
                              spids: [6943 6948 7046 -1]
                            )
                            (case_arm
                              pat_list: [{(Lit_Other "*")}]
                              action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:sub_origin_url)
                                      op: Equal
                                      rhs: {(DQ ($ VSub_Name "$url"))}
                                      spids: [7053]
                                    )
                                  ]
                                  spids: [7053]
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:super_config_url)
                                      op: Equal
                                      rhs: {(DQ ($ VSub_Name "$url"))}
                                      spids: [7059]
                                    )
                                  ]
                                  spids: [7059]
                                )
                              ]
                              spids: [7049 7050 7065 -1]
                            )
                          ]
                          spids: [6934 6940 7068]
                        )
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (SimpleCommand
                                  words: [
                                    {(git)}
                                    {(config)}
                                    {(DQ (submodule.) ($ VSub_Name "$name") (.url))}
                                  ]
                                  redirects: [
                                    (Redir
                                      op_id: Redir_Great
                                      fd: -1
                                      arg_word: {(/dev/null)}
                                      spids: [7084]
                                    )
                                    (Redir
                                      op_id: Redir_Great
                                      fd: 2
                                      arg_word: {(/dev/null)}
                                      spids: [7087]
                                    )
                                  ]
                                )
                              ]
                              action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:displaypath)
                                      op: Equal
                                      rhs: 
                                        {
                                          (CommandSubPart
                                            command_list: 
                                              (CommandList
                                                children: [
                                                  (C {(git)} {(submodule--helper)} {(relative-path)} 
                                                    {
                                                      (DQ ($ VSub_Name "$prefix") 
                                                        ($ VSub_Name "$sm_path")
                                                      )
                                                    } {(DQ ($ VSub_Name "$wt_prefix"))}
                                                  )
                                                ]
                                              )
                                            left_token: <Left_CommandSub "$(">
                                            spids: [7095 7110]
                                          )
                                        }
                                      spids: [7094]
                                    )
                                  ]
                                  spids: [7094]
                                )
                                (C {(say)} 
                                  {
                                    (DQ 
                                      (CommandSubPart
                                        command_list: 
                                          (CommandList
                                            children: [
                                              (C {(eval_gettext)} 
                                                {
                                                  (DQ ("Synchronizing submodule url for '") 
                                                    (EscapedLiteralPart
                                                      token: <Lit_EscapedChar "\\$">
                                                    ) ("displaypath'")
                                                  )
                                                }
                                              )
                                            ]
                                          )
                                        left_token: <Left_CommandSub "$(">
                                        spids: [7116 7124]
                                      )
                                    )
                                  }
                                )
                                (C {(git)} {(config)} {(submodule.) (DQ ($ VSub_Name "$name")) (.url)} 
                                  {(DQ ($ VSub_Name "$super_config_url"))}
                                )
                                (If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (C {(test)} {(-e)} {(DQ ($ VSub_Name "$sm_path")) (/.git)})
                                      ]
                                      action: [
                                        (Subshell
                                          child: 
                                            (CommandList
                                              children: [
                                                (C {(sanitize_submodule_env)})
                                                (C {(cd)} {(DQ ($ VSub_Name "$sm_path"))})
                                                (Assignment
                                                  keyword: Assign_None
                                                  pairs: [
                                                    (assign_pair
                                                      lhs: (LhsName name:remote)
                                                      op: Equal
                                                      rhs: 
                                                        {
                                                          (CommandSubPart
                                                            command_list: 
                                                              (CommandList
                                                                children: [(C {(get_default_remote)})]
                                                              )
                                                            left_token: <Left_CommandSub "$(">
                                                            spids: [7173 7175]
                                                          )
                                                        }
                                                      spids: [7172]
                                                    )
                                                  ]
                                                  spids: [7172]
                                                )
                                                (C {(git)} {(config)} 
                                                  {(remote.) (DQ ($ VSub_Name "$remote")) (.url)} {(DQ ($ VSub_Name "$sub_origin_url"))}
                                                )
                                                (If
                                                  arms: [
                                                    (if_arm
                                                      cond: [
                                                        (C {(test)} {(-n)} 
                                                          {(DQ ($ VSub_Name "$recursive"))}
                                                        )
                                                      ]
                                                      action: [
                                                        (Assignment
                                                          keyword: Assign_None
                                                          pairs: [
                                                            (assign_pair
                                                              lhs: (LhsName name:prefix)
                                                              op: Equal
                                                              rhs: 
                                                                {
                                                                  (DQ ($ VSub_Name "$prefix") 
                                                                    ($ VSub_Name "$sm_path") (/)
                                                                  )
                                                                }
                                                              spids: [7208]
                                                            )
                                                          ]
                                                          spids: [7208]
                                                        )
                                                        (C {(eval)} {(cmd_sync)})
                                                      ]
                                                      spids: [-1 7205]
                                                    )
                                                  ]
                                                  spids: [-1 7221]
                                                )
                                              ]
                                            )
                                          spids: [7159 7224]
                                        )
                                      ]
                                      spids: [-1 7156]
                                    )
                                  ]
                                  spids: [-1 7227]
                                )
                              ]
                              spids: [-1 7091]
                            )
                          ]
                          spids: [-1 7230]
                        )
                      ]
                      spids: [6881 7233]
                    )
                )
              ]
              negated: False
            )
          ]
          spids: [6733]
        )
      spids: [6729 6732]
    )
    (While
      cond: [
        (AndOr
          children: [
            (C {(test)} {($ VSub_Pound "$#")} {(KW_Bang "!") (Lit_Other "=")} {(0)})
            (C {(test)} {(-z)} {(DQ ($ VSub_Name "$command"))})
          ]
          op_id: Op_DAmp
        )
      ]
      body: 
        (DoGroup
          children: [
            (Case
              to_match: {(DQ ($ VSub_Number "$1"))}
              arms: [
                (case_arm
                  pat_list: [
                    {(add)}
                    {(foreach)}
                    {(init)}
                    {(deinit)}
                    {(update)}
                    {(status)}
                    {(summary)}
                    {(sync)}
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:command)
                          op: Equal
                          rhs: {($ VSub_Number "$1")}
                          spids: [7319]
                        )
                      ]
                      spids: [7319]
                    )
                  ]
                  spids: [7287 7316 7323 -1]
                )
                (case_arm
                  pat_list: [{(-q)} {(--quiet)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:GIT_QUIET)
                          op: Equal
                          rhs: {(1)}
                          spids: [7332]
                        )
                      ]
                      spids: [7332]
                    )
                  ]
                  spids: [7326 7329 7336 -1]
                )
                (case_arm
                  pat_list: [{(-b)} {(--branch)}]
                  action: [
                    (Case
                      to_match: {(DQ ($ VSub_Number "$2"))}
                      arms: [
                        (case_arm
                          pat_list: [{(SQ )}]
                          action: [(C {(usage)})]
                          spids: [-1 7356 7362 -1]
                        )
                      ]
                      spids: [7345 7351 7365]
                    )
                    (Sentence
                      child: 
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:branch)
                              op: Equal
                              rhs: {(DQ ($ VSub_Number "$2"))}
                              spids: [7368]
                            )
                          ]
                          spids: [7368]
                        )
                      terminator: <Op_Semi ";">
                    )
                    (C {(shift)})
                  ]
                  spids: [7339 7342 7377 -1]
                )
                (case_arm
                  pat_list: [{(--cached)}]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:cached)
                          op: Equal
                          rhs: {(DQ ($ VSub_Number "$1"))}
                          spids: [7384]
                        )
                      ]
                      spids: [7384]
                    )
                  ]
                  spids: [7380 7381 7390 -1]
                )
                (case_arm
                  pat_list: [{(--)}]
                  action: [(ControlFlow token:<ControlFlow_Break break>)]
                  spids: [7393 7394 7400 -1]
                )
                (case_arm
                  pat_list: [{(-) (Lit_Other "*")}]
                  action: [(C {(usage)})]
                  spids: [7403 7405 7411 -1]
                )
                (case_arm
                  pat_list: [{(Lit_Other "*")}]
                  action: [(ControlFlow token:<ControlFlow_Break break>)]
                  spids: [7414 7415 7421 -1]
                )
              ]
              spids: [7278 7284 7424]
            )
            (C {(shift)})
          ]
          spids: [7275 7429]
        )
    )
    (If
      arms: [
        (if_arm
          cond: [(C {(test)} {(-z)} {(DQ ($ VSub_Name "$command"))})]
          action: [
            (If
              arms: [
                (if_arm
                  cond: [(C {(test)} {($ VSub_Pound "$#")} {(Lit_Other "=")} {(0)})]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:command)
                          op: Equal
                          rhs: {(status)}
                          spids: [7462]
                        )
                      ]
                      spids: [7462]
                    )
                  ]
                  spids: [-1 7459]
                )
              ]
              else_action: [(C {(usage)})]
              spids: [7466 7472]
            )
          ]
          spids: [-1 7445]
        )
      ]
      spids: [-1 7474]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (AndOr
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$branch"))})
                (C {(test)} {(DQ ($ VSub_Name "$command"))} {(KW_Bang "!") (Lit_Other "=")} {(add)})
              ]
              op_id: Op_DAmp
            )
          ]
          action: [(C {(usage)})]
          spids: [-1 7503]
        )
      ]
      spids: [-1 7508]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (AndOr
              children: [
                (C {(test)} {(-n)} {(DQ ($ VSub_Name "$cached"))})
                (AndOr
                  children: [
                    (C {(test)} {(DQ ($ VSub_Name "$command"))} {(KW_Bang "!") (Lit_Other "=")} 
                      {(status)}
                    )
                    (C {(test)} {(DQ ($ VSub_Name "$command"))} {(KW_Bang "!") (Lit_Other "=")} 
                      {(summary)}
                    )
                  ]
                  op_id: Op_DAmp
                )
              ]
              op_id: Op_DAmp
            )
          ]
          action: [(C {(usage)})]
          spids: [-1 7550]
        )
      ]
      spids: [-1 7555]
    )
    (C {(DQ (cmd_) ($ VSub_Name "$command"))} {(DQ ($ VSub_At "$@"))})
  ]
)