(command.AndOr
  ops: [Id.Op_DAmp]
  children: [
    (command.ShFunction
      name: _svk
      body: 
        (command.BraceGroup
          children: [
            (C {(local)} {(cur)} {(prev)} {(words)} {(cword)})
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (C {(_init_completion)})
                (command.ControlFlow
                  token: (Token id:Id.ControlFlow_Return val:return span_id:26)
                )
              ]
            )
            (C {(local)} {(commands)} {(options)} {(command)})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:commands)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (SQ 
                        (Token
                          id: Id.Lit_Chars
                          val: 'add admin annotate ann blame praise cat checkout co cleanup\n'
                          span_id: 42
                        ) 
                        (Token
                          id: Id.Lit_Chars
                          val: 
'        cmerge cm commit ci copy cp delete del remove rm depotmap depot\n'
                          span_id: 43
                        ) 
                        (Token
                          id: Id.Lit_Chars
                          val: 
'        describe desc diff di help h ? import info list ls log merge mirror mi\n'
                          span_id: 44
                        ) 
                        (Token
                          id: Id.Lit_Chars
                          val: 
'        mkdir move mv ren rename patch propdel pd pdel propedit pe pedit\n'
                          span_id: 45
                        ) 
                        (Token
                          id: Id.Lit_Chars
                          val: 
'        propget pg pget proplist pl plist propset ps pset pull push resolved\n'
                          span_id: 46
                        ) 
                        (Token
                          id: Id.Lit_Chars
                          val: 
'        revert smerge sm status st stat switch sw sync sy update up verify'
                          span_id: 47
                        )
                      )
                    }
                  spids: [40]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.Binary
                              op_id: Id.BoolBinary_eq
                              left: {($ Id.VSub_DollarName '$cword')}
                              right: {(1)}
                            )
                        )
                      terminator: (Token id:Id.Op_Semi val:';' span_id:64)
                    )
                  ]
                  action: [
                    (command.If
                      arms: [
                        (if_arm
                          cond: [
                            (command.Sentence
                              child: 
                                (command.DBracket
                                  expr: 
                                    (bool_expr.Binary
                                      op_id: Id.BoolBinary_GlobDEqual
                                      left: {(DQ ($ Id.VSub_DollarName '$cur'))}
                                      right: {(-) (Id.Lit_Other '*')}
                                    )
                                )
                              terminator: (Token id:Id.Op_Semi val:';' span_id:83)
                            )
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: (Token id:Id.Op_LParen val:'(' span_id:89)
                                        words: [
                                          {
                                            (command_sub
                                              left_token: 
                                                (Token
                                                  id: Id.Left_DollarParen
                                                  val: '$('
                                                  span_id: 91
                                                )
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (C {(compgen)} {(-W)} 
                                                      {
                                                        (SQ 
                                                          (Token
                                                            id: Id.Lit_Chars
                                                            val: --version
                                                            span_id: 98
                                                          )
                                                        )
                                                      } {(--)} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                    )
                                                  ]
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [88]
                                )
                              ]
                            )
                          ]
                          spids: [69 85]
                        )
                      ]
                      else_action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (sh_array_literal
                                    left: (Token id:Id.Op_LParen val:'(' span_id:116)
                                    words: [
                                      {
                                        (command_sub
                                          left_token: 
                                            (Token
                                              id: Id.Left_DollarParen
                                              val: '$('
                                              span_id: 118
                                            )
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} 
                                                  {(DQ ($ Id.VSub_DollarName '$commands'))} {(--)} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [115]
                            )
                          ]
                        )
                      ]
                    )
                  ]
                  spids: [52 66]
                )
              ]
              else_action: [
                (command.Case
                  to_match: {($ Id.VSub_DollarName '$prev')}
                  arms: [
                    (case_arm
                      pat_list: [{(-F)} {(--file)} {(--targets)}]
                      action: [
                        (C {(_filedir)})
                        (command.ControlFlow
                          token: (Token id:Id.ControlFlow_Return val:return span_id:163)
                          arg_word: {(0)}
                        )
                      ]
                      spids: [152 157 168 -1]
                    )
                    (case_arm
                      pat_list: [{(--encoding)}]
                      action: [
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (sh_array_literal
                                    left: (Token id:Id.Op_LParen val:'(' span_id:176)
                                    words: [
                                      {
                                        (command_sub
                                          left_token: 
                                            (Token
                                              id: Id.Left_DollarParen
                                              val: '$('
                                              span_id: 178
                                            )
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} 
                                                  {
                                                    (SQ 
                                                      (Token
                                                        id: Id.Lit_Chars
                                                        val: '$( iconv --list | sed -e "s@//@@;" )'
                                                        span_id: 187
                                                      )
                                                    )
                                                  } {(--)} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [175]
                            )
                          ]
                        )
                        (command.ControlFlow
                          token: (Token id:Id.ControlFlow_Return val:return span_id:201)
                          arg_word: {(0)}
                        )
                      ]
                      spids: [171 172 206 -1]
                    )
                  ]
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:command)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (braced_var_sub
                            token: (Token id:Id.VSub_Name val:words span_id:215)
                            bracket_op: 
                              (bracket_op.ArrayIndex
                                expr: (arith_expr.ArithWord w:{(Id.Lit_Digits 1)})
                              )
                          )
                        }
                      spids: [213]
                    )
                  ]
                )
                (command.If
                  arms: [
                    (if_arm
                      cond: [
                        (command.Sentence
                          child: 
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: {(DQ ($ Id.VSub_DollarName '$cur'))}
                                  right: {(-) (Id.Lit_Other '*')}
                                )
                            )
                          terminator: (Token id:Id.Op_Semi val:';' span_id:237)
                        )
                      ]
                      action: [
                        (command.Case
                          to_match: {($ Id.VSub_DollarName '$command')}
                          arms: [
                            (case_arm
                              pat_list: [{(add)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:options)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (SQ 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: ' --non-recursive -N -q --quiet'
                                              span_id: 259
                                            )
                                          )
                                        }
                                      spids: [257]
                                    )
                                  ]
                                )
                              ]
                              spids: [253 254 263 -1]
                            )
                            (case_arm
                              pat_list: [{(blame)} {(annotate)} {(ann)} {(praise)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:options)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (SQ 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: '-r --revisions -x --cross'
                                              span_id: 278
                                            )
                                          )
                                        }
                                      spids: [276]
                                    )
                                  ]
                                )
                              ]
                              spids: [266 273 282 -1]
                            )
                            (case_arm
                              pat_list: [{(cat)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:options)
                                      op: assign_op.Equal
                                      rhs: 
                                        {(SQ (Token id:Id.Lit_Chars val:'-r --revision' span_id:291))}
                                      spids: [289]
                                    )
                                  ]
                                )
                              ]
                              spids: [285 286 295 -1]
                            )
                            (case_arm
                              pat_list: [{(checkout)} {(co)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:options)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (SQ 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: 
'-r --revision -q --quiet -N --non-recursive -l\n'
                                              span_id: 306
                                            ) 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: 
'                        --list -d --detach --export --relocate --purge'
                                              span_id: 307
                                            )
                                          )
                                        }
                                      spids: [304]
                                    )
                                  ]
                                )
                              ]
                              spids: [298 301 311 -1]
                            )
                            (case_arm
                              pat_list: [{(cleanup)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:options)
                                      op: assign_op.Equal
                                      rhs: {(SQ (Token id:Id.Lit_Chars val:'-a --all' span_id:320))}
                                      spids: [318]
                                    )
                                  ]
                                )
                              ]
                              spids: [314 315 324 -1]
                            )
                            (case_arm
                              pat_list: [{(cmerge)} {(cm)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:options)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (SQ 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: '-c --change -l --log -r --revision -a --auto\n'
                                              span_id: 335
                                            ) 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: 
'                        --verbatim --no-ticket -m --message -F --file\n'
                                              span_id: 336
                                            ) 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: 
'                        --template --encoding -P --patch -S --sign -C\n'
                                              span_id: 337
                                            ) (Token id:Id.Lit_Chars val:'                        --check-only --direct' span_id:338)
                                          )
                                        }
                                      spids: [333]
                                    )
                                  ]
                                )
                              ]
                              spids: [327 330 342 -1]
                            )
                            (case_arm
                              pat_list: [{(commit)} {(ci)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:options)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (SQ 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: '--import -m --message -F --file --encoding\n'
                                              span_id: 353
                                            ) 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: 
'                        --template -P --patch -S --sign -C --check-only -N\n'
                                              span_id: 354
                                            ) (Token id:Id.Lit_Chars val:'                        --non-recursive --direct' span_id:355)
                                          )
                                        }
                                      spids: [351]
                                    )
                                  ]
                                )
                              ]
                              spids: [345 348 359 -1]
                            )
                            (case_arm
                              pat_list: [{(copy)} {(cp)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:options)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (SQ 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: 
'-r --revision -p --parent -q --quiet -m --message\n'
                                              span_id: 370
                                            ) 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: 
'                        -F --file --template --encoding -P --patch -S --sign -C\n'
                                              span_id: 371
                                            ) (Token id:Id.Lit_Chars val:'                        --check-only --direct' span_id:372)
                                          )
                                        }
                                      spids: [368]
                                    )
                                  ]
                                )
                              ]
                              spids: [362 365 376 -1]
                            )
                            (case_arm
                              pat_list: [{(delete)} {(del)} {(remove)} {(rm)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:options)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (SQ 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: 
'-k --keep-local -m --message -F --file --encoding\n'
                                              span_id: 391
                                            ) 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: 
'                        --template -P --patch -S --sign -C --check-only\n'
                                              span_id: 392
                                            ) (Token id:Id.Lit_Chars val:'                        --direct' span_id:393)
                                          )
                                        }
                                      spids: [389]
                                    )
                                  ]
                                )
                              ]
                              spids: [379 386 397 -1]
                            )
                            (case_arm
                              pat_list: [{(depotmap)} {(depot)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:options)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (SQ 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: '-i --init -l --list -d --detach --relocate'
                                              span_id: 408
                                            )
                                          )
                                        }
                                      spids: [406]
                                    )
                                  ]
                                )
                              ]
                              spids: [400 403 412 -1]
                            )
                            (case_arm
                              pat_list: [{(diff)} {(di)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:options)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (SQ 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: '-r --revision -s --summarize -b --verbose -N\n'
                                              span_id: 423
                                            ) (Token id:Id.Lit_Chars val:'                        --non-recursive' span_id:424)
                                          )
                                        }
                                      spids: [421]
                                    )
                                  ]
                                )
                              ]
                              spids: [415 418 428 -1]
                            )
                            (case_arm
                              pat_list: [{(import)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:options)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (SQ 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: 
'-f --from-checkout -t --to-checkout -m --message\n'
                                              span_id: 437
                                            ) 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: 
'                        -F --file --template --encoding -P --patch -S --sign -C\n'
                                              span_id: 438
                                            ) 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: 
'                        --check-only -N --non-recursive --direct'
                                              span_id: 439
                                            )
                                          )
                                        }
                                      spids: [435]
                                    )
                                  ]
                                )
                              ]
                              spids: [431 432 443 -1]
                            )
                            (case_arm
                              pat_list: [{(list)} {(ls)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:options)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (SQ 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: '-r --revision -v --verbose -R --recursive -d\n'
                                              span_id: 454
                                            ) (Token id:Id.Lit_Chars val:'                        --depth -f --full-path' span_id:455)
                                          )
                                        }
                                      spids: [452]
                                    )
                                  ]
                                )
                              ]
                              spids: [446 449 459 -1]
                            )
                            (case_arm
                              pat_list: [{(log)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:options)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (SQ 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: 
'-r --revision -l --limit -q --quiet -x --cross -v\n'
                                              span_id: 468
                                            ) (Token id:Id.Lit_Chars val:'                        --verbose' span_id:469)
                                          )
                                        }
                                      spids: [466]
                                    )
                                  ]
                                )
                              ]
                              spids: [462 463 473 -1]
                            )
                            (case_arm
                              pat_list: [{(merge)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:options)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (SQ 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: '-r --revision -c --change -I --incremental -a\n'
                                              span_id: 482
                                            ) 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: 
'                        --auto -l --log -s --sync -t --to -f --from --verbatim\n'
                                              span_id: 483
                                            ) 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: 
'                        --no-ticket --track-rename -m --message -F --file\n'
                                              span_id: 484
                                            ) 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: 
