(CommandList
  children: [
    (FuncDef
      name: _cvs_entries
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              pairs: [
                (assign_pair
                  lhs: (LhsName name:prefix)
                  op: Equal
                  rhs: 
                    {
                      (BracedVarSub
                        token: <VSub_Name cur>
                        suffix_op: (StringUnary op_id:VOp1_Percent arg_word:{(Lit_Slash /) ('*')})
                        spids: [14 19]
                      ) (/)
                    }
                  spids: [13]
                )
                (assign_pair
                  lhs: (LhsName name:IFS)
                  op: Equal
                  rhs: 
                    {
                      (SingleQuotedPart
                        left: <Left_DollarSingleQuote "$'">
                        tokens: [<Char_OneChar '\\n'>]
                        spids: [23 25]
                      )
                    }
                  spids: [22]
                )
              ]
              spids: [11]
            )
            (AndOr
              ops: [Op_DPipe]
              children: [
                (DBracket
                  expr: 
                    (BoolUnary
                      op_id: BoolUnary_e
                      child: 
                        {
                          (BracedVarSub
                            token: <VSub_Name prefix>
                            suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{})
                            spids: [32 35]
                          ) (CVS/Entries)
                        }
                    )
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [(assign_pair lhs:(LhsName name:prefix) op:Equal rhs:{(DQ )} spids:[42])]
                  spids: [42]
                )
              ]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:entries)
                  op: Equal
                  rhs: 
                    {
                      (ArrayLiteralPart
                        words: [
                          {
                            (CommandSubPart
                              command_list: 
                                (CommandList
                                  children: [
                                    (SimpleCommand
                                      words: [
                                        {(cut)}
                                        {(-d/)}
                                        {(-f2)}
                                        {(-s)}
                                        {
                                          (BracedVarSub
                                            token: <VSub_Name prefix>
                                            suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{})
                                            spids: [60 63]
                                          ) (CVS/Entries)
                                        }
                                      ]
                                      redirects: [
                                        (Redir
                                          op: <Redir_Great '2>'>
                                          fd: 2
                                          arg_word: {(/dev/null)}
                                        )
                                      ]
                                    )
                                  ]
                                )
                              left_token: <Left_CommandSub '$('>
                              spids: [50 69]
                            )
                          }
                        ]
                      )
                    }
                  spids: [47]
                )
              ]
              spids: [47]
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: (DBracket expr:(WordTest w:{($ VSub_Name '$entries')}))
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:entries)
                          op: Equal
                          rhs: 
                            {
                              (ArrayLiteralPart
                                words: [
                                  {
                                    (DQ 
                                      (BracedVarSub
                                        token: <VSub_Name entries>
                                        bracket_op: (WholeArray op_id:Lit_At)
                                        suffix_op: 
                                          (PatSub
                                            pat: {}
                                            replace: 
                                              {
                                                (BracedVarSub
                                                  token: <VSub_Name prefix>
                                                  suffix_op: (StringUnary op_id:VTest_ColonHyphen arg_word:{})
                                                  spids: [98 101]
                                                )
                                              }
                                            do_all: F
                                            do_prefix: T
                                            do_suffix: F
                                          )
                                        spids: [90 102]
                                      )
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [86]
                        )
                      ]
                      spids: [86]
                    )
                    (C {(compopt)} {(-o)} {(filenames)})
                  ]
                  spids: [16777215 83]
                )
              ]
              spids: [16777215 115]
            )
          ]
          spids: [8]
        )
      spids: [4 7]
    )
    (FuncDef
      name: _cvs_modules
      body: 
        (BraceGroup
          children: [
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (DBracket
                          expr: (BoolUnary op_id:BoolUnary_n child:{($ VSub_Name '$prefix')})
                        )
                      terminator: <Op_Semi ';'>
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_None
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:COMPREPLY)
                          op: Equal
                          rhs: 
                            {
                              (ArrayLiteralPart
                                words: [
                                  {
                                    (CommandSubPart
                                      command_list: 
                                        (CommandList
                                          children: [
                                            (C {(command)} {(ls)} {(-d)} 
                                              {(${ VSub_Name cvsroot) (/) (${ VSub_Name prefix) (/) 
                                                (ExtGlobPart
                                                  op: <ExtGlob_Bang '!('>
                                                  spids: [160 162]
                                                )
                                              }
                                            )
                                          ]
                                        )
                                      left_token: <Left_CommandSub '$('>
                                      spids: [144 164]
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [141]
                        )
                      ]
                      spids: [141]
                    )
                  ]
                  spids: [16777215 138]
                )
              ]
              else_action: [
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:COMPREPLY)
                      op: Equal
                      rhs: 
                        {
                          (ArrayLiteralPart
                            words: [
                              {
                                (CommandSubPart
                                  command_list: 
                                    (CommandList
                                      children: [
                                        (C {(command)} {(ls)} {(-d)} 
                                          {(${ VSub_Name cvsroot) (/) 
                                            (ExtGlobPart
                                              op: <ExtGlob_Bang '!('>
                                              spids: [187 189]
                                            )
                                          }
                                        )
                                      ]
                                    )
                                  left_token: <Left_CommandSub '$('>
                                  spids: [175 191]
                                )
                              }
                            ]
                          )
                        }
                      spids: [172]
                    )
                  ]
                  spids: [172]
                )
              ]
              spids: [169 196]
            )
          ]
          spids: [124]
        )
      spids: [120 123]
    )
    (FuncDef
      name: _cvs_commands
      body: 
        (BraceGroup
          children: [
            (Pipeline
              children: [
                (SimpleCommand
                  words: [{(cvs)} {(--help-commands)}]
                  redirects: [(Redir op:<Redir_GreatAnd '2>&'> fd:2 arg_word:{(1)})]
                )
                (C {(awk)} {(SQ <'/^(     *|\\t)/ { print $1 }'>)})
              ]
              negated: F
            )
          ]
          spids: [205]
        )
      spids: [201 204]
    )
    (FuncDef
      name: _cvs_command_options
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:COMPREPLY)
                  op: Equal
                  rhs: 
                    {
                      (ArrayLiteralPart
                        words: [
                          {
                            (CommandSubPart
                              command_list: 
                                (CommandList
                                  children: [
                                    (C {(compgen)} {(-W)} {(SQ <'$( _parse_help "$1" "--help $2" )'>)} 
                                      {(--)} {(DQ ($ VSub_Name '$cur'))}
                                    )
                                  ]
                                )
                              left_token: <Left_CommandSub '$('>
                              spids: [236 252]
                            )
                          }
                        ]
                      )
                    }
                  spids: [233]
                )
              ]
              spids: [233]
            )
          ]
          spids: [230]
        )
      spids: [226 229]
    )
    (FuncDef
      name: _cvs_kflags
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:COMPREPLY)
                  op: Equal
                  rhs: 
                    {
                      (ArrayLiteralPart
                        words: [
                          {
                            (CommandSubPart
                              command_list: 
                                (CommandList
                                  children: [
                                    (C {(compgen)} {(-W)} {(SQ <'kv kvl k o b v'>)} {(--)} 
                                      {(DQ ($ VSub_Name '$cur'))}
                                    )
                                  ]
                                )
                              left_token: <Left_CommandSub '$('>
                              spids: [269 285]
                            )
                          }
                        ]
                      )
                    }
                  spids: [266]
                )
              ]
              spids: [266]
            )
          ]
          spids: [263]
        )
      spids: [259 262]
    )
    (FuncDef
      name: _cvs_roots
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_Local
              flags: [-a]
              pairs: [(assign_pair lhs:(LhsName name:cvsroots) op:Equal spids:[303])]
              spids: [299]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:cvsroots)
                  op: Equal
                  rhs: {(ArrayLiteralPart words:[{($ VSub_Name '$CVSROOT')}])}
                  spids: [306]
                )
              ]
              spids: [306]
            )
            (AndOr
              ops: [Op_DAmp]
              children: [
                (DBracket
                  expr: (BoolUnary op_id:BoolUnary_r child:{(Lit_TildeLike '~') (/.cvspass)})
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [
                    (assign_pair
                      lhs: (LhsName name:cvsroots)
                      op: PlusEqual
                      rhs: 
                        {
                          (ArrayLiteralPart
                            words: [
                              {
                                (CommandSubPart
                                  command_list: 
                                    (CommandList
                                      children: [
                                        (C {(awk)} {(SQ <'{ print $2 }'>)} 
                                          {(TildeSubPart token:<Lit_TildeLike '~'>) (/.cvspass)}
                                        )
                                      ]
                                    )
                                  left_token: <Left_CommandSub '$('>
                                  spids: [328 339]
                                )
                              }
                            ]
                          )
                        }
                      spids: [325]
                    )
                  ]
                  spids: [325]
                )
              ]
            )
            (AndOr
              ops: [Op_DAmp]
              children: [
                (DBracket expr:(BoolUnary op_id:BoolUnary_r child:{(CVS/Root)}))
                (SimpleCommand
                  words: [
                    {(mapfile)}
                    {(-tO)}
                    {
                      (BracedVarSub
                        token: <VSub_Name cvsroots>
                        prefix_op: VSub_Pound
                        bracket_op: (WholeArray op_id:Lit_At)
                        spids: [358 364]
                      )
                    }
                    {(cvsroots)}
                  ]
                  redirects: [(Redir op:<Redir_Less '<'> fd:16777215 arg_word:{(CVS/Root)})]
                )
              ]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:COMPREPLY)
                  op: Equal
                  rhs: 
                    {
                      (ArrayLiteralPart
                        words: [
                          {
                            (CommandSubPart
                              command_list: 
                                (CommandList
                                  children: [
                                    (C {(compgen)} {(-W)} {(SQ <'${cvsroots[@]}'>)} {(--)} 
                                      {(DQ ($ VSub_Name '$cur'))}
                                    )
                                  ]
                                )
                              left_token: <Left_CommandSub '$('>
                              spids: [376 392]
                            )
                          }
                        ]
                      )
                    }
                  spids: [373]
                )
              ]
              spids: [373]
            )
            (C {(__ltrim_colon_completions)} {(DQ ($ VSub_Name '$cur'))})
          ]
          spids: [296]
        )
      spids: [292 295]
    )
    (AndOr
      ops: [Op_DAmp]
      children: [
        (FuncDef
          name: _cvs
          body: 
            (BraceGroup
              children: [
                (Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair lhs:(LhsName name:cur) op:Equal spids:[415])
                    (assign_pair lhs:(LhsName name:prev) op:Equal spids:[417])
                    (assign_pair lhs:(LhsName name:words) op:Equal spids:[419])
                    (assign_pair lhs:(LhsName name:cword) op:Equal spids:[421])
                  ]
                  spids: [413]
                )
                (AndOr
                  ops: [Op_DPipe]
                  children: [
                    (C {(_init_completion)} {(-n)} {(Lit_Other ':')})
                    (ControlFlow token:<ControlFlow_Return return>)
                  ]
                )
                (Assignment
                  keyword: Assign_Local
                  pairs: [
                    (assign_pair lhs:(LhsName name:count) op:Equal spids:[438])
                    (assign_pair lhs:(LhsName name:mode) op:Equal spids:[440])
                    (assign_pair lhs:(LhsName name:i) op:Equal spids:[442])
                    (assign_pair lhs:(LhsName name:cvsroot) op:Equal spids:[444])
                    (assign_pair
                      lhs: (LhsName name:cvsroots)
                      op: Equal
                      spids: [446]
                    )
                    (assign_pair lhs:(LhsName name:pwd) op:Equal spids:[448])
                  ]
                  spids: [436]
                )
                (Assignment
                  keyword: Assign_Local
                  flags: [-a]
                  pairs: [
                    (assign_pair lhs:(LhsName name:flags) op:Equal spids:[455])
                    (assign_pair lhs:(LhsName name:files) op:Equal spids:[457])
                    (assign_pair lhs:(LhsName name:entries) op:Equal spids:[459])
                    (assign_pair lhs:(LhsName name:changed) op:Equal spids:[461])
                    (assign_pair
                      lhs: (LhsName name:newremoved)
                      op: Equal
                      spids: [463]
                    )
                  ]
                  spids: [451]
                )
                (Assignment
                  keyword: Assign_None
                  pairs: [(assign_pair lhs:(LhsName name:count) op:Equal rhs:{(0)} spids:[467])]
                  spids: [467]
                )
                (ForEach
                  iter_name: i
                  iter_words: [
                    {
                      (DQ 
                        (BracedVarSub
                          token: <VSub_Name words>
                          bracket_op: (WholeArray op_id:Lit_At)
                          spids: [478 483]
                        )
                      )
                    }
                  ]
                  do_arg_iter: F
                  body: 
                    (DoGroup
                      children: [
                        (AndOr
                          ops: [Op_DAmp]
                          children: [
                            (DBracket
                              expr: 
                                (BoolBinary
                                  op_id: BoolBinary_eq
                                  left: {($ VSub_Name '$count')}
                                  right: {($ VSub_Name '$cword')}
                                )
                            )
                            (ControlFlow token:<ControlFlow_Break break>)
                          ]
                        )
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (Sentence
                                  child: 
                                    (DBracket
                                      expr: 
                                        (LogicalAnd
                                          left: 
                                            (BoolBinary
                                              op_id: BoolBinary_GlobDEqual
                                              left: 
                                                {
                                                  (DQ 
                                                    (BracedVarSub
                                                      token: <VSub_Name words>
                                                      bracket_op: 
                                                        (ArrayIndex
                                                          expr: (ArithVarRef name:count)
                                                        )
                                                      spids: [514 523]
                                                    )
                                                  )
                                                }
                                              right: {(DQ ($ VSub_Name '$cvsroot'))}
                                            )
                                          right: 
                                            (BoolBinary
                                              op_id: BoolBinary_GlobDEqual
                                              left: {(DQ ($ VSub_Name '$mode'))}
                                              right: {(cvsroot)}
                                            )
                                        )
                                    )
                                  terminator: <Op_Semi ';'>
                                )
                              ]
                              action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:mode)
                                      op: Equal
                                      rhs: {(DQ )}
                                      spids: [548]
                                    )
                                  ]
                                  spids: [548]
                                )
                              ]
                              spids: [16777215 545]
                            )
                          ]
                          spids: [16777215 553]
                        )
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (Sentence
                                  child: 
                                    (DBracket
                                      expr: (BoolUnary op_id:BoolUnary_z child:{($ VSub_Name '$mode')})
                                    )
                                  terminator: <Op_Semi ';'>
                                )
                              ]
                              action: [
                                (Case
                                  to_match: {($ VSub_Name '$i')}
                                  arms: [
                                    (case_arm
                                      pat_list: [{(-H)} {(--help)}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:COMPREPLY)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (ArrayLiteralPart
                                                    words: [
                                                      {
                                                        (CommandSubPart
                                                          command_list: 
                                                            (CommandList
                                                              children: [
                                                                (C {(compgen)} {(-W)} 
                                                                  {
                                                                    (DQ 
                                                                      (CommandSubPart
                                                                        command_list: 
                                                                          (CommandList
                                                                            children: [
                                                                              (C {(_cvs_commands)})
                                                                            ]
                                                                          )
                                                                        left_token: 
                                                                          <Left_CommandSub '$('>
                                                                        spids: [593 597]
                                                                      )
                                                                    )
                                                                  } {(--)} {(DQ ($ VSub_Name '$cur'))}
                                                                )
                                                              ]
                                                            )
                                                          left_token: <Left_CommandSub '$('>
                                                          spids: [586 606]
                                                        )
                                                      }
                                                    ]
                                                  )
                                                }
                                              spids: [583]
                                            )
                                          ]
                                          spids: [583]
                                        )
                                        (ControlFlow
                                          token: <ControlFlow_Return return>
                                          arg_word: {(0)}
                                        )
                                      ]
                                      spids: [577 580 616 16777215]
                                    )
                                    (case_arm
                                      pat_list: [{(-d)}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:mode)
                                              op: Equal
                                              rhs: {(cvsroot)}
                                              spids: [623]
                                            )
                                          ]
                                          spids: [623]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:cvsroot)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (BracedVarSub
                                                    token: <VSub_Name words>
                                                    bracket_op: 
                                                      (ArrayIndex
                                                        expr: 
                                                          (ArithBinary
                                                            op_id: Arith_Plus
                                                            left: (ArithVarRef name:count)
                                                            right: (ArithWord w:{(Lit_Digits 1)})
                                                          )
                                                      )
                                                    spids: [628 639]
                                                  )
                                                }
                                              spids: [627]
                                            )
                                          ]
                                          spids: [627]
                                        )
                                      ]
                                      spids: [619 620 642 16777215]
                                    )
                                    (case_arm
                                      pat_list: [{(add)} {(ad)} {(new)}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:mode)
                                              op: Equal
                                              rhs: {(add)}
                                              spids: [653]
                                            )
                                          ]
                                          spids: [653]
                                        )
                                      ]
                                      spids: [645 650 657 16777215]
                                    )
                                    (case_arm
                                      pat_list: [{(admin)} {(adm)} {(rcs)}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:mode)
                                              op: Equal
                                              rhs: {(admin)}
                                              spids: [668]
                                            )
                                          ]
                                          spids: [668]
                                        )
                                      ]
                                      spids: [660 665 672 16777215]
                                    )
                                    (case_arm
                                      pat_list: [
                                        {(annotate)}
                                        {(ann)}
                                        {(blame)}
                                        {(rannotate)}
                                        {(rann)}
                                        {(ra)}
                                      ]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:mode)
                                              op: Equal
                                              rhs: {(annotate)}
                                              spids: [689]
                                            )
                                          ]
                                          spids: [689]
                                        )
                                      ]
                                      spids: [675 686 693 16777215]
                                    )
                                    (case_arm
                                      pat_list: [{(checkout)} {(co)} {(get)}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:mode)
                                              op: Equal
                                              rhs: {(checkout)}
                                              spids: [704]
                                            )
                                          ]
                                          spids: [704]
                                        )
                                      ]
                                      spids: [696 701 708 16777215]
                                    )
                                    (case_arm
                                      pat_list: [{(commit)} {(ci)} {(com)}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:mode)
                                              op: Equal
                                              rhs: {(commit)}
                                              spids: [719]
                                            )
                                          ]
                                          spids: [719]
                                        )
                                      ]
                                      spids: [711 716 723 16777215]
                                    )
                                    (case_arm
                                      pat_list: [{(diff)} {(di)} {(dif)}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:mode)
                                              op: Equal
                                              rhs: {(diff)}
                                              spids: [734]
                                            )
                                          ]
                                          spids: [734]
                                        )
                                      ]
                                      spids: [726 731 738 16777215]
                                    )
                                    (case_arm
                                      pat_list: [{(export)} {(ex)} {(exp)}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:mode)
                                              op: Equal
                                              rhs: {(export)}
                                              spids: [749]
                                            )
                                          ]
                                          spids: [749]
                                        )
                                      ]
                                      spids: [741 746 753 16777215]
                                    )
                                    (case_arm
                                      pat_list: [
                                        {(edit)}
                                        {(unedit)}
                                        {(editors)}
                                        {(logout)}
                                        {(pserver)}
                                        {(server)}
                                        {(watch)}
                                        {(watchers)}
                                      ]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:mode)
                                              op: Equal
                                              rhs: {($ VSub_Name '$i')}
                                              spids: [774]
                                            )
                                          ]
                                          spids: [774]
                                        )
                                      ]
                                      spids: [756 771 778 16777215]
                                    )
                                    (case_arm
                                      pat_list: [{(history)} {(hi)} {(his)}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:mode)
                                              op: Equal
                                              rhs: {(history)}
                                              spids: [789]
                                            )
                                          ]
                                          spids: [789]
                                        )
                                      ]
                                      spids: [781 786 793 16777215]
                                    )
                                    (case_arm
                                      pat_list: [{(import)} {(im)} {(imp)}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:mode)
                                              op: Equal
                                              rhs: {(import)}
                                              spids: [804]
                                            )
                                          ]
                                          spids: [804]
                                        )
                                      ]
                                      spids: [796 801 808 16777215]
                                    )
                                    (case_arm
                                      pat_list: [{(log)} {(lo)} {(rlog)} {(rl)}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:mode)
                                              op: Equal
                                              rhs: {(log)}
                                              spids: [821]
                                            )
                                          ]
                                          spids: [821]
                                        )
                                      ]
                                      spids: [811 818 825 16777215]
                                    )
                                    (case_arm
                                      pat_list: [{(login)} {(logon)} {(lgn)}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:mode)
                                              op: Equal
                                              rhs: {(login)}
                                              spids: [836]
                                            )
                                          ]
                                          spids: [836]
                                        )
                                      ]
                                      spids: [828 833 840 16777215]
                                    )
                                    (case_arm
                                      pat_list: [{(rdiff)} {(patch)} {(pa)}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:mode)
                                              op: Equal
                                              rhs: {(rdiff)}
                                              spids: [851]
                                            )
                                          ]
                                          spids: [851]
                                        )
                                      ]
                                      spids: [843 848 855 16777215]
                                    )
                                    (case_arm
                                      pat_list: [{(release)} {(re)} {(rel)}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:mode)
                                              op: Equal
                                              rhs: {(release)}
                                              spids: [866]
                                            )
                                          ]
                                          spids: [866]
                                        )
                                      ]
                                      spids: [858 863 870 16777215]
                                    )
                                    (case_arm
                                      pat_list: [{(remove)} {(rm)} {(delete)}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:mode)
                                              op: Equal
                                              rhs: {(remove)}
                                              spids: [881]
                                            )
                                          ]
                                          spids: [881]
                                        )
                                      ]
                                      spids: [873 878 885 16777215]
                                    )
                                    (case_arm
                                      pat_list: [{(rtag)} {(rt)} {(rfreeze)}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:mode)
                                              op: Equal
                                              rhs: {(rtag)}
                                              spids: [896]
                                            )
                                          ]
                                          spids: [896]
                                        )
                                      ]
                                      spids: [888 893 900 16777215]
                                    )
                                    (case_arm
                                      pat_list: [{(status)} {(st)} {(stat)}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:mode)
                                              op: Equal
                                              rhs: {(status)}
                                              spids: [911]
                                            )
                                          ]
                                          spids: [911]
                                        )
                                      ]
                                      spids: [903 908 915 16777215]
                                    )
                                    (case_arm
                                      pat_list: [{(tag)} {(ta)} {(freeze)}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:mode)
                                              op: Equal
                                              rhs: {(tag)}
                                              spids: [926]
                                            )
                                          ]
                                          spids: [926]
                                        )
                                      ]
                                      spids: [918 923 930 16777215]
                                    )
                                    (case_arm
                                      pat_list: [{(update)} {(up)} {(upd)}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:mode)
                                              op: Equal
                                              rhs: {(update)}
                                              spids: [941]
                                            )
                                          ]
                                          spids: [941]
                                        )
                                      ]
                                      spids: [933 938 945 16777215]
                                    )
                                    (case_arm
                                      pat_list: [{(version)} {(ve)} {(ver)}]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:mode)
                                              op: Equal
                                              rhs: {(version)}
                                              spids: [956]
                                            )
                                          ]
                                          spids: [956]
                                        )
                                      ]
                                      spids: [948 953 960 16777215]
                                    )
                                  ]
                                  spids: [570 574 963]
                                )
                              ]
                              spids: [16777215 567]
                            )
                            (if_arm
                              cond: [
                                (Sentence
                                  child: 
                                    (DBracket
                                      expr: 
                                        (BoolBinary
                                          op_id: BoolBinary_GlobDEqual
                                          left: {(DQ ($ VSub_Name '$i'))}
                                          right: {(-) (Lit_Other '*')}
                                        )
                                    )
                                  terminator: <Op_Semi ';'>
                                )
                              ]
                              action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:flags)
                                      op: PlusEqual
                                      rhs: {(ArrayLiteralPart words:[{($ VSub_Name '$i')}])}
                                      spids: [985]
                                    )
                                  ]
                                  spids: [985]
                                )
                              ]
                              spids: [966 982]
                            )
                          ]
                          spids: [16777215 993]
                        )
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:count)
                              op: Equal
                              rhs: 
                                {
                                  (ArithSubPart
                                    anode: (UnaryAssign op_id:Arith_DPlus child:(LhsName name:count))
                                    spids: [997 1001]
                                  )
                                }
                              spids: [996]
                            )
                          ]
                          spids: [996]
                        )
                      ]
                      spids: [487 1004]
                    )
                  spids: [476 485]
                )
                (Case
                  to_match: {($ VSub_Name '$mode')}
                  arms: [
                    (case_arm
                      pat_list: [{(add)}]
                      action: [
                        (Case
                          to_match: {($ VSub_Name '$prev')}
                          arms: [
                            (case_arm
                              pat_list: [{(-m)}]
                              action: [(ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})]
                              spids: [1026 1027 1035 16777215]
                            )
                            (case_arm
                              pat_list: [{(-k)}]
                              action: [
                                (C {(_cvs_kflags)})
                                (ControlFlow
                                  token: <ControlFlow_Return return>
                                  arg_word: {(0)}
                                )
                              ]
                              spids: [1038 1039 1050 16777215]
                            )
                          ]
                          spids: [1019 1023 1053]
                        )
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (Sentence
                                  child: 
                                    (DBracket
                                      expr: 
                                        (BoolBinary
                                          op_id: BoolBinary_GlobNEqual
                                          left: {(DQ ($ VSub_Name '$cur'))}
                                          right: {(-) (Lit_Other '*')}
                                        )
                                    )
                                  terminator: <Op_Semi ';'>
                                )
                              ]
                              action: [
                                (C {(_cvs_entries)})
                                (AndOr
                                  ops: [Op_DAmp Op_DPipe]
                                  children: [
                                    (DBracket
                                      expr: (BoolUnary op_id:BoolUnary_z child:{($ VSub_Name '$cur')})
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:files)
                                          op: Equal
                                          rhs: 
                                            {
                                              (ArrayLiteralPart
                                                words: [
                                                  {
                                                    (ExtGlobPart
                                                      op: <ExtGlob_Bang '!('>
                                                      spids: [1092 1094]
                                                    )
                                                  }
                                                ]
                                              )
                                            }
                                          spids: [1089]
                                        )
                                      ]
                                      spids: [1089]
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:files)
                                          op: Equal
                                          rhs: 
                                            {
                                              (ArrayLiteralPart
                                                words: [
                                                  {
                                                    (CommandSubPart
                                                      command_list: 
                                                        (CommandList
                                                          children: [
                                                            (SimpleCommand
                                                              words: [
                                                                {(command)}
                                                                {(ls)}
                                                                {(-d)}
                                                                {(${ VSub_Name cur) (Lit_Other '*')}
                                                              ]
                                                              redirects: [
                                                                (Redir
                                                                  op: <Redir_Great '2>'>
                                                                  fd: 2
                                                                  arg_word: {(/dev/null)}
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                      left_token: <Left_CommandSub '$('>
                                                      spids: [1105 1121]
                                                    )
                                                  }
                                                ]
                                              )
                                            }
                                          spids: [1102]
                                        )
                                      ]
                                      spids: [1102]
                                    )
                                  ]
                                )
                                (Assignment
                                  keyword: Assign_Local
                                  pairs: [(assign_pair lhs:(LhsName name:f) op:Equal spids:[1128])]
                                  spids: [1126]
                                )
                                (ForEach
                                  iter_name: i
                                  iter_words: [
                                    {
                                      (BracedVarSub
                                        token: <VSub_Name files>
                                        prefix_op: VSub_Bang
                                        bracket_op: (WholeArray op_id:Lit_At)
                                        spids: [1137 1143]
                                      )
                                    }
                                  ]
                                  do_arg_iter: F
                                  body: 
                                    (DoGroup
                                      children: [
                                        (If
                                          arms: [
                                            (if_arm
                                              cond: [
                                                (Sentence
                                                  child: 
                                                    (DBracket
                                                      expr: 
                                                        (BoolBinary
                                                          op_id: BoolBinary_GlobDEqual
                                                          left: 
                                                            {
                                                              (BracedVarSub
                                                                token: <VSub_Name files>
                                                                bracket_op: 
                                                                  (ArrayIndex
                                                                    expr: (ArithVarRef name:i)
                                                                  )
                                                                spids: [1153 1158]
                                                              )
                                                            }
                                                          right: 
                                                            {
                                                              (ExtGlobPart
                                                                op: <ExtGlob_QMark '?('>
                                                                spids: [1162 1165]
                                                              ) (CVS)
                                                            }
                                                        )
                                                    )
                                                  terminator: <Op_Semi ';'>
                                                )
                                              ]
                                              action: [(C {(unset)} {(SQ <'files[i]'>)})]
                                              spids: [16777215 1171]
                                            )
                                          ]
                                          else_action: [
                                            (ForEach
                                              iter_name: f
                                              iter_words: [
                                                {
                                                  (DQ 
                                                    (BracedVarSub
                                                      token: <VSub_Name entries>
                                                      bracket_op: (WholeArray op_id:Lit_At)
                                                      spids: [1191 1196]
                                                    )
                                                  )
                                                }
                                              ]
                                              do_arg_iter: F
                                              body: 
                                                (DoGroup
                                                  children: [
                                                    (If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (Sentence
                                                              child: 
                                                                (DBracket
                                                                  expr: 
                                                                    (LogicalAnd
                                                                      left: 
                                                                        (BoolBinary
                                                                          op_id: 
BoolBinary_GlobDEqual
                                                                          left: 
                                                                            {
                                                                              (BracedVarSub
                                                                                token: 
                                                                                  <VSub_Name files>
                                                                                bracket_op: 
                                                                                  (ArrayIndex
                                                                                    expr: 
                                                                                      (ArithVarRef
                                                                                        name: i
                                                                                      )
                                                                                  )
                                                                                spids: [1207 1212]
                                                                              )
                                                                            }
                                                                          right: {($ VSub_Name '$f')}
                                                                        )
                                                                      right: 
                                                                        (LogicalNot
                                                                          child: 
                                                                            (BoolUnary
                                                                              op_id: BoolUnary_d
                                                                              child: 
                                                                                {($ VSub_Name '$f')}
                                                                            )
                                                                        )
                                                                    )
                                                                )
                                                              terminator: <Op_Semi ';'>
                                                            )
                                                          ]
                                                          action: [
                                                            (C {(unset)} {(SQ <'files[i]'>)})
                                                            (ControlFlow
                                                              token: <ControlFlow_Break break>
                                                            )
                                                          ]
                                                          spids: [16777215 1229]
                                                        )
                                                      ]
                                                      spids: [16777215 1242]
                                                    )
                                                  ]
                                                  spids: [1200 1245]
                                                )
                                              spids: [1189 1198]
                                            )
                                          ]
                                          spids: [1181 1248]
                                        )
                                      ]
                                      spids: [1146 1251]
                                    )
                                  spids: [1136 1144]
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:COMPREPLY)
                                      op: Equal
                                      rhs: 
                                        {
                                          (ArrayLiteralPart
                                            words: [
                                              {
                                                (CommandSubPart
                                                  command_list: 
                                                    (CommandList
                                                      children: [
                                                        (C {(compgen)} {(-X)} 
                                                          {(DQ ($ VSub_Name '$_backup_glob'))} {(-W)} {(SQ <'${files[@]}'>)} {(--)} {(DQ ($ VSub_Name '$cur'))}
                                                        )
                                                      ]
                                                    )
                                                  left_token: <Left_CommandSub '$('>
                                                  spids: [1257 1281]
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [1254]
                                    )
                                  ]
                                  spids: [1254]
                                )
                              ]
                              spids: [16777215 1073]
                            )
                          ]
                          else_action: [
                            (C {(_cvs_command_options)} {(DQ ($ VSub_Number '$1'))} 
                              {($ VSub_Name '$mode')}
                            )
                          ]
                          spids: [1286 1298]
                        )
                      ]
                      spids: [1015 1016 1301 16777215]
                    )
                    (case_arm
                      pat_list: [{(admin)}]
                      action: [
                        (Case
                          to_match: {($ VSub_Name '$prev')}
                          arms: [
                            (case_arm
                              pat_list: [
                                {(-a)}
                                {(-A)}
                                {(-b)}
                                {(-c)}
                                {(-e)}
                                {(-l)}
                                {(-m)}
                                {(-n)}
                                {(-N)}
                                {(-o)}
                                {(-s)}
                                {(-t-)}
                                {(-u)}
                              ]
                              action: [(ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})]
                              spids: [1315 1340 1348 16777215]
                            )
                            (case_arm
                              pat_list: [{(-t)}]
                              action: [
                                (C {(_filedir)})
                                (ControlFlow
                                  token: <ControlFlow_Return return>
                                  arg_word: {(0)}
                                )
                              ]
                              spids: [1351 1352 1363 16777215]
                            )
                            (case_arm
                              pat_list: [{(-k)}]
                              action: [
                                (C {(_cvs_kflags)})
                                (ControlFlow
                                  token: <ControlFlow_Return return>
                                  arg_word: {(0)}
                                )
                              ]
                              spids: [1366 1367 1378 16777215]
                            )
                          ]
                          spids: [1308 1312 1381]
                        )
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (Sentence
                                  child: 
                                    (DBracket
                                      expr: 
                                        (BoolBinary
                                          op_id: BoolBinary_GlobDEqual
                                          left: {(DQ ($ VSub_Name '$cur'))}
                                          right: {(-) (Lit_Other '*')}
                                        )
                                    )
                                  terminator: <Op_Semi ';'>
                                )
                              ]
                              action: [
                                (C {(_cvs_command_options)} {(DQ ($ VSub_Number '$1'))} 
                                  {($ VSub_Name '$mode')}
                                )
                              ]
                              spids: [16777215 1401]
                            )
                          ]
                          else_action: [
                            (C {(_cvs_entries)})
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:COMPREPLY)
                                  op: Equal
                                  rhs: 
                                    {
                                      (ArrayLiteralPart
                                        words: [
                                          {
                                            (CommandSubPart
                                              command_list: 
                                                (CommandList
                                                  children: [
                                                    (C {(compgen)} {(-W)} {(SQ <'${entries[@]}'>)} {(--)} 
                                                      {(DQ ($ VSub_Name '$cur'))}
                                                    )
                                                  ]
                                                )
                                              left_token: <Left_CommandSub '$('>
                                              spids: [1422 1438]
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [1419]
                                )
                              ]
                              spids: [1419]
                            )
                          ]
                          spids: [1413 1443]
                        )
                      ]
                      spids: [1304 1305 1446 16777215]
                    )
                    (case_arm
                      pat_list: [{(annotate)}]
                      action: [
                        (AndOr
                          ops: [Op_DAmp]
                          children: [
                            (DBracket
                              expr: 
                                (BoolBinary
                                  op_id: BoolBinary_GlobDEqual
                                  left: {(DQ ($ VSub_Name '$prev'))}
                                  right: {(-) (Lit_Other '[') (rD) (Lit_Other ']')}
                                )
                            )
                            (ControlFlow
                              token: <ControlFlow_Return return>
                              arg_word: {(0)}
                            )
                          ]
                        )
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (Sentence
                                  child: 
                                    (DBracket
                                      expr: 
                                        (BoolBinary
                                          op_id: BoolBinary_GlobDEqual
                                          left: {(DQ ($ VSub_Name '$cur'))}
                                          right: {(-) (Lit_Other '*')}
                                        )
                                    )
                                  terminator: <Op_Semi ';'>
                                )
                              ]
                              action: [
                                (C {(_cvs_command_options)} {(DQ ($ VSub_Number '$1'))} 
                                  {($ VSub_Name '$mode')}
                                )
                              ]
                              spids: [16777215 1492]
                            )
                          ]
                          else_action: [
                            (C {(_cvs_entries)})
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:COMPREPLY)
                                  op: Equal
                                  rhs: 
                                    {
                                      (ArrayLiteralPart
                                        words: [
                                          {
                                            (CommandSubPart
                                              command_list: 
                                                (CommandList
                                                  children: [
                                                    (C {(compgen)} {(-W)} {(SQ <'${entries[@]}'>)} {(--)} 
                                                      {(DQ ($ VSub_Name '$cur'))}
                                                    )
                                                  ]
                                                )
                                              left_token: <Left_CommandSub '$('>
                                              spids: [1513 1529]
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [1510]
                                )
                              ]
                              spids: [1510]
                            )
                          ]
                          spids: [1504 1534]
                        )
                      ]
                      spids: [1449 1450 1537 16777215]
                    )
                    (case_arm
                      pat_list: [{(checkout)}]
                      action: [
                        (Case
                          to_match: {($ VSub_Name '$prev')}
                          arms: [
                            (case_arm
                              pat_list: [{(-r)} {(-D)} {(-j)}]
                              action: [(ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})]
                              spids: [1551 1556 1564 16777215]
                            )
                            (case_arm
                              pat_list: [{(-d)}]
                              action: [
                                (C {(_filedir)} {(-d)})
                                (ControlFlow
                                  token: <ControlFlow_Return return>
                                  arg_word: {(0)}
                                )
                              ]
                              spids: [1567 1568 1581 16777215]
                            )
                            (case_arm
                              pat_list: [{(-k)}]
                              action: [
                                (C {(_cvs_kflags)})
                                (ControlFlow
                                  token: <ControlFlow_Return return>
                                  arg_word: {(0)}
                                )
                              ]
                              spids: [1584 1585 1596 16777215]
                            )
                          ]
                          spids: [1544 1548 1599]
                        )
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (Sentence
                                  child: 
                                    (DBracket
                                      expr: 
                                        (BoolBinary
                                          op_id: BoolBinary_GlobNEqual
                                          left: {(DQ ($ VSub_Name '$cur'))}
                                          right: {(-) (Lit_Other '*')}
                                        )
                                    )
                                  terminator: <Op_Semi ';'>
                                )
                              ]
                              action: [
                                (AndOr
                                  ops: [Op_DAmp]
                                  children: [
                                    (DBracket
                                      expr: 
                                        (BoolUnary
                                          op_id: BoolUnary_z
                                          child: {($ VSub_Name '$cvsroot')}
                                        )
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:cvsroot)
                                          op: Equal
                                          rhs: {($ VSub_Name '$CVSROOT')}
                                          spids: [1632]
                                        )
                                      ]
                                      spids: [1632]
                                    )
                                  ]
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:COMPREPLY)
                                      op: Equal
                                      rhs: 
                                        {
                                          (ArrayLiteralPart
                                            words: [
                                              {
                                                (CommandSubPart
                                                  command_list: 
                                                    (CommandList
                                                      children: [
                                                        (Pipeline
                                                          children: [
                                                            (SimpleCommand
                                                              words: [
                                                                {(cvs)}
                                                                {(-d)}
                                                                {(DQ ($ VSub_Name '$cvsroot'))}
                                                                {(co)}
                                                                {(-c)}
                                                              ]
                                                              redirects: [
                                                                (Redir
                                                                  op: <Redir_Great '2>'>
                                                                  fd: 2
                                                                  arg_word: {(/dev/null)}
                                                                )
                                                              ]
                                                            )
                                                            (C {(awk)} {(SQ <'{print $1}'>)})
                                                          ]
                                                          negated: F
                                                        )
                                                      ]
                                                    )
                                                  left_token: <Left_CommandSub '$('>
                                                  spids: [1639 1667]
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [1636]
                                    )
                                  ]
                                  spids: [1636]
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:COMPREPLY)
                                      op: Equal
                                      rhs: 
                                        {
                                          (ArrayLiteralPart
                                            words: [
                                              {
                                                (CommandSubPart
                                                  command_list: 
                                                    (CommandList
                                                      children: [
                                                        (C {(compgen)} {(-W)} {(SQ <'${COMPREPLY[@]}'>)} 
                                                          {(--)} {(DQ ($ VSub_Name '$cur'))}
                                                        )
                                                      ]
                                                    )
                                                  left_token: <Left_CommandSub '$('>
                                                  spids: [1675 1691]
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [1672]
                                    )
                                  ]
                                  spids: [1672]
                                )
                              ]
                              spids: [16777215 1619]
                            )
                          ]
                          else_action: [
                            (C {(_cvs_command_options)} {(DQ ($ VSub_Number '$1'))} 
                              {($ VSub_Name '$mode')}
                            )
                          ]
                          spids: [1696 1708]
                        )
                      ]
                      spids: [1540 1541 1711 16777215]
                    )
                    (case_arm
                      pat_list: [{(commit)}]
                      action: [
                        (Case
                          to_match: {($ VSub_Name '$prev')}
                          arms: [
                            (case_arm
                              pat_list: [{(-m)} {(-r)}]
                              action: [(ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})]
                              spids: [1725 1728 1736 16777215]
                            )
                            (case_arm
                              pat_list: [{(-F)}]
                              action: [
                                (C {(_filedir)})
                                (ControlFlow
                                  token: <ControlFlow_Return return>
                                  arg_word: {(0)}
                                )
                              ]
                              spids: [1739 1740 1751 16777215]
                            )
                          ]
                          spids: [1718 1722 1754]
                        )
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (Sentence
                                  child: 
                                    (DBracket
                                      expr: 
                                        (BoolBinary
                                          op_id: BoolBinary_GlobNEqual
                                          left: {(DQ ($ VSub_Name '$cur'))}
                                          right: {(-) (Lit_Other '*')}
                                        )
                                    )
                                  terminator: <Op_Semi ';'>
                                )
                              ]
                              action: [
                                (If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (Sentence
                                          child: 
                                            (DBracket
                                              expr: 
                                                (BoolUnary
                                                  op_id: BoolUnary_n
                                                  child: 
                                                    {
                                                      (BracedVarSub
                                                        token: <VSub_Name COMP_CVS_REMOTE>
                                                        suffix_op: 
                                                          (StringUnary
                                                            op_id: VTest_ColonHyphen
                                                            arg_word: {}
                                                          )
                                                        spids: [1795 1798]
                                                      )
                                                    }
                                                )
                                            )
                                          terminator: <Op_Semi ';'>
                                        )
                                      ]
                                      action: [
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:changed)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (ArrayLiteralPart
                                                    words: [
                                                      {
                                                        (CommandSubPart
                                                          command_list: 
                                                            (CommandList
                                                              children: [
                                                                (Pipeline
                                                                  children: [
                                                                    (SimpleCommand
                                                                      words: [
                                                                        {(cvs)}
                                                                        {(-q)}
                                                                        {(diff)}
                                                                        {(--brief)}
                                                                      ]
                                                                      redirects: [
                                                                        (Redir
                                                                          op: <Redir_GreatAnd '2>&'>
                                                                          fd: 2
                                                                          arg_word: {(1)}
                                                                        )
                                                                      ]
                                                                    )
                                                                    (C {(sed)} {(-ne)} 
                                                                      {
                                                                        (SQ 
                                                                          <
's/^Files [^ ]* and \\([^ ]*\\) differ$/\\1/p'
                                                                          >
                                                                        )
                                                                      }
                                                                    )
                                                                  ]
                                                                  negated: F
                                                                )
                                                              ]
                                                            )
                                                          left_token: <Left_CommandSub '$('>
                                                          spids: [1821 1846]
                                                        )
                                                      }
                                                    ]
                                                  )
                                                }
                                              spids: [1818]
                                            )
                                          ]
                                          spids: [1818]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:newremoved)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (ArrayLiteralPart
                                                    words: [
                                                      {
                                                        (CommandSubPart
                                                          command_list: 
                                                            (CommandList
                                                              children: [
                                                                (Pipeline
                                                                  children: [
                                                                    (SimpleCommand
                                                                      words: [
                                                                        {(cvs)}
                                                                        {(-q)}
                                                                        {(diff)}
                                                                        {(--brief)}
                                                                      ]
                                                                      redirects: [
                                                                        (Redir
                                                                          op: <Redir_GreatAnd '2>&'>
                                                                          fd: 2
                                                                          arg_word: {(1)}
                                                                        )
                                                                      ]
                                                                    )
                                                                    (C {(sed)} {(-ne)} 
                                                                      {
                                                                        (SQ 
                                                                          <
's/^cvs diff: \\([^ ]*\\) .*, no comparison available$/\\1/p'
                                                                          >
                                                                        )
                                                                      }
                                                                    )
                                                                  ]
                                                                  negated: F
                                                                )
                                                              ]
                                                            )
                                                          left_token: <Left_CommandSub '$('>
                                                          spids: [1854 1879]
                                                        )
                                                      }
                                                    ]
                                                  )
                                                }
                                              spids: [1851]
                                            )
                                          ]
                                          spids: [1851]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:COMPREPLY)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (ArrayLiteralPart
                                                    words: [
                                                      {
                                                        (CommandSubPart
                                                          command_list: 
                                                            (CommandList
                                                              children: [
                                                                (C {(compgen)} {(-W)} 
                                                                  {
                                                                    (SQ <'${changed[@]:-} \\\n'> 
                                                                      <
'                        ${newremoved[@]:-}'
                                                                      >
                                                                    )
                                                                  } {(--)} {(DQ ($ VSub_Name '$cur'))}
                                                                )
                                                              ]
                                                            )
                                                          left_token: <Left_CommandSub '$('>
                                                          spids: [1887 1904]
                                                        )
                                                      }
                                                    ]
                                                  )
                                                }
                                              spids: [1884]
                                            )
                                          ]
                                          spids: [1884]
                                        )
                                      ]
                                      spids: [16777215 1803]
                                    )
                                  ]
                                  else_action: [
                                    (C {(_cvs_entries)})
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:COMPREPLY)
                                          op: Equal
                                          rhs: 
                                            {
                                              (ArrayLiteralPart
                                                words: [
                                                  {
                                                    (CommandSubPart
                                                      command_list: 
                                                        (CommandList
                                                          children: [
                                                            (C {(compgen)} {(-W)} 
                                                              {(SQ <'${entries[@]}'>)} {(--)} {(DQ ($ VSub_Name '$cur'))}
                                                            )
                                                          ]
                                                        )
                                                      left_token: <Left_CommandSub '$('>
                                                      spids: [1918 1934]
                                                    )
                                                  }
                                                ]
                                              )
                                            }
                                          spids: [1915]
                                        )
                                      ]
                                      spids: [1915]
                                    )
                                  ]
                                  spids: [1909 1939]
                                )
                              ]
                              spids: [16777215 1774]
                            )
                          ]
                          else_action: [
                            (C {(_cvs_command_options)} {(DQ ($ VSub_Number '$1'))} 
                              {($ VSub_Name '$mode')}
                            )
                          ]
                          spids: [1942 1954]
                        )
                      ]
                      spids: [1714 1715 1957 16777215]
                    )
                    (case_arm
                      pat_list: [{(cvsroot)}]
                      action: [(C {(_cvs_roots)})]
                      spids: [1960 1961 1967 16777215]
                    )
                    (case_arm
                      pat_list: [{(diff)}]
                      action: [
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (Sentence
                                  child: 
                                    (DBracket
                                      expr: 
                                        (BoolBinary
                                          op_id: BoolBinary_GlobDEqual
                                          left: {(DQ ($ VSub_Name '$cur'))}
                                          right: {(-) (Lit_Other '*')}
                                        )
                                    )
                                  terminator: <Op_Semi ';'>
                                )
                              ]
                              action: [
                                (C {(_cvs_command_options)} {(DQ ($ VSub_Number '$1'))} 
                                  {($ VSub_Name '$mode')}
                                )
                                (AndOr
                                  ops: [Op_DAmp]
                                  children: [
                                    (DBracket
                                      expr: 
                                        (BoolBinary
                                          op_id: BoolBinary_GlobDEqual
                                          left: {($ VSub_Name '$COMPREPLY')}
                                          right: {(Lit_Other '*') (BoolBinary_GlobEqual '=')}
                                        )
                                    )
                                    (C {(compopt)} {(-o)} {(nospace)})
                                  ]
                                )
                              ]
                              spids: [16777215 1990]
                            )
                          ]
                          else_action: [
                            (C {(_cvs_entries)})
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:COMPREPLY)
                                  op: Equal
                                  rhs: 
                                    {
                                      (ArrayLiteralPart
                                        words: [
                                          {
                                            (CommandSubPart
                                              command_list: 
                                                (CommandList
                                                  children: [
                                                    (C {(compgen)} {(-W)} {(SQ <'${entries[@]:-}'>)} 
                                                      {(--)} {(DQ ($ VSub_Name '$cur'))}
                                                    )
                                                  ]
                                                )
                                              left_token: <Left_CommandSub '$('>
                                              spids: [2031 2047]
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [2028]
                                )
                              ]
                              spids: [2028]
                            )
                          ]
                          spids: [2022 2052]
                        )
                      ]
                      spids: [1970 1971 2055 16777215]
                    )
                    (case_arm
                      pat_list: [{(editors)} {(watchers)}]
                      action: [
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (Sentence
                                  child: 
                                    (DBracket
                                      expr: 
                                        (BoolBinary
                                          op_id: BoolBinary_GlobDEqual
                                          left: {(DQ ($ VSub_Name '$cur'))}
                                          right: {(-) (Lit_Other '*')}
                                        )
                                    )
                                  terminator: <Op_Semi ';'>
                                )
                              ]
                              action: [
                                (C {(_cvs_command_options)} {(DQ ($ VSub_Number '$1'))} 
                                  {($ VSub_Name '$mode')}
                                )
                              ]
                              spids: [16777215 2080]
                            )
                          ]
                          else_action: [
                            (C {(_cvs_entries)})
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:COMPREPLY)
                                  op: Equal
                                  rhs: 
                                    {
                                      (ArrayLiteralPart
                                        words: [
                                          {
                                            (CommandSubPart
                                              command_list: 
                                                (CommandList
                                                  children: [
                                                    (C {(compgen)} {(-W)} {(SQ <'${entries[@]}'>)} {(--)} 
                                                      {(DQ ($ VSub_Name '$cur'))}
                                                    )
                                                  ]
                                                )
                                              left_token: <Left_CommandSub '$('>
                                              spids: [2101 2117]
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [2098]
                                )
                              ]
                              spids: [2098]
                            )
                          ]
                          spids: [2092 2122]
                        )
                      ]
                      spids: [2058 2061 2125 16777215]
                    )
                    (case_arm
                      pat_list: [{(export)}]
                      action: [
                        (Case
                          to_match: {($ VSub_Name '$prev')}
                          arms: [
                            (case_arm
                              pat_list: [{(-r)} {(-D)}]
                              action: [(ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})]
                              spids: [2139 2142 2150 16777215]
                            )
                            (case_arm
                              pat_list: [{(-d)}]
                              action: [
                                (C {(_filedir)} {(-d)})
                                (ControlFlow
                                  token: <ControlFlow_Return return>
                                  arg_word: {(0)}
                                )
                              ]
                              spids: [2153 2154 2167 16777215]
                            )
                            (case_arm
                              pat_list: [{(-k)}]
                              action: [
                                (C {(_cvs_kflags)})
                                (ControlFlow
                                  token: <ControlFlow_Return return>
                                  arg_word: {(0)}
                                )
                              ]
                              spids: [2170 2171 2182 16777215]
                            )
                          ]
                          spids: [2132 2136 2185]
                        )
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (Sentence
                                  child: 
                                    (DBracket
                                      expr: 
                                        (BoolBinary
                                          op_id: BoolBinary_GlobNEqual
                                          left: {(DQ ($ VSub_Name '$cur'))}
                                          right: {(-) (Lit_Other '*')}
                                        )
                                    )
                                  terminator: <Op_Semi ';'>
                                )
                              ]
                              action: [
                                (AndOr
                                  ops: [Op_DAmp]
                                  children: [
                                    (DBracket
                                      expr: 
                                        (BoolUnary
                                          op_id: BoolUnary_z
                                          child: {($ VSub_Name '$cvsroot')}
                                        )
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:cvsroot)
                                          op: Equal
                                          rhs: {($ VSub_Name '$CVSROOT')}
                                          spids: [2218]
                                        )
                                      ]
                                      spids: [2218]
                                    )
                                  ]
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:COMPREPLY)
                                      op: Equal
                                      rhs: 
                                        {
                                          (ArrayLiteralPart
                                            words: [
                                              {
                                                (CommandSubPart
                                                  command_list: 
                                                    (CommandList
                                                      children: [
                                                        (Pipeline
                                                          children: [
                                                            (C {(cvs)} {(-d)} 
                                                              {(DQ ($ VSub_Name '$cvsroot'))} {(co)} {(-c)}
                                                            )
                                                            (C {(awk)} {(SQ <'{print $1}'>)})
                                                          ]
                                                          negated: F
                                                        )
                                                      ]
                                                    )
                                                  left_token: <Left_CommandSub '$('>
                                                  spids: [2225 2247]
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [2222]
                                    )
                                  ]
                                  spids: [2222]
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:COMPREPLY)
                                      op: Equal
                                      rhs: 
                                        {
                                          (ArrayLiteralPart
                                            words: [
                                              {
                                                (CommandSubPart
                                                  command_list: 
                                                    (CommandList
                                                      children: [
                                                        (C {(compgen)} {(-W)} {(SQ <'${COMPREPLY[@]}'>)} 
                                                          {(--)} {(DQ ($ VSub_Name '$cur'))}
                                                        )
                                                      ]
                                                    )
                                                  left_token: <Left_CommandSub '$('>
                                                  spids: [2255 2271]
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [2252]
                                    )
                                  ]
                                  spids: [2252]
                                )
                              ]
                              spids: [16777215 2205]
                            )
                          ]
                          else_action: [
                            (C {(_cvs_command_options)} {(DQ ($ VSub_Number '$1'))} 
                              {($ VSub_Name '$mode')}
                            )
                          ]
                          spids: [2276 2288]
                        )
                      ]
                      spids: [2128 2129 2291 16777215]
                    )
                    (case_arm
                      pat_list: [{(import)}]
                      action: [
                        (Case
                          to_match: {($ VSub_Name '$prev')}
                          arms: [
                            (case_arm
                              pat_list: [{(-I)} {(-b)} {(-m)} {(-W)}]
                              action: [(ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})]
                              spids: [2305 2312 2320 16777215]
                            )
                            (case_arm
                              pat_list: [{(-k)}]
                              action: [
                                (C {(_cvs_kflags)})
                                (ControlFlow
                                  token: <ControlFlow_Return return>
                                  arg_word: {(0)}
                                )
                              ]
                              spids: [2323 2324 2335 16777215]
                            )
                          ]
                          spids: [2298 2302 2338]
                        )
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (Sentence
                                  child: 
                                    (DBracket
                                      expr: 
                                        (BoolBinary
                                          op_id: BoolBinary_GlobNEqual
                                          left: {(DQ ($ VSub_Name '$cur'))}
                                          right: {(-) (Lit_Other '*')}
                                        )
                                    )
                                  terminator: <Op_Semi ';'>
                                )
                              ]
                              action: [
                                (AndOr
                                  ops: [Op_DAmp]
                                  children: [
                                    (DBracket
                                      expr: 
                                        (BoolUnary
                                          op_id: BoolUnary_z
                                          child: {($ VSub_Name '$cvsroot')}
                                        )
                                    )
                                    (Assignment
                                      keyword: Assign_None
                                      pairs: [
                                        (assign_pair
                                          lhs: (LhsName name:cvsroot)
                                          op: Equal
                                          rhs: {($ VSub_Name '$CVSROOT')}
                                          spids: [2375]
                                        )
                                      ]
                                      spids: [2375]
                                    )
                                  ]
                                )
                                (Assignment
                                  keyword: Assign_Local
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:prefix)
                                      op: Equal
                                      rhs: 
                                        {
                                          (BracedVarSub
                                            token: <VSub_Name cur>
                                            suffix_op: 
                                              (StringUnary
                                                op_id: VOp1_Percent
                                                arg_word: {(Lit_Slash /) ('*')}
                                              )
                                            spids: [2382 2387]
                                          )
                                        }
                                      spids: [2381]
                                    )
                                  ]
                                  spids: [2379]
                                )
                                (If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (Sentence
                                          child: 
                                            (DBracket
                                              expr: 
                                                (BoolUnary
                                                  op_id: BoolUnary_r
                                                  child: 
                                                    {(${ VSub_Name cvsroot) (/) (${ VSub_Name prefix)}
                                                )
                                            )
                                          terminator: <Op_Semi ';'>
                                        )
                                      ]
                                      action: [
                                        (C {(_cvs_modules)})
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:COMPREPLY)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (ArrayLiteralPart
                                                    words: [
                                                      {
                                                        (BracedVarSub
                                                          token: <VSub_Name COMPREPLY>
                                                          bracket_op: (WholeArray op_id:Lit_At)
                                                          suffix_op: 
                                                            (StringUnary
                                                              op_id: VOp1_Pound
                                                              arg_word: {($ VSub_Name '$cvsroot')}
                                                            )
                                                          spids: [2416 2423]
                                                        )
                                                      }
                                                    ]
                                                  )
                                                }
                                              spids: [2413]
                                            )
                                          ]
                                          spids: [2413]
                                        )
                                        (Assignment
                                          keyword: Assign_None
                                          pairs: [
                                            (assign_pair
                                              lhs: (LhsName name:COMPREPLY)
                                              op: Equal
                                              rhs: 
                                                {
                                                  (ArrayLiteralPart
                                                    words: [
                                                      {
                                                        (BracedVarSub
                                                          token: <VSub_Name COMPREPLY>
                                                          bracket_op: (WholeArray op_id:Lit_At)
                                                          suffix_op: 
                                                            (StringUnary
                                                              op_id: VOp1_Pound
                                                              arg_word: 
                                                                {
                                                                  (EscapedLiteralPart
                                                                    token: <Lit_EscapedChar '\\/'>
                                                                  )
                                                                }
                                                            )
                                                          spids: [2431 2438]
                                                        )
                                                      }
                                                    ]
                                                  )
                                                }
                                              spids: [2428]
                                            )
                                          ]
                                          spids: [2428]
                                        )
                                      ]
                                      spids: [16777215 2407]
                                    )
                                  ]
                                  spids: [16777215 2443]
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:pwd)
                                      op: Equal
                                      rhs: 
                                        {
                                          (CommandSubPart
                                            command_list: (CommandList children:[(C {(pwd)})])
                                            left_token: <Left_CommandSub '$('>
                                            spids: [2447 2451]
                                          )
                                        }
                                      spids: [2446]
                                    )
                                  ]
                                  spids: [2446]
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:pwd)
                                      op: Equal
                                      rhs: 
                                        {
                                          (BracedVarSub
                                            token: <VSub_Name pwd>
                                            suffix_op: 
                                              (StringUnary
                                                op_id: VOp1_DPound
                                                arg_word: {('*') (Lit_Slash /)}
                                              )
                                            spids: [2455 2460]
                                          )
                                        }
                                      spids: [2454]
                                    )
                                  ]
                                  spids: [2454]
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:COMPREPLY)
                                      op: Equal
                                      rhs: 
                                        {
                                          (ArrayLiteralPart
                                            words: [
                                              {
                                                (CommandSubPart
                                                  command_list: 
                                                    (CommandList
                                                      children: [
                                                        (C {(compgen)} {(-W)} 
                                                          {(SQ <'${COMPREPLY[@]} $pwd'>)} {(--)} {(DQ ($ VSub_Name '$cur'))}
                                                        )
                                                      ]
                                                    )
                                                  left_token: <Left_CommandSub '$('>
                                                  spids: [2466 2482]
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [2463]
                                    )
                                  ]
                                  spids: [2463]
                                )
                              ]
                              spids: [16777215 2358]
                            )
                          ]
                          else_action: [
                            (C {(_cvs_command_options)} {(DQ ($ VSub_Number '$1'))} 
                              {($ VSub_Name '$mode')}
                            )
                          ]
                          spids: [2487 2499]
                        )
                      ]
                      spids: [2294 2295 2502 16777215]
                    )
                    (case_arm
                      pat_list: [{(remove)}]
                      action: [
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (Sentence
                                  child: 
                                    (DBracket
                                      expr: 
                                        (BoolBinary
                                          op_id: BoolBinary_GlobNEqual
                                          left: {(DQ ($ VSub_Name '$cur'))}
                                          right: {(-) (Lit_Other '*')}
                                        )
                                    )
                                  terminator: <Op_Semi ';'>
                                )
                              ]
                              action: [
                                (C {(_cvs_entries)})
                                (If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (Sentence
                                          child: 
                                            (DBracket
                                              expr: 
                                                (BoolBinary
                                                  op_id: BoolBinary_GlobNEqual
                                                  left: {(DQ ($ VSub_Name '$prev'))}
                                                  right: {(BoolUnary_f -f)}
                                                )
                                            )
                                          terminator: <Op_Semi ';'>
                                        )
                                      ]
                                      action: [
                                        (ForEach
                                          iter_name: i
                                          iter_words: [
                                            {
                                              (BracedVarSub
                                                token: <VSub_Name entries>
                                                prefix_op: VSub_Bang
                                                bracket_op: (WholeArray op_id:Lit_At)
                                                spids: [2559 2565]
                                              )
                                            }
                                          ]
                                          do_arg_iter: F
                                          body: 
                                            (DoGroup
                                              children: [
                                                (AndOr
                                                  ops: [Op_DAmp]
                                                  children: [
                                                    (DBracket
                                                      expr: 
                                                        (BoolUnary
                                                          op_id: BoolUnary_r
                                                          child: 
                                                            {
                                                              (DQ 
                                                                (BracedVarSub
                                                                  token: <VSub_Name entries>
                                                                  bracket_op: 
                                                                    (ArrayIndex
                                                                      expr: (ArithVarRef name:i)
                                                                    )
                                                                  spids: [2576 2581]
                                                                )
                                                              )
                                                            }
                                                        )
                                                    )
                                                    (C {(unset)} {(SQ <'entries[i]'>)})
                                                  ]
                                                )
                                              ]
                                              spids: [2568 2595]
                                            )
                                          spids: [2558 2566]
                                        )
                                      ]
                                      spids: [16777215 2546]
                                    )
                                  ]
                                  spids: [16777215 2598]
                                )
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:COMPREPLY)
                                      op: Equal
                                      rhs: 
                                        {
                                          (ArrayLiteralPart
                                            words: [
                                              {
                                                (CommandSubPart
                                                  command_list: 
                                                    (CommandList
                                                      children: [
                                                        (C {(compgen)} {(-W)} {(SQ <'${entries[@]:-}'>)} 
                                                          {(--)} {(DQ ($ VSub_Name '$cur'))}
                                                        )
                                                      ]
                                                    )
                                                  left_token: <Left_CommandSub '$('>
                                                  spids: [2604 2620]
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [2601]
                                    )
                                  ]
                                  spids: [2601]
                                )
                              ]
                              spids: [16777215 2525]
                            )
                          ]
                          else_action: [
                            (C {(_cvs_command_options)} {(DQ ($ VSub_Number '$1'))} 
                              {($ VSub_Name '$mode')}
                            )
                          ]
                          spids: [2625 2637]
                        )
                      ]
                      spids: [2505 2506 2640 16777215]
                    )
                    (case_arm
                      pat_list: [{(update)}]
                      action: [
                        (Case
                          to_match: {($ VSub_Name '$prev')}
                          arms: [
                            (case_arm
                              pat_list: [{(-r)} {(-D)} {(-j)} {(-I)} {(-W)}]
                              action: [(ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})]
                              spids: [2654 2663 2671 16777215]
                            )
                            (case_arm
                              pat_list: [{(-k)}]
                              action: [
                                (C {(_cvs_kflags)})
                                (ControlFlow
                                  token: <ControlFlow_Return return>
                                  arg_word: {(0)}
                                )
                              ]
                              spids: [2674 2675 2686 16777215]
                            )
                          ]
                          spids: [2647 2651 2689]
                        )
                        (If
                          arms: [
                            (if_arm
                              cond: [
                                (Sentence
                                  child: 
                                    (DBracket
                                      expr: 
                                        (BoolBinary
                                          op_id: BoolBinary_GlobDEqual
                                          left: {(DQ ($ VSub_Name '$cur'))}
                                          right: {(-) (Lit_Other '*')}
                                        )
                                    )
                                  terminator: <Op_Semi ';'>
                                )
                              ]
                              action: [
                                (C {(_cvs_command_options)} {(DQ ($ VSub_Number '$1'))} 
                                  {($ VSub_Name '$mode')}
                                )
                              ]
                              spids: [16777215 2709]
                            )
                          ]
                          else_action: [
                            (C {(_cvs_entries)})
                            (Assignment
                              keyword: Assign_None
                              pairs: [
                                (assign_pair
                                  lhs: (LhsName name:COMPREPLY)
                                  op: Equal
                                  rhs: 
                                    {
                                      (ArrayLiteralPart
                                        words: [
                                          {
                                            (CommandSubPart
                                              command_list: 
                                                (CommandList
                                                  children: [
                                                    (C {(compgen)} {(-W)} {(SQ <'${entries[@]}'>)} {(--)} 
                                                      {(DQ ($ VSub_Name '$cur'))}
                                                    )
                                                  ]
                                                )
                                              left_token: <Left_CommandSub '$('>
                                              spids: [2730 2746]
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [2727]
                                )
                              ]
                              spids: [2727]
                            )
                          ]
                          spids: [2721 2751]
                        )
                      ]
                      spids: [2643 2644 2754 16777215]
                    )
                    (case_arm
                      pat_list: [{(DQ )}]
                      action: [
                        (Case
                          to_match: {($ VSub_Name '$prev')}
                          arms: [
                            (case_arm
                              pat_list: [{(-T)}]
                              action: [
                                (C {(_filedir)} {(-d)})
                                (ControlFlow
                                  token: <ControlFlow_Return return>
                                  arg_word: {(0)}
                                )
                              ]
                              spids: [2769 2770 2783 16777215]
                            )
                            (case_arm
                              pat_list: [{(-e)} {(-s)}]
                              action: [(ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})]
                              spids: [2786 2789 2797 16777215]
                            )
                            (case_arm
                              pat_list: [{(-z)}]
                              action: [
                                (Assignment
                                  keyword: Assign_None
                                  pairs: [
                                    (assign_pair
                                      lhs: (LhsName name:COMPREPLY)
                                      op: Equal
                                      rhs: 
                                        {
                                          (ArrayLiteralPart
                                            words: [
                                              {
                                                (CommandSubPart
                                                  command_list: 
                                                    (CommandList
                                                      children: [
                                                        (C {(compgen)} {(-W)} {(SQ <'{1..9}'>)} {(--)} 
                                                          {(DQ ($ VSub_Name '$cur'))}
                                                        )
                                                      ]
                                                    )
                                                  left_token: <Left_CommandSub '$('>
                                                  spids: [2807 2823]
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [2804]
                                    )
                                  ]
                                  spids: [2804]
                                )
                                (ControlFlow
                                  token: <ControlFlow_Return return>
                                  arg_word: {(0)}
                                )
                              ]
                              spids: [2800 2801 2833 16777215]
                            )
                          ]
                          spids: [2762 2766 2836]
                        )
                        (Assignment
                          keyword: Assign_None
                          pairs: [
                            (assign_pair
                              lhs: (LhsName name:COMPREPLY)
                              op: Equal
                              rhs: 
                                {
                                  (ArrayLiteralPart
                                    words: [
                                      {
                                        (CommandSubPart
                                          command_list: 
                                            (CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} 
                                                  {
                                                    (SQ <'$( _cvs_commands )\n'> 
                                                      <
'                $( _parse_help "$1" --help-options ) --help --help-commands\n'
                                                      > <'                --help-options --version'>
                                                    )
                                                  } {(--)} {(DQ ($ VSub_Name '$cur'))}
                                                )
                                              ]
                                            )
                                          left_token: <Left_CommandSub '$('>
                                          spids: [2843 2861]
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [2840]
                            )
                          ]
                          spids: [2840]
                        )
                      ]
                      spids: [2757 2759 2866 16777215]
                    )
                  ]
                  spids: [1008 1012 2869]
                )
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(0)})
              ]
              spids: [410]
            )
          spids: [406 409]
        )
        (C {(complete)} {(-F)} {(_cvs)} {(cvs)})
      ]
    )
  ]
)