(command.CommandList
  children: [
    (command.ShFunction
      name: _cvs_entries
      body: 
        (command.BraceGroup
          children: [
            (C {(local)} 
              {(Id.Lit_VarLike 'prefix=') 
                (braced_var_sub
                  token: (Token id:Id.VSub_Name val:cur span_id:15)
                  suffix_op: (suffix_op.Unary op_id:Id.VOp1_Percent arg_word:{(Id.Lit_Slash /) ('*')})
                ) (/)
              } 
              {(Id.Lit_VarLike 'IFS=') 
                (single_quoted
                  left: (Token id:Id.Left_SingleQuoteC val:"$'" span_id:23)
                  tokens: [(Token id:Id.Char_OneChar val:'\\n' span_id:24)]
                )
              }
            )
            (command.AndOr
              ops: [Id.Op_DPipe]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.Unary
                      op_id: Id.BoolUnary_e
                      child: 
                        {
                          (braced_var_sub
                            token: (Token id:Id.VSub_Name val:prefix span_id:33)
                            suffix_op: (suffix_op.Unary op_id:Id.VTest_ColonHyphen arg_word:{})
                          ) (CVS/Entries)
                        }
                    )
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:prefix)
                      op: assign_op.Equal
                      rhs: {(DQ )}
                      spids: [42]
                    )
                  ]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:entries)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (sh_array_literal
                        left: (Token id:Id.Op_LParen val:'(' span_id:48)
                        words: [
                          {
                            (command_sub
                              left_token: (Token id:Id.Left_DollarParen val:'$(' span_id:50)
                              command_list: 
                                (command.CommandList
                                  children: [
                                    (command.Simple
                                      words: [
                                        {(cut)}
                                        {(-d/)}
                                        {(-f2)}
                                        {(-s)}
                                        {
                                          (braced_var_sub
                                            token: (Token id:Id.VSub_Name val:prefix span_id:61)
                                            suffix_op: (suffix_op.Unary op_id:Id.VTest_ColonHyphen arg_word:{})
                                          ) (CVS/Entries)
                                        }
                                      ]
                                      redirects: [
                                        (redir.Redir
                                          op: (Token id:Id.Redir_Great val:'2>' span_id:66)
                                          fd: 2
                                          arg_word: {(/dev/null)}
                                        )
                                      ]
                                    )
                                  ]
                                )
                            )
                          }
                        ]
                      )
                    }
                  spids: [47]
                )
              ]
            )
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: (bool_expr.WordTest w:{($ Id.VSub_DollarName '$entries')})
                        )
                      terminator: (Token id:Id.Op_Semi val:';' span_id:81)
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:entries)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (sh_array_literal
                                left: (Token id:Id.Op_LParen val:'(' span_id:87)
                                words: [
                                  {
                                    (DQ 
                                      (braced_var_sub
                                        token: (Token id:Id.VSub_Name val:entries span_id:91)
                                        bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                                        suffix_op: 
                                          (suffix_op.PatSub
                                            pat: {}
                                            replace: 
                                              {
                                                (braced_var_sub
                                                  token: 
                                                    (Token
                                                      id: Id.VSub_Name
                                                      val: prefix
                                                      span_id: 99
                                                    )
                                                  suffix_op: 
                                                    (suffix_op.Unary
                                                      op_id: Id.VTest_ColonHyphen
                                                      arg_word: {}
                                                    )
                                                )
                                              }
                                            replace_mode: Id.Lit_Pound
                                          )
                                      )
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [86]
                        )
                      ]
                    )
                    (C {(compopt)} {(-o)} {(filenames)})
                  ]
                  spids: [74 83]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: _cvs_modules
      body: 
        (command.BraceGroup
          children: [
            (command.If
              arms: [
                (if_arm
                  cond: [
                    (command.Sentence
                      child: 
                        (command.DBracket
                          expr: 
                            (bool_expr.Unary
                              op_id: Id.BoolUnary_n
                              child: {($ Id.VSub_DollarName '$prefix')}
                            )
                        )
                      terminator: (Token id:Id.Op_Semi val:';' span_id:136)
                    )
                  ]
                  action: [
                    (command.ShAssignment
                      pairs: [
                        (assign_pair
                          lhs: (sh_lhs_expr.Name name:COMPREPLY)
                          op: assign_op.Equal
                          rhs: 
                            {
                              (sh_array_literal
                                left: (Token id:Id.Op_LParen val:'(' span_id:142)
                                words: [
                                  {
                                    (command_sub
                                      left_token: (Token id:Id.Left_DollarParen val:'$(' span_id:144)
                                      command_list: 
                                        (command.CommandList
                                          children: [
                                            (C {(command)} {(ls)} {(-d)} 
                                              {(${ Id.VSub_Name cvsroot) (/) (${ Id.VSub_Name prefix) 
                                                (/) (word_part.ExtGlob op:(Token id:Id.ExtGlob_Bang val:'!(' span_id:160) arms:[{(CVSROOT)}])
                                              }
                                            )
                                          ]
                                        )
                                    )
                                  }
                                ]
                              )
                            }
                          spids: [141]
                        )
                      ]
                    )
                  ]
                  spids: [127 138]
                )
              ]
              else_action: [
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:COMPREPLY)
                      op: assign_op.Equal
                      rhs: 
                        {
                          (sh_array_literal
                            left: (Token id:Id.Op_LParen val:'(' span_id:173)
                            words: [
                              {
                                (command_sub
                                  left_token: (Token id:Id.Left_DollarParen val:'$(' span_id:175)
                                  command_list: 
                                    (command.CommandList
                                      children: [
                                        (C {(command)} {(ls)} {(-d)} 
                                          {(${ Id.VSub_Name cvsroot) (/) 
                                            (word_part.ExtGlob
                                              op: (Token id:Id.ExtGlob_Bang val:'!(' span_id:187)
                                              arms: [{(CVSROOT)}]
                                            )
                                          }
                                        )
                                      ]
                                    )
                                )
                              }
                            ]
                          )
                        }
                      spids: [172]
                    )
                  ]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: _cvs_commands
      body: 
        (command.BraceGroup
          children: [
            (command.Pipeline
              children: [
                (command.Simple
                  words: [{(cvs)} {(--help-commands)}]
                  redirects: [
                    (redir.Redir
                      op: (Token id:Id.Redir_GreatAnd val:'2>&' span_id:212)
                      fd: 2
                      arg_word: {(1)}
                    )
                  ]
                )
                (C {(awk)} {(SQ (Token id:Id.Lit_Chars val:'/^(     *|\\t)/ { print $1 }' span_id:220))})
              ]
              negated: F
            )
          ]
        )
    )
    (command.ShFunction
      name: _cvs_command_options
      body: 
        (command.BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (sh_array_literal
                        left: (Token id:Id.Op_LParen val:'(' span_id:234)
                        words: [
                          {
                            (command_sub
                              left_token: (Token id:Id.Left_DollarParen val:'$(' span_id:236)
                              command_list: 
                                (command.CommandList
                                  children: [
                                    (C {(compgen)} {(-W)} 
                                      {
                                        (SQ 
                                          (Token
                                            id: Id.Lit_Chars
                                            val: '$( _parse_help "$1" "--help $2" )'
                                            span_id: 243
                                          )
                                        )
                                      } {(--)} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                    )
                                  ]
                                )
                            )
                          }
                        ]
                      )
                    }
                  spids: [233]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: _cvs_kflags
      body: 
        (command.BraceGroup
          children: [
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (sh_array_literal
                        left: (Token id:Id.Op_LParen val:'(' span_id:267)
                        words: [
                          {
                            (command_sub
                              left_token: (Token id:Id.Left_DollarParen val:'$(' span_id:269)
                              command_list: 
                                (command.CommandList
                                  children: [
                                    (C {(compgen)} {(-W)} 
                                      {(SQ (Token id:Id.Lit_Chars val:'kv kvl k o b v' span_id:276))} {(--)} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                    )
                                  ]
                                )
                            )
                          }
                        ]
                      )
                    }
                  spids: [266]
                )
              ]
            )
          ]
        )
    )
    (command.ShFunction
      name: _cvs_roots
      body: 
        (command.BraceGroup
          children: [
            (C {(local)} {(-a)} {(cvsroots)})
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:cvsroots)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (sh_array_literal
                        left: (Token id:Id.Op_LParen val:'(' span_id:307)
                        words: [{($ Id.VSub_DollarName '$CVSROOT')}]
                      )
                    }
                  spids: [306]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.DBracket
                  expr: 
                    (bool_expr.Unary
                      op_id: Id.BoolUnary_r
                      child: {(Id.Lit_TildeLike '~') (/.cvspass)}
                    )
                )
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:cvsroots)
                      op: assign_op.PlusEqual
                      rhs: 
                        {
                          (sh_array_literal
                            left: (Token id:Id.Op_LParen val:'(' span_id:326)
                            words: [
                              {
                                (command_sub
                                  left_token: (Token id:Id.Left_DollarParen val:'$(' span_id:328)
                                  command_list: 
                                    (command.CommandList
                                      children: [
                                        (C {(awk)} 
                                          {
                                            (SQ 
                                              (Token
                                                id: Id.Lit_Chars
                                                val: '{ print $2 }'
                                                span_id: 333
                                              )
                                            )
                                          } {(word_part.TildeSub token:(Token id:Id.Lit_TildeLike val:'~' span_id:336)) (/.cvspass)}
                                        )
                                      ]
                                    )
                                )
                              }
                            ]
                          )
                        }
                      spids: [325]
                    )
                  ]
                )
              ]
            )
            (command.AndOr
              ops: [Id.Op_DAmp]
              children: [
                (command.DBracket
                  expr: (bool_expr.Unary op_id:Id.BoolUnary_r child:{(CVS/Root)})
                )
                (command.Simple
                  words: [
                    {(mapfile)}
                    {(-tO)}
                    {
                      (braced_var_sub
                        token: (Token id:Id.VSub_Name val:cvsroots span_id:360)
                        prefix_op: (Id.VSub_Pound)
                        bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                      )
                    }
                    {(cvsroots)}
                  ]
                  redirects: [
                    (redir.Redir
                      op: (Token id:Id.Redir_Less val:'<' span_id:368)
                      fd: -1
                      arg_word: {(CVS/Root)}
                    )
                  ]
                )
              ]
            )
            (command.ShAssignment
              pairs: [
                (assign_pair
                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                  op: assign_op.Equal
                  rhs: 
                    {
                      (sh_array_literal
                        left: (Token id:Id.Op_LParen val:'(' span_id:374)
                        words: [
                          {
                            (command_sub
                              left_token: (Token id:Id.Left_DollarParen val:'$(' span_id:376)
                              command_list: 
                                (command.CommandList
                                  children: [
                                    (C {(compgen)} {(-W)} 
                                      {(SQ (Token id:Id.Lit_Chars val:'${cvsroots[@]}' span_id:383))} {(--)} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                    )
                                  ]
                                )
                            )
                          }
                        ]
                      )
                    }
                  spids: [373]
                )
              ]
            )
            (C {(__ltrim_colon_completions)} {(DQ ($ Id.VSub_DollarName '$cur'))})
          ]
        )
    )
    (command.AndOr
      ops: [Id.Op_DAmp]
      children: [
        (command.ShFunction
          name: _cvs
          body: 
            (command.BraceGroup
              children: [
                (C {(local)} {(cur)} {(prev)} {(words)} {(cword)})
                (command.AndOr
                  ops: [Id.Op_DPipe]
                  children: [
                    (C {(_init_completion)} {(-n)} {(Id.Lit_Other ':')})
                    (command.ControlFlow
                      token: (Token id:Id.ControlFlow_Return val:return span_id:432)
                    )
                  ]
                )
                (C {(local)} {(count)} {(mode)} {(i)} {(cvsroot)} {(cvsroots)} {(pwd)})
                (C {(local)} {(-a)} {(flags)} {(files)} {(entries)} {(changed)} {(newremoved)})
                (command.ShAssignment
                  pairs: [
                    (assign_pair
                      lhs: (sh_lhs_expr.Name name:count)
                      op: assign_op.Equal
                      rhs: {(0)}
                      spids: [467]
                    )
                  ]
                )
                (command.ForEach
                  iter_name: i
                  iter_words: [
                    {
                      (DQ 
                        (braced_var_sub
                          token: (Token id:Id.VSub_Name val:words span_id:479)
                          bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                        )
                      )
                    }
                  ]
                  do_arg_iter: F
                  body: 
                    (command.DoGroup
                      children: [
                        (command.AndOr
                          ops: [Id.Op_DAmp]
                          children: [
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_eq
                                  left: {($ Id.VSub_DollarName '$count')}
                                  right: {($ Id.VSub_DollarName '$cword')}
                                )
                            )
                            (command.ControlFlow
                              token: (Token id:Id.ControlFlow_Break val:break span_id:502)
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.LogicalAnd
                                          left: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobDEqual
                                              left: 
                                                {
                                                  (DQ 
                                                    (braced_var_sub
                                                      token: 
                                                        (Token
                                                          id: Id.VSub_Name
                                                          val: words
                                                          span_id: 515
                                                        )
                                                      bracket_op: 
                                                        (bracket_op.ArrayIndex
                                                          expr: 
                                                            (arith_expr.VarRef
                                                              token: 
                                                                (Token
                                                                  id: Id.Lit_ArithVarLike
                                                                  val: count
                                                                  span_id: 519
                                                                )
                                                            )
                                                        )
                                                    )
                                                  )
                                                }
                                              right: {(DQ ($ Id.VSub_DollarName '$cvsroot'))}
                                            )
                                          right: 
                                            (bool_expr.Binary
                                              op_id: Id.BoolBinary_GlobDEqual
                                              left: {(DQ ($ Id.VSub_DollarName '$mode'))}
                                              right: {(cvsroot)}
                                            )
                                        )
                                    )
                                  terminator: (Token id:Id.Op_Semi val:';' span_id:543)
                                )
                              ]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:mode)
                                      op: assign_op.Equal
                                      rhs: {(DQ )}
                                      spids: [548]
                                    )
                                  ]
                                )
                              ]
                              spids: [509 545]
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_z
                                          child: {($ Id.VSub_DollarName '$mode')}
                                        )
                                    )
                                  terminator: (Token id:Id.Op_Semi val:';' span_id:565)
                                )
                              ]
                              action: [
                                (command.Case
                                  to_match: {($ Id.VSub_DollarName '$i')}
                                  arms: [
                                    (case_arm
                                      pat_list: [{(-H)} {(--help)}]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                              op: assign_op.Equal
                                              rhs: 
                                                {
                                                  (sh_array_literal
                                                    left: (Token id:Id.Op_LParen val:'(' span_id:584)
                                                    words: [
                                                      {
                                                        (command_sub
                                                          left_token: 
                                                            (Token
                                                              id: Id.Left_DollarParen
                                                              val: '$('
                                                              span_id: 586
                                                            )
                                                          command_list: 
                                                            (command.CommandList
                                                              children: [
                                                                (C {(compgen)} {(-W)} 
                                                                  {
                                                                    (DQ 
                                                                      (command_sub
                                                                        left_token: 
                                                                          (Token
                                                                            id: Id.Left_DollarParen
                                                                            val: '$('
                                                                            span_id: 593
                                                                          )
                                                                        command_list: 
                                                                          (command.CommandList
                                                                            children: [
                                                                              (C {(_cvs_commands)})
                                                                            ]
                                                                          )
                                                                      )
                                                                    )
                                                                  } {(--)} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                                )
                                                              ]
                                                            )
                                                        )
                                                      }
                                                    ]
                                                  )
                                                }
                                              spids: [583]
                                            )
                                          ]
                                        )
                                        (command.ControlFlow
                                          token: 
                                            (Token
                                              id: Id.ControlFlow_Return
                                              val: return
                                              span_id: 611
                                            )
                                          arg_word: {(0)}
                                        )
                                      ]
                                      spids: [577 580 616 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(-d)}]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:mode)
                                              op: assign_op.Equal
                                              rhs: {(cvsroot)}
                                              spids: [623]
                                            )
                                          ]
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:cvsroot)
                                              op: assign_op.Equal
                                              rhs: 
                                                {
                                                  (braced_var_sub
                                                    token: 
                                                      (Token
                                                        id: Id.VSub_Name
                                                        val: words
                                                        span_id: 629
                                                      )
                                                    bracket_op: 
                                                      (bracket_op.ArrayIndex
                                                        expr: 
                                                          (arith_expr.Binary
                                                            op_id: Id.Arith_Plus
                                                            left: 
                                                              (arith_expr.VarRef
                                                                token: 
                                                                  (Token
                                                                    id: Id.Lit_ArithVarLike
                                                                    val: count
                                                                    span_id: 633
                                                                  )
                                                              )
                                                            right: 
                                                              (arith_expr.ArithWord
                                                                w: {(Id.Lit_Digits 1)}
                                                              )
                                                          )
                                                      )
                                                  )
                                                }
                                              spids: [627]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [619 620 642 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(add)} {(ad)} {(new)}]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:mode)
                                              op: assign_op.Equal
                                              rhs: {(add)}
                                              spids: [653]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [645 650 657 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(admin)} {(adm)} {(rcs)}]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:mode)
                                              op: assign_op.Equal
                                              rhs: {(admin)}
                                              spids: [668]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [660 665 672 -1]
                                    )
                                    (case_arm
                                      pat_list: [
                                        {(annotate)}
                                        {(ann)}
                                        {(blame)}
                                        {(rannotate)}
                                        {(rann)}
                                        {(ra)}
                                      ]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:mode)
                                              op: assign_op.Equal
                                              rhs: {(annotate)}
                                              spids: [689]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [675 686 693 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(checkout)} {(co)} {(get)}]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:mode)
                                              op: assign_op.Equal
                                              rhs: {(checkout)}
                                              spids: [704]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [696 701 708 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(commit)} {(ci)} {(com)}]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:mode)
                                              op: assign_op.Equal
                                              rhs: {(commit)}
                                              spids: [719]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [711 716 723 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(diff)} {(di)} {(dif)}]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:mode)
                                              op: assign_op.Equal
                                              rhs: {(diff)}
                                              spids: [734]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [726 731 738 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(export)} {(ex)} {(exp)}]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:mode)
                                              op: assign_op.Equal
                                              rhs: {(export)}
                                              spids: [749]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [741 746 753 -1]
                                    )
                                    (case_arm
                                      pat_list: [
                                        {(edit)}
                                        {(unedit)}
                                        {(editors)}
                                        {(logout)}
                                        {(pserver)}
                                        {(server)}
                                        {(watch)}
                                        {(watchers)}
                                      ]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:mode)
                                              op: assign_op.Equal
                                              rhs: {($ Id.VSub_DollarName '$i')}
                                              spids: [774]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [756 771 778 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(history)} {(hi)} {(his)}]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:mode)
                                              op: assign_op.Equal
                                              rhs: {(history)}
                                              spids: [789]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [781 786 793 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(import)} {(im)} {(imp)}]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:mode)
                                              op: assign_op.Equal
                                              rhs: {(import)}
                                              spids: [804]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [796 801 808 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(log)} {(lo)} {(rlog)} {(rl)}]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:mode)
                                              op: assign_op.Equal
                                              rhs: {(log)}
                                              spids: [821]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [811 818 825 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(login)} {(logon)} {(lgn)}]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:mode)
                                              op: assign_op.Equal
                                              rhs: {(login)}
                                              spids: [836]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [828 833 840 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(rdiff)} {(patch)} {(pa)}]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:mode)
                                              op: assign_op.Equal
                                              rhs: {(rdiff)}
                                              spids: [851]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [843 848 855 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(release)} {(re)} {(rel)}]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:mode)
                                              op: assign_op.Equal
                                              rhs: {(release)}
                                              spids: [866]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [858 863 870 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(remove)} {(rm)} {(delete)}]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:mode)
                                              op: assign_op.Equal
                                              rhs: {(remove)}
                                              spids: [881]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [873 878 885 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(rtag)} {(rt)} {(rfreeze)}]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:mode)
                                              op: assign_op.Equal
                                              rhs: {(rtag)}
                                              spids: [896]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [888 893 900 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(status)} {(st)} {(stat)}]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:mode)
                                              op: assign_op.Equal
                                              rhs: {(status)}
                                              spids: [911]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [903 908 915 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(tag)} {(ta)} {(freeze)}]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:mode)
                                              op: assign_op.Equal
                                              rhs: {(tag)}
                                              spids: [926]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [918 923 930 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(update)} {(up)} {(upd)}]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:mode)
                                              op: assign_op.Equal
                                              rhs: {(update)}
                                              spids: [941]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [933 938 945 -1]
                                    )
                                    (case_arm
                                      pat_list: [{(version)} {(ve)} {(ver)}]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:mode)
                                              op: assign_op.Equal
                                              rhs: {(version)}
                                              spids: [956]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [948 953 960 -1]
                                    )
                                  ]
                                )
                              ]
                              spids: [556 567]
                            )
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobDEqual
                                          left: {(DQ ($ Id.VSub_DollarName '$i'))}
                                          right: {(-) (Id.Lit_Other '*')}
                                        )
                                    )
                                  terminator: (Token id:Id.Op_Semi val:';' span_id:980)
                                )
                              ]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:flags)
                                      op: assign_op.PlusEqual
                                      rhs: 
                                        {
                                          (sh_array_literal
                                            left: (Token id:Id.Op_LParen val:'(' span_id:986)
                                            words: [{($ Id.VSub_DollarName '$i')}]
                                          )
                                        }
                                      spids: [985]
                                    )
                                  ]
                                )
                              ]
                              spids: [966 982]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:count)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (word_part.ArithSub
                                    anode: 
                                      (arith_expr.UnaryAssign
                                        op_id: Id.Arith_DPlus
                                        child: (sh_lhs_expr.Name name:count)
                                      )
                                  )
                                }
                              spids: [996]
                            )
                          ]
                        )
                      ]
                    )
                )
                (command.Case
                  to_match: {($ Id.VSub_DollarName '$mode')}
                  arms: [
                    (case_arm
                      pat_list: [{(add)}]
                      action: [
                        (command.Case
                          to_match: {($ Id.VSub_DollarName '$prev')}
                          arms: [
                            (case_arm
                              pat_list: [{(-m)}]
                              action: [
                                (command.ControlFlow
                                  token: (Token id:Id.ControlFlow_Return val:return span_id:1030)
                                  arg_word: {(0)}
                                )
                              ]
                              spids: [1026 1027 1035 -1]
                            )
                            (case_arm
                              pat_list: [{(-k)}]
                              action: [
                                (C {(_cvs_kflags)})
                                (command.ControlFlow
                                  token: (Token id:Id.ControlFlow_Return val:return span_id:1045)
                                  arg_word: {(0)}
                                )
                              ]
                              spids: [1038 1039 1050 -1]
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobNEqual
                                          left: {(DQ ($ Id.VSub_DollarName '$cur'))}
                                          right: {(-) (Id.Lit_Other '*')}
                                        )
                                    )
                                  terminator: (Token id:Id.Op_Semi val:';' span_id:1071)
                                )
                              ]
                              action: [
                                (C {(_cvs_entries)})
                                (command.AndOr
                                  ops: [Id.Op_DAmp Id.Op_DPipe]
                                  children: [
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_z
                                          child: {($ Id.VSub_DollarName '$cur')}
                                        )
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:files)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (sh_array_literal
                                                left: (Token id:Id.Op_LParen val:'(' span_id:1090)
                                                words: [
                                                  {
                                                    (word_part.ExtGlob
                                                      op: 
                                                        (Token
                                                          id: Id.ExtGlob_Bang
                                                          val: '!('
                                                          span_id: 1092
                                                        )
                                                      arms: [{(CVS)}]
                                                    )
                                                  }
                                                ]
                                              )
                                            }
                                          spids: [1089]
                                        )
                                      ]
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:files)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (sh_array_literal
                                                left: (Token id:Id.Op_LParen val:'(' span_id:1103)
                                                words: [
                                                  {
                                                    (command_sub
                                                      left_token: 
                                                        (Token
                                                          id: Id.Left_DollarParen
                                                          val: '$('
                                                          span_id: 1105
                                                        )
                                                      command_list: 
                                                        (command.CommandList
                                                          children: [
                                                            (command.Simple
                                                              words: [
                                                                {(command)}
                                                                {(ls)}
                                                                {(-d)}
                                                                {(${ Id.VSub_Name cur) 
                                                                  (Id.Lit_Star '*')
                                                                }
                                                              ]
                                                              redirects: [
                                                                (redir.Redir
                                                                  op: 
                                                                    (Token
                                                                      id: Id.Redir_Great
                                                                      val: '2>'
                                                                      span_id: 1118
                                                                    )
                                                                  fd: 2
                                                                  arg_word: {(/dev/null)}
                                                                )
                                                              ]
                                                            )
                                                          ]
                                                        )
                                                    )
                                                  }
                                                ]
                                              )
                                            }
                                          spids: [1102]
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (C {(local)} {(f)})
                                (command.ForEach
                                  iter_name: i
                                  iter_words: [
                                    {
                                      (braced_var_sub
                                        token: (Token id:Id.VSub_Name val:files span_id:1139)
                                        prefix_op: (Id.VSub_Bang)
                                        bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                                      )
                                    }
                                  ]
                                  do_arg_iter: F
                                  body: 
                                    (command.DoGroup
                                      children: [
                                        (command.If
                                          arms: [
                                            (if_arm
                                              cond: [
                                                (command.Sentence
                                                  child: 
                                                    (command.DBracket
                                                      expr: 
                                                        (bool_expr.Binary
                                                          op_id: Id.BoolBinary_GlobDEqual
                                                          left: 
                                                            {
                                                              (braced_var_sub
                                                                token: 
                                                                  (Token
                                                                    id: Id.VSub_Name
                                                                    val: files
                                                                    span_id: 1154
                                                                  )
                                                                bracket_op: 
                                                                  (bracket_op.ArrayIndex
                                                                    expr: 
                                                                      (arith_expr.VarRef
                                                                        token: 
                                                                          (Token
                                                                            id: Id.Lit_ArithVarLike
                                                                            val: i
                                                                            span_id: 1156
                                                                          )
                                                                      )
                                                                  )
                                                              )
                                                            }
                                                          right: 
                                                            {
                                                              (word_part.ExtGlob
                                                                op: 
                                                                  (Token
                                                                    id: Id.ExtGlob_QMark
                                                                    val: '?('
                                                                    span_id: 1162
                                                                  )
                                                                arms: [{(Id.Lit_Other '*') (/)}]
                                                              ) (CVS)
                                                            }
                                                        )
                                                    )
                                                  terminator: 
                                                    (Token
                                                      id: Id.Op_Semi
                                                      val: ';'
                                                      span_id: 1169
                                                    )
                                                )
                                              ]
                                              action: [
                                                (C {(unset)} 
                                                  {
                                                    (SQ 
                                                      (Token
                                                        id: Id.Lit_Chars
                                                        val: 'files[i]'
                                                        span_id: 1177
                                                      )
                                                    )
                                                  }
                                                )
                                              ]
                                              spids: [1149 1171]
                                            )
                                          ]
                                          else_action: [
                                            (command.ForEach
                                              iter_name: f
                                              iter_words: [
                                                {
                                                  (DQ 
                                                    (braced_var_sub
                                                      token: 
                                                        (Token
                                                          id: Id.VSub_Name
                                                          val: entries
                                                          span_id: 1192
                                                        )
                                                      bracket_op: 
                                                        (bracket_op.WholeArray
                                                          op_id: Id.Lit_At
                                                        )
                                                    )
                                                  )
                                                }
                                              ]
                                              do_arg_iter: F
                                              body: 
                                                (command.DoGroup
                                                  children: [
                                                    (command.If
                                                      arms: [
                                                        (if_arm
                                                          cond: [
                                                            (command.Sentence
                                                              child: 
                                                                (command.DBracket
                                                                  expr: 
                                                                    (bool_expr.LogicalAnd
                                                                      left: 
                                                                        (bool_expr.Binary
                                                                          op_id: 
Id.BoolBinary_GlobDEqual
                                                                          left: 
                                                                            {
                                                                              (braced_var_sub
                                                                                token: 
                                                                                  (Token
                                                                                    id: Id.VSub_Name
                                                                                    val: files
                                                                                    span_id: 1208
                                                                                  )
                                                                                bracket_op: 
                                                                                  (bracket_op.ArrayIndex
                                                                                    expr: 
                                                                                      (arith_expr.VarRef
                                                                                        token: 
                                                                                          (Token
                                                                                            id: 
Id.Lit_ArithVarLike
                                                                                            val: i
                                                                                            span_id: 
1210
                                                                                          )
                                                                                      )
                                                                                  )
                                                                              )
                                                                            }
                                                                          right: 
                                                                            {
                                                                              ($ Id.VSub_DollarName 
'$f'
                                                                              )
                                                                            }
                                                                        )
                                                                      right: 
                                                                        (bool_expr.LogicalNot
                                                                          child: 
                                                                            (bool_expr.Unary
                                                                              op_id: Id.BoolUnary_d
                                                                              child: 
                                                                                {
                                                                                  ($ 
Id.VSub_DollarName '$f'
                                                                                  )
                                                                                }
                                                                            )
                                                                        )
                                                                    )
                                                                )
                                                              terminator: 
                                                                (Token
                                                                  id: Id.Op_Semi
                                                                  val: ';'
                                                                  span_id: 1227
                                                                )
                                                            )
                                                          ]
                                                          action: [
                                                            (C {(unset)} 
                                                              {
                                                                (SQ 
                                                                  (Token
                                                                    id: Id.Lit_Chars
                                                                    val: 'files[i]'
                                                                    span_id: 1235
                                                                  )
                                                                )
                                                              }
                                                            )
                                                            (command.ControlFlow
                                                              token: 
                                                                (Token
                                                                  id: Id.ControlFlow_Break
                                                                  val: break
                                                                  span_id: 1239
                                                                )
                                                            )
                                                          ]
                                                          spids: [1203 1229]
                                                        )
                                                      ]
                                                    )
                                                  ]
                                                )
                                            )
                                          ]
                                        )
                                      ]
                                    )
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (sh_array_literal
                                            left: (Token id:Id.Op_LParen val:'(' span_id:1255)
                                            words: [
                                              {
                                                (command_sub
                                                  left_token: 
                                                    (Token
                                                      id: Id.Left_DollarParen
                                                      val: '$('
                                                      span_id: 1257
                                                    )
                                                  command_list: 
                                                    (command.CommandList
                                                      children: [
                                                        (C {(compgen)} {(-X)} 
                                                          {
                                                            (DQ 
                                                              ($ Id.VSub_DollarName '$_backup_glob')
                                                            )
                                                          } {(-W)} {(SQ (Token id:Id.Lit_Chars val:'${files[@]}' span_id:1270))} {(--)} 
                                                          {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                        )
                                                      ]
                                                    )
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [1254]
                                    )
                                  ]
                                )
                              ]
                              spids: [1057 1073]
                            )
                          ]
                          else_action: [
                            (C {(_cvs_command_options)} {(DQ ($ Id.VSub_Number '$1'))} 
                              {($ Id.VSub_DollarName '$mode')}
                            )
                          ]
                        )
                      ]
                      spids: [1015 1016 1301 -1]
                    )
                    (case_arm
                      pat_list: [{(admin)}]
                      action: [
                        (command.Case
                          to_match: {($ Id.VSub_DollarName '$prev')}
                          arms: [
                            (case_arm
                              pat_list: [
                                {(-a)}
                                {(-A)}
                                {(-b)}
                                {(-c)}
                                {(-e)}
                                {(-l)}
                                {(-m)}
                                {(-n)}
                                {(-N)}
                                {(-o)}
                                {(-s)}
                                {(-t-)}
                                {(-u)}
                              ]
                              action: [
                                (command.ControlFlow
                                  token: (Token id:Id.ControlFlow_Return val:return span_id:1343)
                                  arg_word: {(0)}
                                )
                              ]
                              spids: [1315 1340 1348 -1]
                            )
                            (case_arm
                              pat_list: [{(-t)}]
                              action: [
                                (C {(_filedir)})
                                (command.ControlFlow
                                  token: (Token id:Id.ControlFlow_Return val:return span_id:1358)
                                  arg_word: {(0)}
                                )
                              ]
                              spids: [1351 1352 1363 -1]
                            )
                            (case_arm
                              pat_list: [{(-k)}]
                              action: [
                                (C {(_cvs_kflags)})
                                (command.ControlFlow
                                  token: (Token id:Id.ControlFlow_Return val:return span_id:1373)
                                  arg_word: {(0)}
                                )
                              ]
                              spids: [1366 1367 1378 -1]
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobDEqual
                                          left: {(DQ ($ Id.VSub_DollarName '$cur'))}
                                          right: {(-) (Id.Lit_Other '*')}
                                        )
                                    )
                                  terminator: (Token id:Id.Op_Semi val:';' span_id:1399)
                                )
                              ]
                              action: [
                                (C {(_cvs_command_options)} {(DQ ($ Id.VSub_Number '$1'))} 
                                  {($ Id.VSub_DollarName '$mode')}
                                )
                              ]
                              spids: [1385 1401]
                            )
                          ]
                          else_action: [
                            (C {(_cvs_entries)})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: (Token id:Id.Op_LParen val:'(' span_id:1420)
                                        words: [
                                          {
                                            (command_sub
                                              left_token: 
                                                (Token
                                                  id: Id.Left_DollarParen
                                                  val: '$('
                                                  span_id: 1422
                                                )
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (C {(compgen)} {(-W)} 
                                                      {
                                                        (SQ 
                                                          (Token
                                                            id: Id.Lit_Chars
                                                            val: '${entries[@]}'
                                                            span_id: 1429
                                                          )
                                                        )
                                                      } {(--)} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                    )
                                                  ]
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [1419]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                      spids: [1304 1305 1446 -1]
                    )
                    (case_arm
                      pat_list: [{(annotate)}]
                      action: [
                        (command.AndOr
                          ops: [Id.Op_DAmp]
                          children: [
                            (command.DBracket
                              expr: 
                                (bool_expr.Binary
                                  op_id: Id.BoolBinary_GlobDEqual
                                  left: {(DQ ($ Id.VSub_DollarName '$prev'))}
                                  right: {(-) (Id.Lit_Other '[') (rD) (Id.Lit_Other ']')}
                                )
                            )
                            (command.ControlFlow
                              token: (Token id:Id.ControlFlow_Return val:return span_id:1470)
                              arg_word: {(0)}
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobDEqual
                                          left: {(DQ ($ Id.VSub_DollarName '$cur'))}
                                          right: {(-) (Id.Lit_Other '*')}
                                        )
                                    )
                                  terminator: (Token id:Id.Op_Semi val:';' span_id:1490)
                                )
                              ]
                              action: [
                                (C {(_cvs_command_options)} {(DQ ($ Id.VSub_Number '$1'))} 
                                  {($ Id.VSub_DollarName '$mode')}
                                )
                              ]
                              spids: [1476 1492]
                            )
                          ]
                          else_action: [
                            (C {(_cvs_entries)})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: (Token id:Id.Op_LParen val:'(' span_id:1511)
                                        words: [
                                          {
                                            (command_sub
                                              left_token: 
                                                (Token
                                                  id: Id.Left_DollarParen
                                                  val: '$('
                                                  span_id: 1513
                                                )
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (C {(compgen)} {(-W)} 
                                                      {
                                                        (SQ 
                                                          (Token
                                                            id: Id.Lit_Chars
                                                            val: '${entries[@]}'
                                                            span_id: 1520
                                                          )
                                                        )
                                                      } {(--)} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                    )
                                                  ]
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [1510]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                      spids: [1449 1450 1537 -1]
                    )
                    (case_arm
                      pat_list: [{(checkout)}]
                      action: [
                        (command.Case
                          to_match: {($ Id.VSub_DollarName '$prev')}
                          arms: [
                            (case_arm
                              pat_list: [{(-r)} {(-D)} {(-j)}]
                              action: [
                                (command.ControlFlow
                                  token: (Token id:Id.ControlFlow_Return val:return span_id:1559)
                                  arg_word: {(0)}
                                )
                              ]
                              spids: [1551 1556 1564 -1]
                            )
                            (case_arm
                              pat_list: [{(-d)}]
                              action: [
                                (C {(_filedir)} {(-d)})
                                (command.ControlFlow
                                  token: (Token id:Id.ControlFlow_Return val:return span_id:1576)
                                  arg_word: {(0)}
                                )
                              ]
                              spids: [1567 1568 1581 -1]
                            )
                            (case_arm
                              pat_list: [{(-k)}]
                              action: [
                                (C {(_cvs_kflags)})
                                (command.ControlFlow
                                  token: (Token id:Id.ControlFlow_Return val:return span_id:1591)
                                  arg_word: {(0)}
                                )
                              ]
                              spids: [1584 1585 1596 -1]
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobNEqual
                                          left: {(DQ ($ Id.VSub_DollarName '$cur'))}
                                          right: {(-) (Id.Lit_Other '*')}
                                        )
                                    )
                                  terminator: (Token id:Id.Op_Semi val:';' span_id:1617)
                                )
                              ]
                              action: [
                                (command.AndOr
                                  ops: [Id.Op_DAmp]
                                  children: [
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_z
                                          child: {($ Id.VSub_DollarName '$cvsroot')}
                                        )
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:cvsroot)
                                          op: assign_op.Equal
                                          rhs: {($ Id.VSub_DollarName '$CVSROOT')}
                                          spids: [1632]
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (sh_array_literal
                                            left: (Token id:Id.Op_LParen val:'(' span_id:1637)
                                            words: [
                                              {
                                                (command_sub
                                                  left_token: 
                                                    (Token
                                                      id: Id.Left_DollarParen
                                                      val: '$('
                                                      span_id: 1639
                                                    )
                                                  command_list: 
                                                    (command.CommandList
                                                      children: [
                                                        (command.Pipeline
                                                          children: [
                                                            (command.Simple
                                                              words: [
                                                                {(cvs)}
                                                                {(-d)}
                                                                {
                                                                  (DQ 
                                                                    ($ Id.VSub_DollarName '$cvsroot')
                                                                  )
                                                                }
                                                                {(co)}
                                                                {(-c)}
                                                              ]
                                                              redirects: [
                                                                (redir.Redir
                                                                  op: 
                                                                    (Token
                                                                      id: Id.Redir_Great
                                                                      val: '2>'
                                                                      span_id: 1653
                                                                    )
                                                                  fd: 2
                                                                  arg_word: {(/dev/null)}
                                                                )
                                                              ]
                                                            )
                                                            (C {(awk)} 
                                                              {
                                                                (SQ 
                                                                  (Token
                                                                    id: Id.Lit_Chars
                                                                    val: '{print $1}'
                                                                    span_id: 1664
                                                                  )
                                                                )
                                                              }
                                                            )
                                                          ]
                                                          negated: F
                                                        )
                                                      ]
                                                    )
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [1636]
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (sh_array_literal
                                            left: (Token id:Id.Op_LParen val:'(' span_id:1673)
                                            words: [
                                              {
                                                (command_sub
                                                  left_token: 
                                                    (Token
                                                      id: Id.Left_DollarParen
                                                      val: '$('
                                                      span_id: 1675
                                                    )
                                                  command_list: 
                                                    (command.CommandList
                                                      children: [
                                                        (C {(compgen)} {(-W)} 
                                                          {
                                                            (SQ 
                                                              (Token
                                                                id: Id.Lit_Chars
                                                                val: '${COMPREPLY[@]}'
                                                                span_id: 1682
                                                              )
                                                            )
                                                          } {(--)} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                        )
                                                      ]
                                                    )
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [1672]
                                    )
                                  ]
                                )
                              ]
                              spids: [1603 1619]
                            )
                          ]
                          else_action: [
                            (C {(_cvs_command_options)} {(DQ ($ Id.VSub_Number '$1'))} 
                              {($ Id.VSub_DollarName '$mode')}
                            )
                          ]
                        )
                      ]
                      spids: [1540 1541 1711 -1]
                    )
                    (case_arm
                      pat_list: [{(commit)}]
                      action: [
                        (command.Case
                          to_match: {($ Id.VSub_DollarName '$prev')}
                          arms: [
                            (case_arm
                              pat_list: [{(-m)} {(-r)}]
                              action: [
                                (command.ControlFlow
                                  token: (Token id:Id.ControlFlow_Return val:return span_id:1731)
                                  arg_word: {(0)}
                                )
                              ]
                              spids: [1725 1728 1736 -1]
                            )
                            (case_arm
                              pat_list: [{(-F)}]
                              action: [
                                (C {(_filedir)})
                                (command.ControlFlow
                                  token: (Token id:Id.ControlFlow_Return val:return span_id:1746)
                                  arg_word: {(0)}
                                )
                              ]
                              spids: [1739 1740 1751 -1]
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobNEqual
                                          left: {(DQ ($ Id.VSub_DollarName '$cur'))}
                                          right: {(-) (Id.Lit_Other '*')}
                                        )
                                    )
                                  terminator: (Token id:Id.Op_Semi val:';' span_id:1772)
                                )
                              ]
                              action: [
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (command.Sentence
                                          child: 
                                            (command.DBracket
                                              expr: 
                                                (bool_expr.Unary
                                                  op_id: Id.BoolUnary_n
                                                  child: 
                                                    {
                                                      (braced_var_sub
                                                        token: 
                                                          (Token
                                                            id: Id.VSub_Name
                                                            val: COMP_CVS_REMOTE
                                                            span_id: 1796
                                                          )
                                                        suffix_op: 
                                                          (suffix_op.Unary
                                                            op_id: Id.VTest_ColonHyphen
                                                            arg_word: {}
                                                          )
                                                      )
                                                    }
                                                )
                                            )
                                          terminator: (Token id:Id.Op_Semi val:';' span_id:1801)
                                        )
                                      ]
                                      action: [
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:changed)
                                              op: assign_op.Equal
                                              rhs: 
                                                {
                                                  (sh_array_literal
                                                    left: 
                                                      (Token
                                                        id: Id.Op_LParen
                                                        val: '('
                                                        span_id: 1819
                                                      )
                                                    words: [
                                                      {
                                                        (command_sub
                                                          left_token: 
                                                            (Token
                                                              id: Id.Left_DollarParen
                                                              val: '$('
                                                              span_id: 1821
                                                            )
                                                          command_list: 
                                                            (command.CommandList
                                                              children: [
                                                                (command.Pipeline
                                                                  children: [
                                                                    (command.Simple
                                                                      words: [
                                                                        {(cvs)}
                                                                        {(-q)}
                                                                        {(diff)}
                                                                        {(--brief)}
                                                                      ]
                                                                      redirects: [
                                                                        (redir.Redir
                                                                          op: 
                                                                            (Token
                                                                              id: Id.Redir_GreatAnd
                                                                              val: '2>&'
                                                                              span_id: 1831
                                                                            )
                                                                          fd: 2
                                                                          arg_word: {(1)}
                                                                        )
                                                                      ]
                                                                    )
                                                                    (C {(sed)} {(-ne)} 
                                                                      {
                                                                        (SQ 
                                                                          (Token
                                                                            id: Id.Lit_Chars
                                                                            val: 
's/^Files [^ ]* and \\([^ ]*\\) differ$/\\1/p'
                                                                            span_id: 1843
                                                                          )
                                                                        )
                                                                      }
                                                                    )
                                                                  ]
                                                                  negated: F
                                                                )
                                                              ]
                                                            )
                                                        )
                                                      }
                                                    ]
                                                  )
                                                }
                                              spids: [1818]
                                            )
                                          ]
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:newremoved)
                                              op: assign_op.Equal
                                              rhs: 
                                                {
                                                  (sh_array_literal
                                                    left: 
                                                      (Token
                                                        id: Id.Op_LParen
                                                        val: '('
                                                        span_id: 1852
                                                      )
                                                    words: [
                                                      {
                                                        (command_sub
                                                          left_token: 
                                                            (Token
                                                              id: Id.Left_DollarParen
                                                              val: '$('
                                                              span_id: 1854
                                                            )
                                                          command_list: 
                                                            (command.CommandList
                                                              children: [
                                                                (command.Pipeline
                                                                  children: [
                                                                    (command.Simple
                                                                      words: [
                                                                        {(cvs)}
                                                                        {(-q)}
                                                                        {(diff)}
                                                                        {(--brief)}
                                                                      ]
                                                                      redirects: [
                                                                        (redir.Redir
                                                                          op: 
                                                                            (Token
                                                                              id: Id.Redir_GreatAnd
                                                                              val: '2>&'
                                                                              span_id: 1864
                                                                            )
                                                                          fd: 2
                                                                          arg_word: {(1)}
                                                                        )
                                                                      ]
                                                                    )
                                                                    (C {(sed)} {(-ne)} 
                                                                      {
                                                                        (SQ 
                                                                          (Token
                                                                            id: Id.Lit_Chars
                                                                            val: 
's/^cvs diff: \\([^ ]*\\) .*, no comparison available$/\\1/p'
                                                                            span_id: 1876
                                                                          )
                                                                        )
                                                                      }
                                                                    )
                                                                  ]
                                                                  negated: F
                                                                )
                                                              ]
                                                            )
                                                        )
                                                      }
                                                    ]
                                                  )
                                                }
                                              spids: [1851]
                                            )
                                          ]
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                              op: assign_op.Equal
                                              rhs: 
                                                {
                                                  (sh_array_literal
                                                    left: 
                                                      (Token
                                                        id: Id.Op_LParen
                                                        val: '('
                                                        span_id: 1885
                                                      )
                                                    words: [
                                                      {
                                                        (command_sub
                                                          left_token: 
                                                            (Token
                                                              id: Id.Left_DollarParen
                                                              val: '$('
                                                              span_id: 1887
                                                            )
                                                          command_list: 
                                                            (command.CommandList
                                                              children: [
                                                                (C {(compgen)} {(-W)} 
                                                                  {
                                                                    (SQ 
                                                                      (Token
                                                                        id: Id.Lit_Chars
                                                                        val: '${changed[@]:-} \\\n'
                                                                        span_id: 1894
                                                                      ) (Token id:Id.Lit_Chars val:'                        ${newremoved[@]:-}' span_id:1895)
                                                                    )
                                                                  } {(--)} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                                )
                                                              ]
                                                            )
                                                        )
                                                      }
                                                    ]
                                                  )
                                                }
                                              spids: [1884]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [1789 1803]
                                    )
                                  ]
                                  else_action: [
                                    (C {(_cvs_entries)})
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                          op: assign_op.Equal
                                          rhs: 
                                            {
                                              (sh_array_literal
                                                left: (Token id:Id.Op_LParen val:'(' span_id:1916)
                                                words: [
                                                  {
                                                    (command_sub
                                                      left_token: 
                                                        (Token
                                                          id: Id.Left_DollarParen
                                                          val: '$('
                                                          span_id: 1918
                                                        )
                                                      command_list: 
                                                        (command.CommandList
                                                          children: [
                                                            (C {(compgen)} {(-W)} 
                                                              {
                                                                (SQ 
                                                                  (Token
                                                                    id: Id.Lit_Chars
                                                                    val: '${entries[@]}'
                                                                    span_id: 1925
                                                                  )
                                                                )
                                                              } {(--)} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                            )
                                                          ]
                                                        )
                                                    )
                                                  }
                                                ]
                                              )
                                            }
                                          spids: [1915]
                                        )
                                      ]
                                    )
                                  ]
                                )
                              ]
                              spids: [1758 1774]
                            )
                          ]
                          else_action: [
                            (C {(_cvs_command_options)} {(DQ ($ Id.VSub_Number '$1'))} 
                              {($ Id.VSub_DollarName '$mode')}
                            )
                          ]
                        )
                      ]
                      spids: [1714 1715 1957 -1]
                    )
                    (case_arm
                      pat_list: [{(cvsroot)}]
                      action: [(C {(_cvs_roots)})]
                      spids: [1960 1961 1967 -1]
                    )
                    (case_arm
                      pat_list: [{(diff)}]
                      action: [
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobDEqual
                                          left: {(DQ ($ Id.VSub_DollarName '$cur'))}
                                          right: {(-) (Id.Lit_Other '*')}
                                        )
                                    )
                                  terminator: (Token id:Id.Op_Semi val:';' span_id:1988)
                                )
                              ]
                              action: [
                                (C {(_cvs_command_options)} {(DQ ($ Id.VSub_Number '$1'))} 
                                  {($ Id.VSub_DollarName '$mode')}
                                )
                                (command.AndOr
                                  ops: [Id.Op_DAmp]
                                  children: [
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobDEqual
                                          left: {($ Id.VSub_DollarName '$COMPREPLY')}
                                          right: {(Id.Lit_Other '*') (Id.BoolBinary_GlobEqual '=')}
                                        )
                                    )
                                    (C {(compopt)} {(-o)} {(nospace)})
                                  ]
                                )
                              ]
                              spids: [1974 1990]
                            )
                          ]
                          else_action: [
                            (C {(_cvs_entries)})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: (Token id:Id.Op_LParen val:'(' span_id:2029)
                                        words: [
                                          {
                                            (command_sub
                                              left_token: 
                                                (Token
                                                  id: Id.Left_DollarParen
                                                  val: '$('
                                                  span_id: 2031
                                                )
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (C {(compgen)} {(-W)} 
                                                      {
                                                        (SQ 
                                                          (Token
                                                            id: Id.Lit_Chars
                                                            val: '${entries[@]:-}'
                                                            span_id: 2038
                                                          )
                                                        )
                                                      } {(--)} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                    )
                                                  ]
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [2028]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                      spids: [1970 1971 2055 -1]
                    )
                    (case_arm
                      pat_list: [{(editors)} {(watchers)}]
                      action: [
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobDEqual
                                          left: {(DQ ($ Id.VSub_DollarName '$cur'))}
                                          right: {(-) (Id.Lit_Other '*')}
                                        )
                                    )
                                  terminator: (Token id:Id.Op_Semi val:';' span_id:2078)
                                )
                              ]
                              action: [
                                (C {(_cvs_command_options)} {(DQ ($ Id.VSub_Number '$1'))} 
                                  {($ Id.VSub_DollarName '$mode')}
                                )
                              ]
                              spids: [2064 2080]
                            )
                          ]
                          else_action: [
                            (C {(_cvs_entries)})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: (Token id:Id.Op_LParen val:'(' span_id:2099)
                                        words: [
                                          {
                                            (command_sub
                                              left_token: 
                                                (Token
                                                  id: Id.Left_DollarParen
                                                  val: '$('
                                                  span_id: 2101
                                                )
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (C {(compgen)} {(-W)} 
                                                      {
                                                        (SQ 
                                                          (Token
                                                            id: Id.Lit_Chars
                                                            val: '${entries[@]}'
                                                            span_id: 2108
                                                          )
                                                        )
                                                      } {(--)} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                    )
                                                  ]
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [2098]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                      spids: [2058 2061 2125 -1]
                    )
                    (case_arm
                      pat_list: [{(export)}]
                      action: [
                        (command.Case
                          to_match: {($ Id.VSub_DollarName '$prev')}
                          arms: [
                            (case_arm
                              pat_list: [{(-r)} {(-D)}]
                              action: [
                                (command.ControlFlow
                                  token: (Token id:Id.ControlFlow_Return val:return span_id:2145)
                                  arg_word: {(0)}
                                )
                              ]
                              spids: [2139 2142 2150 -1]
                            )
                            (case_arm
                              pat_list: [{(-d)}]
                              action: [
                                (C {(_filedir)} {(-d)})
                                (command.ControlFlow
                                  token: (Token id:Id.ControlFlow_Return val:return span_id:2162)
                                  arg_word: {(0)}
                                )
                              ]
                              spids: [2153 2154 2167 -1]
                            )
                            (case_arm
                              pat_list: [{(-k)}]
                              action: [
                                (C {(_cvs_kflags)})
                                (command.ControlFlow
                                  token: (Token id:Id.ControlFlow_Return val:return span_id:2177)
                                  arg_word: {(0)}
                                )
                              ]
                              spids: [2170 2171 2182 -1]
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobNEqual
                                          left: {(DQ ($ Id.VSub_DollarName '$cur'))}
                                          right: {(-) (Id.Lit_Other '*')}
                                        )
                                    )
                                  terminator: (Token id:Id.Op_Semi val:';' span_id:2203)
                                )
                              ]
                              action: [
                                (command.AndOr
                                  ops: [Id.Op_DAmp]
                                  children: [
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_z
                                          child: {($ Id.VSub_DollarName '$cvsroot')}
                                        )
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:cvsroot)
                                          op: assign_op.Equal
                                          rhs: {($ Id.VSub_DollarName '$CVSROOT')}
                                          spids: [2218]
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (sh_array_literal
                                            left: (Token id:Id.Op_LParen val:'(' span_id:2223)
                                            words: [
                                              {
                                                (command_sub
                                                  left_token: 
                                                    (Token
                                                      id: Id.Left_DollarParen
                                                      val: '$('
                                                      span_id: 2225
                                                    )
                                                  command_list: 
                                                    (command.CommandList
                                                      children: [
                                                        (command.Pipeline
                                                          children: [
                                                            (C {(cvs)} {(-d)} 
                                                              {(DQ ($ Id.VSub_DollarName '$cvsroot'))} {(co)} {(-c)}
                                                            )
                                                            (C {(awk)} 
                                                              {
                                                                (SQ 
                                                                  (Token
                                                                    id: Id.Lit_Chars
                                                                    val: '{print $1}'
                                                                    span_id: 2244
                                                                  )
                                                                )
                                                              }
                                                            )
                                                          ]
                                                          negated: F
                                                        )
                                                      ]
                                                    )
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [2222]
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (sh_array_literal
                                            left: (Token id:Id.Op_LParen val:'(' span_id:2253)
                                            words: [
                                              {
                                                (command_sub
                                                  left_token: 
                                                    (Token
                                                      id: Id.Left_DollarParen
                                                      val: '$('
                                                      span_id: 2255
                                                    )
                                                  command_list: 
                                                    (command.CommandList
                                                      children: [
                                                        (C {(compgen)} {(-W)} 
                                                          {
                                                            (SQ 
                                                              (Token
                                                                id: Id.Lit_Chars
                                                                val: '${COMPREPLY[@]}'
                                                                span_id: 2262
                                                              )
                                                            )
                                                          } {(--)} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                        )
                                                      ]
                                                    )
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [2252]
                                    )
                                  ]
                                )
                              ]
                              spids: [2189 2205]
                            )
                          ]
                          else_action: [
                            (C {(_cvs_command_options)} {(DQ ($ Id.VSub_Number '$1'))} 
                              {($ Id.VSub_DollarName '$mode')}
                            )
                          ]
                        )
                      ]
                      spids: [2128 2129 2291 -1]
                    )
                    (case_arm
                      pat_list: [{(import)}]
                      action: [
                        (command.Case
                          to_match: {($ Id.VSub_DollarName '$prev')}
                          arms: [
                            (case_arm
                              pat_list: [{(-I)} {(-b)} {(-m)} {(-W)}]
                              action: [
                                (command.ControlFlow
                                  token: (Token id:Id.ControlFlow_Return val:return span_id:2315)
                                  arg_word: {(0)}
                                )
                              ]
                              spids: [2305 2312 2320 -1]
                            )
                            (case_arm
                              pat_list: [{(-k)}]
                              action: [
                                (C {(_cvs_kflags)})
                                (command.ControlFlow
                                  token: (Token id:Id.ControlFlow_Return val:return span_id:2330)
                                  arg_word: {(0)}
                                )
                              ]
                              spids: [2323 2324 2335 -1]
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobNEqual
                                          left: {(DQ ($ Id.VSub_DollarName '$cur'))}
                                          right: {(-) (Id.Lit_Other '*')}
                                        )
                                    )
                                  terminator: (Token id:Id.Op_Semi val:';' span_id:2356)
                                )
                              ]
                              action: [
                                (command.AndOr
                                  ops: [Id.Op_DAmp]
                                  children: [
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Unary
                                          op_id: Id.BoolUnary_z
                                          child: {($ Id.VSub_DollarName '$cvsroot')}
                                        )
                                    )
                                    (command.ShAssignment
                                      pairs: [
                                        (assign_pair
                                          lhs: (sh_lhs_expr.Name name:cvsroot)
                                          op: assign_op.Equal
                                          rhs: {($ Id.VSub_DollarName '$CVSROOT')}
                                          spids: [2375]
                                        )
                                      ]
                                    )
                                  ]
                                )
                                (C {(local)} 
                                  {(Id.Lit_VarLike 'prefix=') 
                                    (braced_var_sub
                                      token: (Token id:Id.VSub_Name val:cur span_id:2383)
                                      suffix_op: 
                                        (suffix_op.Unary
                                          op_id: Id.VOp1_Percent
                                          arg_word: {(Id.Lit_Slash /) ('*')}
                                        )
                                    )
                                  }
                                )
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (command.Sentence
                                          child: 
                                            (command.DBracket
                                              expr: 
                                                (bool_expr.Unary
                                                  op_id: Id.BoolUnary_r
                                                  child: 
                                                    {(${ Id.VSub_Name cvsroot) (/) 
                                                      (${ Id.VSub_Name prefix)
                                                    }
                                                )
                                            )
                                          terminator: (Token id:Id.Op_Semi val:';' span_id:2405)
                                        )
                                      ]
                                      action: [
                                        (C {(_cvs_modules)})
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                              op: assign_op.Equal
                                              rhs: 
                                                {
                                                  (sh_array_literal
                                                    left: 
                                                      (Token
                                                        id: Id.Op_LParen
                                                        val: '('
                                                        span_id: 2414
                                                      )
                                                    words: [
                                                      {
                                                        (braced_var_sub
                                                          token: 
                                                            (Token
                                                              id: Id.VSub_Name
                                                              val: COMPREPLY
                                                              span_id: 2417
                                                            )
                                                          bracket_op: 
                                                            (bracket_op.WholeArray
                                                              op_id: Id.Lit_At
                                                            )
                                                          suffix_op: 
                                                            (suffix_op.Unary
                                                              op_id: Id.VOp1_Pound
                                                              arg_word: 
                                                                {($ Id.VSub_DollarName '$cvsroot')}
                                                            )
                                                        )
                                                      }
                                                    ]
                                                  )
                                                }
                                              spids: [2413]
                                            )
                                          ]
                                        )
                                        (command.ShAssignment
                                          pairs: [
                                            (assign_pair
                                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                              op: assign_op.Equal
                                              rhs: 
                                                {
                                                  (sh_array_literal
                                                    left: 
                                                      (Token
                                                        id: Id.Op_LParen
                                                        val: '('
                                                        span_id: 2429
                                                      )
                                                    words: [
                                                      {
                                                        (braced_var_sub
                                                          token: 
                                                            (Token
                                                              id: Id.VSub_Name
                                                              val: COMPREPLY
                                                              span_id: 2432
                                                            )
                                                          bracket_op: 
                                                            (bracket_op.WholeArray
                                                              op_id: Id.Lit_At
                                                            )
                                                          suffix_op: 
                                                            (suffix_op.Unary
                                                              op_id: Id.VOp1_Pound
                                                              arg_word: 
                                                                {
                                                                  (word_part.EscapedLiteral
                                                                    token: 
                                                                      (Token
                                                                        id: Id.Lit_EscapedChar
                                                                        val: '\\/'
                                                                        span_id: 2437
                                                                      )
                                                                  )
                                                                }
                                                            )
                                                        )
                                                      }
                                                    ]
                                                  )
                                                }
                                              spids: [2428]
                                            )
                                          ]
                                        )
                                      ]
                                      spids: [2390 2407]
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:pwd)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (command_sub
                                            left_token: 
                                              (Token
                                                id: Id.Left_DollarParen
                                                val: '$('
                                                span_id: 2447
                                              )
                                            command_list: 
                                              (command.CommandList
                                                children: [(C {(pwd)})]
                                              )
                                          )
                                        }
                                      spids: [2446]
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:pwd)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (braced_var_sub
                                            token: (Token id:Id.VSub_Name val:pwd span_id:2456)
                                            suffix_op: 
                                              (suffix_op.Unary
                                                op_id: Id.VOp1_DPound
                                                arg_word: {('*') (Id.Lit_Slash /)}
                                              )
                                          )
                                        }
                                      spids: [2454]
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (sh_array_literal
                                            left: (Token id:Id.Op_LParen val:'(' span_id:2464)
                                            words: [
                                              {
                                                (command_sub
                                                  left_token: 
                                                    (Token
                                                      id: Id.Left_DollarParen
                                                      val: '$('
                                                      span_id: 2466
                                                    )
                                                  command_list: 
                                                    (command.CommandList
                                                      children: [
                                                        (C {(compgen)} {(-W)} 
                                                          {
                                                            (SQ 
                                                              (Token
                                                                id: Id.Lit_Chars
                                                                val: '${COMPREPLY[@]} $pwd'
                                                                span_id: 2473
                                                              )
                                                            )
                                                          } {(--)} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                        )
                                                      ]
                                                    )
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [2463]
                                    )
                                  ]
                                )
                              ]
                              spids: [2342 2358]
                            )
                          ]
                          else_action: [
                            (C {(_cvs_command_options)} {(DQ ($ Id.VSub_Number '$1'))} 
                              {($ Id.VSub_DollarName '$mode')}
                            )
                          ]
                        )
                      ]
                      spids: [2294 2295 2502 -1]
                    )
                    (case_arm
                      pat_list: [{(remove)}]
                      action: [
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobNEqual
                                          left: {(DQ ($ Id.VSub_DollarName '$cur'))}
                                          right: {(-) (Id.Lit_Other '*')}
                                        )
                                    )
                                  terminator: (Token id:Id.Op_Semi val:';' span_id:2523)
                                )
                              ]
                              action: [
                                (C {(_cvs_entries)})
                                (command.If
                                  arms: [
                                    (if_arm
                                      cond: [
                                        (command.Sentence
                                          child: 
                                            (command.DBracket
                                              expr: 
                                                (bool_expr.Binary
                                                  op_id: Id.BoolBinary_GlobNEqual
                                                  left: {(DQ ($ Id.VSub_DollarName '$prev'))}
                                                  right: {(Id.BoolUnary_f -f)}
                                                )
                                            )
                                          terminator: (Token id:Id.Op_Semi val:';' span_id:2544)
                                        )
                                      ]
                                      action: [
                                        (command.ForEach
                                          iter_name: i
                                          iter_words: [
                                            {
                                              (braced_var_sub
                                                token: 
                                                  (Token
                                                    id: Id.VSub_Name
                                                    val: entries
                                                    span_id: 2561
                                                  )
                                                prefix_op: (Id.VSub_Bang)
                                                bracket_op: (bracket_op.WholeArray op_id:Id.Lit_At)
                                              )
                                            }
                                          ]
                                          do_arg_iter: F
                                          body: 
                                            (command.DoGroup
                                              children: [
                                                (command.AndOr
                                                  ops: [Id.Op_DAmp]
                                                  children: [
                                                    (command.DBracket
                                                      expr: 
                                                        (bool_expr.Unary
                                                          op_id: Id.BoolUnary_r
                                                          child: 
                                                            {
                                                              (DQ 
                                                                (braced_var_sub
                                                                  token: 
                                                                    (Token
                                                                      id: Id.VSub_Name
                                                                      val: entries
                                                                      span_id: 2577
                                                                    )
                                                                  bracket_op: 
                                                                    (bracket_op.ArrayIndex
                                                                      expr: 
                                                                        (arith_expr.VarRef
                                                                          token: 
                                                                            (Token
                                                                              id: 
Id.Lit_ArithVarLike
                                                                              val: i
                                                                              span_id: 2579
                                                                            )
                                                                        )
                                                                    )
                                                                )
                                                              )
                                                            }
                                                        )
                                                    )
                                                    (C {(unset)} 
                                                      {
                                                        (SQ 
                                                          (Token
                                                            id: Id.Lit_Chars
                                                            val: 'entries[i]'
                                                            span_id: 2591
                                                          )
                                                        )
                                                      }
                                                    )
                                                  ]
                                                )
                                              ]
                                            )
                                        )
                                      ]
                                      spids: [2531 2546]
                                    )
                                  ]
                                )
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (sh_array_literal
                                            left: (Token id:Id.Op_LParen val:'(' span_id:2602)
                                            words: [
                                              {
                                                (command_sub
                                                  left_token: 
                                                    (Token
                                                      id: Id.Left_DollarParen
                                                      val: '$('
                                                      span_id: 2604
                                                    )
                                                  command_list: 
                                                    (command.CommandList
                                                      children: [
                                                        (C {(compgen)} {(-W)} 
                                                          {
                                                            (SQ 
                                                              (Token
                                                                id: Id.Lit_Chars
                                                                val: '${entries[@]:-}'
                                                                span_id: 2611
                                                              )
                                                            )
                                                          } {(--)} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                        )
                                                      ]
                                                    )
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [2601]
                                    )
                                  ]
                                )
                              ]
                              spids: [2509 2525]
                            )
                          ]
                          else_action: [
                            (C {(_cvs_command_options)} {(DQ ($ Id.VSub_Number '$1'))} 
                              {($ Id.VSub_DollarName '$mode')}
                            )
                          ]
                        )
                      ]
                      spids: [2505 2506 2640 -1]
                    )
                    (case_arm
                      pat_list: [{(update)}]
                      action: [
                        (command.Case
                          to_match: {($ Id.VSub_DollarName '$prev')}
                          arms: [
                            (case_arm
                              pat_list: [{(-r)} {(-D)} {(-j)} {(-I)} {(-W)}]
                              action: [
                                (command.ControlFlow
                                  token: (Token id:Id.ControlFlow_Return val:return span_id:2666)
                                  arg_word: {(0)}
                                )
                              ]
                              spids: [2654 2663 2671 -1]
                            )
                            (case_arm
                              pat_list: [{(-k)}]
                              action: [
                                (C {(_cvs_kflags)})
                                (command.ControlFlow
                                  token: (Token id:Id.ControlFlow_Return val:return span_id:2681)
                                  arg_word: {(0)}
                                )
                              ]
                              spids: [2674 2675 2686 -1]
                            )
                          ]
                        )
                        (command.If
                          arms: [
                            (if_arm
                              cond: [
                                (command.Sentence
                                  child: 
                                    (command.DBracket
                                      expr: 
                                        (bool_expr.Binary
                                          op_id: Id.BoolBinary_GlobDEqual
                                          left: {(DQ ($ Id.VSub_DollarName '$cur'))}
                                          right: {(-) (Id.Lit_Other '*')}
                                        )
                                    )
                                  terminator: (Token id:Id.Op_Semi val:';' span_id:2707)
                                )
                              ]
                              action: [
                                (C {(_cvs_command_options)} {(DQ ($ Id.VSub_Number '$1'))} 
                                  {($ Id.VSub_DollarName '$mode')}
                                )
                              ]
                              spids: [2693 2709]
                            )
                          ]
                          else_action: [
                            (C {(_cvs_entries)})
                            (command.ShAssignment
                              pairs: [
                                (assign_pair
                                  lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                  op: assign_op.Equal
                                  rhs: 
                                    {
                                      (sh_array_literal
                                        left: (Token id:Id.Op_LParen val:'(' span_id:2728)
                                        words: [
                                          {
                                            (command_sub
                                              left_token: 
                                                (Token
                                                  id: Id.Left_DollarParen
                                                  val: '$('
                                                  span_id: 2730
                                                )
                                              command_list: 
                                                (command.CommandList
                                                  children: [
                                                    (C {(compgen)} {(-W)} 
                                                      {
                                                        (SQ 
                                                          (Token
                                                            id: Id.Lit_Chars
                                                            val: '${entries[@]}'
                                                            span_id: 2737
                                                          )
                                                        )
                                                      } {(--)} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                    )
                                                  ]
                                                )
                                            )
                                          }
                                        ]
                                      )
                                    }
                                  spids: [2727]
                                )
                              ]
                            )
                          ]
                        )
                      ]
                      spids: [2643 2644 2754 -1]
                    )
                    (case_arm
                      pat_list: [{(DQ )}]
                      action: [
                        (command.Case
                          to_match: {($ Id.VSub_DollarName '$prev')}
                          arms: [
                            (case_arm
                              pat_list: [{(-T)}]
                              action: [
                                (C {(_filedir)} {(-d)})
                                (command.ControlFlow
                                  token: (Token id:Id.ControlFlow_Return val:return span_id:2778)
                                  arg_word: {(0)}
                                )
                              ]
                              spids: [2769 2770 2783 -1]
                            )
                            (case_arm
                              pat_list: [{(-e)} {(-s)}]
                              action: [
                                (command.ControlFlow
                                  token: (Token id:Id.ControlFlow_Return val:return span_id:2792)
                                  arg_word: {(0)}
                                )
                              ]
                              spids: [2786 2789 2797 -1]
                            )
                            (case_arm
                              pat_list: [{(-z)}]
                              action: [
                                (command.ShAssignment
                                  pairs: [
                                    (assign_pair
                                      lhs: (sh_lhs_expr.Name name:COMPREPLY)
                                      op: assign_op.Equal
                                      rhs: 
                                        {
                                          (sh_array_literal
                                            left: (Token id:Id.Op_LParen val:'(' span_id:2805)
                                            words: [
                                              {
                                                (command_sub
                                                  left_token: 
                                                    (Token
                                                      id: Id.Left_DollarParen
                                                      val: '$('
                                                      span_id: 2807
                                                    )
                                                  command_list: 
                                                    (command.CommandList
                                                      children: [
                                                        (C {(compgen)} {(-W)} 
                                                          {
                                                            (SQ 
                                                              (Token
                                                                id: Id.Lit_Chars
                                                                val: '{1..9}'
                                                                span_id: 2814
                                                              )
                                                            )
                                                          } {(--)} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                        )
                                                      ]
                                                    )
                                                )
                                              }
                                            ]
                                          )
                                        }
                                      spids: [2804]
                                    )
                                  ]
                                )
                                (command.ControlFlow
                                  token: (Token id:Id.ControlFlow_Return val:return span_id:2828)
                                  arg_word: {(0)}
                                )
                              ]
                              spids: [2800 2801 2833 -1]
                            )
                          ]
                        )
                        (command.ShAssignment
                          pairs: [
                            (assign_pair
                              lhs: (sh_lhs_expr.Name name:COMPREPLY)
                              op: assign_op.Equal
                              rhs: 
                                {
                                  (sh_array_literal
                                    left: (Token id:Id.Op_LParen val:'(' span_id:2841)
                                    words: [
                                      {
                                        (command_sub
                                          left_token: 
                                            (Token
                                              id: Id.Left_DollarParen
                                              val: '$('
                                              span_id: 2843
                                            )
                                          command_list: 
                                            (command.CommandList
                                              children: [
                                                (C {(compgen)} {(-W)} 
                                                  {
                                                    (SQ 
                                                      (Token
                                                        id: Id.Lit_Chars
                                                        val: '$( _cvs_commands )\n'
                                                        span_id: 2850
                                                      ) 
                                                      (Token
                                                        id: Id.Lit_Chars
                                                        val: 
'                $( _parse_help "$1" --help-options ) --help --help-commands\n'
                                                        span_id: 2851
                                                      ) (Token id:Id.Lit_Chars val:'                --help-options --version' span_id:2852)
                                                    )
                                                  } {(--)} {(DQ ($ Id.VSub_DollarName '$cur'))}
                                                )
                                              ]
                                            )
                                        )
                                      }
                                    ]
                                  )
                                }
                              spids: [2840]
                            )
                          ]
                        )
                      ]
                      spids: [2757 2759 2866 -1]
                    )
                  ]
                )
                (command.ControlFlow
                  token: (Token id:Id.ControlFlow_Return val:return span_id:2873)
                  arg_word: {(0)}
                )
              ]
            )
        )
        (C {(complete)} {(-F)} {(_cvs)} {(cvs)})
      ]
    )
  ]
)