'                        --template --encoding -P --patch -S --sign -C\n'
                                              span_id: 485
                                            ) (Token id:Id.Lit_Chars val:'                        --check-only --direct' span_id:486)
                                          )
                                        }
                                      spids: [480]
                                    )
                                  ]
                                )
                              ]
                              spids: [476 477 490 -1]
                            )
                            (case_arm
                              pat_list: [{(mirror)} {(mi)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:options)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (SQ 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: '-l --list -d --detach --relocate --recover\n'
                                              span_id: 501
                                            ) (Token id:Id.Lit_Chars val:'                        --unlock --upgrade' span_id:502)
                                          )
                                        }
                                      spids: [499]
                                    )
                                  ]
                                )
                              ]
                              spids: [493 496 506 -1]
                            )
                            (case_arm
                              pat_list: [{(mkdir)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:options)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (SQ 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: '-p --parent -m --message -F --file --template\n'
                                              span_id: 515
                                            ) 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: 
'                        --encoding -P --patch -S --sign -C --check-only\n'
                                              span_id: 516
                                            ) (Token id:Id.Lit_Chars val:'                        --direct' span_id:517)
                                          )
                                        }
                                      spids: [513]
                                    )
                                  ]
                                )
                              ]
                              spids: [509 510 521 -1]
                            )
                            (case_arm
                              pat_list: [{(move)} {(mv)} {(rename)} {(ren)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:options)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (SQ 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: 
'-r --revision -p --parent -q --quiet -m --message\n'
                                              span_id: 536
                                            ) 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: 
'                        -F --file --encoding --template -P --patch -S --sign -C\n'
                                              span_id: 537
                                            ) (Token id:Id.Lit_Chars val:'                        --check-only --direct' span_id:538)
                                          )
                                        }
                                      spids: [534]
                                    )
                                  ]
                                )
                              ]
                              spids: [524 531 542 -1]
                            )
                            (case_arm
                              pat_list: [{(patch)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:options)
                                      op: assign_op.Equal
                                      rhs: {(SQ (Token id:Id.Lit_Chars val:--depot span_id:551))}
                                      spids: [549]
                                    )
                                  ]
                                )
                              ]
                              spids: [545 546 555 -1]
                            )
                            (case_arm
                              pat_list: [{(propdel)} {(propset)} {(pdel)} {(pset)} {(pd)} {(ps)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:options)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (SQ 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: '-R --recursive -r --revision --revprop -m\n'
                                              span_id: 574
                                            ) 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: 
'                        --message -F --file --template --encoding -P --patch -S\n'
                                              span_id: 575
                                            ) 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: 
'                        --sign -C --check-only -q --quiet --direct'
                                              span_id: 576
                                            )
                                          )
                                        }
                                      spids: [572]
                                    )
                                  ]
                                )
                              ]
                              spids: [558 569 580 -1]
                            )
                            (case_arm
                              pat_list: [{(propedit)} {(pedit)} {(pe)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:options)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (SQ 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: '-R --recursive -r --revision --revprop -m\n'
                                              span_id: 593
                                            ) 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: 
'                        --message -F --file --template --encoding -P --patch\n'
                                              span_id: 594
                                            ) (Token id:Id.Lit_Chars val:'                        -S --sign -C --check-only --direct' span_id:595)
                                          )
                                        }
                                      spids: [591]
                                    )
                                  ]
                                )
                              ]
                              spids: [583 588 599 -1]
                            )
                            (case_arm
                              pat_list: [{(propget)} {(pget)} {(pg)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:options)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (SQ 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: '-R --recursive -r --revision --revprop --strict'
                                              span_id: 612
                                            )
                                          )
                                        }
                                      spids: [610]
                                    )
                                  ]
                                )
                              ]
                              spids: [602 607 616 -1]
                            )
                            (case_arm
                              pat_list: [{(proplist)} {(plist)} {(pl)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:options)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (SQ 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: '-R --recursive -v --verbose -r --revision\n'
                                              span_id: 629
                                            ) (Token id:Id.Lit_Chars val:'                        --revprop' span_id:630)
                                          )
                                        }
                                      spids: [627]
                                    )
                                  ]
                                )
                              ]
                              spids: [619 624 634 -1]
                            )
                            (case_arm
                              pat_list: [{(pull)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:options)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (SQ 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: '-a --all -l --lump'
                                              span_id: 643
                                            )
                                          )
                                        }
                                      spids: [641]
                                    )
                                  ]
                                )
                              ]
                              spids: [637 638 647 -1]
                            )
                            (case_arm
                              pat_list: [{(push)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:options)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (SQ 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: '-f --from -l --lump -C --check -P --patch -S\n'
                                              span_id: 656
                                            ) (Token id:Id.Lit_Chars val:'                        --sign --verbatim' span_id:657)
                                          )
                                        }
                                      spids: [654]
                                    )
                                  ]
                                )
                              ]
                              spids: [650 651 661 -1]
                            )
                            (case_arm
                              pat_list: [{(resolved)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:options)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (SQ 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: '-R --recursive'
                                              span_id: 670
                                            )
                                          )
                                        }
                                      spids: [668]
                                    )
                                  ]
                                )
                              ]
                              spids: [664 665 674 -1]
                            )
                            (case_arm
                              pat_list: [{(revert)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:options)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (SQ 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: '-R --recursive -q --quiet'
                                              span_id: 683
                                            )
                                          )
                                        }
                                      spids: [681]
                                    )
                                  ]
                                )
                              ]
                              spids: [677 678 687 -1]
                            )
                            (case_arm
                              pat_list: [{(smerge)} {(sm)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:options)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (SQ 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: 
'-I --incremental -l --log -B --baseless -b --base\n'
                                              span_id: 698
                                            ) 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: 
'                        -s --sync -t --to -f --from --verbatim --no-ticket\n'
                                              span_id: 699
                                            ) 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: 
'                        --track-rename --host --remoterev -m --message -F\n'
                                              span_id: 700
                                            ) 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: 
'                        --file --template --encoding -P --patch -S --sign -C\n'
                                              span_id: 701
                                            ) (Token id:Id.Lit_Chars val:'                        --check-only --direct' span_id:702)
                                          )
                                        }
                                      spids: [696]
                                    )
                                  ]
                                )
                              ]
                              spids: [690 693 706 -1]
                            )
                            (case_arm
                              pat_list: [{(status)} {(stat)} {(st)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:options)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (SQ 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: '-q --quiet --no-ignore -N --non-recursive -v\n'
                                              span_id: 719
                                            ) (Token id:Id.Lit_Chars val:'                        --verbose' span_id:720)
                                          )
                                        }
                                      spids: [717]
                                    )
                                  ]
                                )
                              ]
                              spids: [709 714 724 -1]
                            )
                            (case_arm
                              pat_list: [{(switch)} {(sw)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:options)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (SQ 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: '-r --revision -d --detach -q --quiet'
                                              span_id: 735
                                            )
                                          )
                                        }
                                      spids: [733]
                                    )
                                  ]
                                )
                              ]
                              spids: [727 730 739 -1]
                            )
                            (case_arm
                              pat_list: [{(sync)} {(sy)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:options)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (SQ 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: '-a --all -s --skipto -t --torev'
                                              span_id: 750
                                            )
                                          )
                                        }
                                      spids: [748]
                                    )
                                  ]
                                )
                              ]
                              spids: [742 745 754 -1]
                            )
                            (case_arm
                              pat_list: [{(update)} {(up)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:options)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (SQ 
                                            (Token
                                              id: Id.Lit_Chars
                                              val: 
'-r --revision -N --non-recursive -C --check-only\n'
                                              span_id: 765
                                            ) (Token id:Id.Lit_Chars val:'                        -s --sync -m --merge -q --quiet' span_id:766)
                                          )
                                        }
                                      spids: [763]
                                    )
                                  ]
                                )
                              ]
                              spids: [757 760 770 -1]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:options)
                              op: assign_op.PlusEqual
                              rhs: {(DQ (' --help -h'))}
                              spids: [776]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (sh_array_literal
                                    left: (Token id:Id.Op_LParen val:'(' span_id:784)
                                    words: [
                                      {
                                        (command_sub
                                          left_token: 
                                            (Token
                                              id: Id.Left_DollarParen
                                              val: '$('
                                              span_id: 786
                                            )
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} 
                                                  {(DQ ($ Id.VSub_DollarName '$options'))} {(--)} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [783]
                            )
                          ]
                        )
                      ]
                      spids: [223 239]
                    )
                  ]
                  else_action: [
                    (command.Case
                      to_match: {($ Id.VSub_DollarName '$command')}
                      arms: [
                        (case_arm
                          pat_list: [
                            {(help)}
                            {(h)}
                            {
                              (word_part.EscapedLiteral
                                token: (Token id:Id.Lit_EscapedChar val:'\\?' span_id:821)
                              )
                            }
                          ]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: (Token id:Id.Op_LParen val:'(' span_id:826)
                                        words: [
                                          {
                                            (command_sub
                                              left_token: 
                                                (Token
                                                  id: Id.Left_DollarParen
                                                  val: '$('
                                                  span_id: 828
                                                )
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (C {(compgen)} {(-W)} 
                                                      {
                                                        (DQ ($ Id.VSub_DollarName '$commands') 
                                                          (' environment commands\n') ('                        intro')
                                                        )
                                                      } {(--)} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                    )
                                                  ]
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [825]
                                )
                              ]
                            )
                          ]
                          spids: [817 822 851 -1]
                        )
                        (case_arm
                          pat_list: [{(admin)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: (Token id:Id.Op_LParen val:'(' span_id:859)
                                        words: [
                                          {
                                            (command_sub
                                              left_token: 
                                                (Token
                                                  id: Id.Left_DollarParen
                                                  val: '$('
                                                  span_id: 861
                                                )
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (C {(compgen)} {(-W)} 
                                                      {
                                                        (SQ 
                                                          (Token
                                                            id: Id.Lit_Chars
                                                            val: 'help deltify dump hotcopy\n'
                                                            span_id: 868
                                                          ) 
                                                          (Token
                                                            id: Id.Lit_Chars
                                                            val: 
'                        list-dblogs list-unused-dblogs load lstxns recover\n'
                                                            span_id: 869
                                                          ) (Token id:Id.Lit_Chars val:'                        rmtxns setlog verify rmcache' span_id:870)
                                                        )
                                                      } {(--)} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                    )
                                                  ]
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [858]
                                )
                              ]
                            )
                          ]
                          spids: [854 855 884 -1]
                        )
                        (case_arm
                          pat_list: [{(patch)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: (Token id:Id.Op_LParen val:'(' span_id:892)
                                        words: [
                                          {
                                            (command_sub
                                              left_token: 
                                                (Token
                                                  id: Id.Left_DollarParen
                                                  val: '$('
                                                  span_id: 894
                                                )
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (C {(compgen)} {(-W)} 
                                                      {
                                                        (SQ 
                                                          (Token
                                                            id: Id.Lit_Chars
                                                            val: '--ls --list --cat --view\n'
                                                            span_id: 901
                                                          ) 
                                                          (Token
                                                            id: Id.Lit_Chars
                                                            val: 
'                        --regen --regenerate --up --update --apply --rm\n'
                                                            span_id: 902
                                                          ) (Token id:Id.Lit_Chars val:'                        --delete' span_id:903)
                                                        )
                                                      } {(--)} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                    )
                                                  ]
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [891]
                                )
                              ]
                            )
                          ]
                          spids: [887 888 917 -1]
                        )
                        (case_arm
                          pat_list: [{(sync)}]
                          action: [
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: (Token id:Id.Op_LParen val:'(' span_id:925)
                                        words: [
                                          {
                                            (command_sub
                                              left_token: 
                                                (Token
                                                  id: Id.Left_DollarParen
                                                  val: '$('
                                                  span_id: 927
                                                )
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (C {(compgen)} {(-W)} 
                                                      {
                                                        (DQ 
                                                          (command_sub
                                                            left_token: 
                                                              (Token
                                                                id: Id.Left_DollarParen
                                                                val: '$('
                                                                span_id: 934
                                                              )
                                                            command_list: 
                                                              (command.CommandList
                                                                children: [
                                                                  (command.Pipeline
                                                                    children: [
                                                                      (command.Simple
                                                                        words: [
                                                                          {($ Id.VSub_Number '$1')}
                                                                          {(mirror)}
                                                                          {(--list)}
                                                                        ]
                                                                        redirects: [
                                                                          (redir.Redir
                                                                            op: 
                                                                              (Token
                                                                                id: Id.Redir_Great
                                                                                val: '2>'
                                                                                span_id: 944
                                                                              )
                                                                            fd: 2
                                                                            arg_word: {(/dev/null)}
                                                                          )
                                                                        ]
                                                                      )
                                                                      (C {(awk)} 
                                                                        {
                                                                          (SQ 
                                                                            (Token
                                                                              id: Id.Lit_Chars
                                                                              val: 
'/^\\//{print $1}'
                                                                              span_id: 952
                                                                            )
                                                                          )
                                                                        }
                                                                      )
                                                                    ]
                                                                    negated: F
                                                                  )
                                                                ]
                                                              )
                                                          )
                                                        )
                                                      } {(--)} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                    )
                                                  ]
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [924]
                                )
                              ]
                            )
                          ]
                          spids: [920 921 969 -1]
                        )
                        (case_arm
                          pat_list: [{(co)} {(checkout)} {(push)} {(pull)}]
                          action: [
                            (command.If
                              arms: [
                                (if_arm
                                  cond: [
                                    (command.Sentence
                                      child: 
                                        (command.DBracket
                                          expr: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobDEqual
                                              left: {(DQ ($ Id.VSub_DollarName '$cur'))}
                                              right: {(//) (Id.Lit_Other '*') (/) (Id.Lit_Other '*')}
                                            )
                                        )
                                      terminator: (Token id:Id.Op_Semi val:';' span_id:998)
                                    )
                                  ]
                                  action: [
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:path)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (braced_var_sub
                                                token: (Token id:Id.VSub_Name val:cur span_id:1005)
                                                suffix_op: 
                                                  (suffix_op.Unary
                                                    op_id: Id.VOp1_Percent
                                                    arg_word: {(Id.Lit_Slash /) ('*')}
                                                  )
                                              ) (/)
                                            }
                                          spids: [1003]
                                        )
                                      ]
                                    )
                                  ]
                                  spids: [982 1000]
                                )
                              ]
                              else_action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:path)
                                      op: assign_op.Equal
                                      rhs: {(//)}
                                      spids: [1016]
                                    )
                                  ]
                                )
                              ]
                            )
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: (Token id:Id.Op_LParen val:'(' span_id:1024)
                                        words: [
                                          {
                                            (command_sub
                                              left_token: 
                                                (Token
                                                  id: Id.Left_DollarParen
                                                  val: '$('
                                                  span_id: 1026
                                                )
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (C {(compgen)} {(-W)} 
                                                      {
                                                        (DQ 
                                                          (command_sub
                                                            left_token: 
                                                              (Token
                                                                id: Id.Left_DollarParen
                                                                val: '$('
                                                                span_id: 1033
                                                              )
                                                            command_list: 
                                                              (command.CommandList
                                                                children: [
                                                                  (command.Pipeline
                                                                    children: [
                                                                      (command.Simple
                                                                        words: [
                                                                          {($ Id.VSub_Number '$1')}
                                                                          {(list)}
                                                                          {
                                                                            ($ Id.VSub_DollarName 
'$path'
                                                                            )
                                                                          }
                                                                        ]
                                                                        redirects: [
                                                                          (redir.Redir
                                                                            op: 
                                                                              (Token
                                                                                id: Id.Redir_Great
                                                                                val: '2>'
                                                                                span_id: 1041
                                                                              )
                                                                            fd: 2
                                                                            arg_word: {(/dev/null)}
                                                                          )
                                                                        ]
                                                                      )
                                                                      (C {(sed)} {(-e)} 
                                                                        {
                                                                          (SQ 
                                                                            (Token
                                                                              id: Id.Lit_Chars
                                                                              val: 's|\\(.*\\)|'
                                                                              span_id: 1053
                                                                            )
                                                                          ) ($ Id.VSub_DollarName '$path') (SQ (Token id:Id.Lit_Chars val:'\\1|' span_id:1057))
                                                                        }
                                                                      )
                                                                    ]
                                                                    negated: F
                                                                  )
                                                                ]
                                                              )
                                                          )
                                                        )
                                                      } {(--)} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                    )
                                                  ]
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [1023]
                                )
                              ]
                            )
                          ]
                          spids: [972 979 1073 -1]
                        )
                        (case_arm
                          pat_list: [{(Id.Lit_Star '*')}]
                          action: [(C {(_filedir)})]
                          spids: [1076 1077 1083 -1]
                        )
                      ]
                    )
                  ]
                )
              ]
            )
            (command.ControlFlow
              token: (Token id:Id.ControlFlow_Return val:return span_id:1096)
              arg_word: {(0)}
            )
          ]
        )
    )
    (C {(complete)} {(-F)} {(_svk)} {(svk)})
  ]
)