public final AntlrPilarParser.annotationParams_return annotationParams()
      throws RecognitionException {
    AntlrPilarParser.annotationParams_return retval = new AntlrPilarParser.annotationParams_return();
    retval.start = input.LT(1);
    int annotationParams_StartIndex = input.index();
    Object root_0 = null;

    Token t = null;
    Token char_literal35 = null;
    Token char_literal37 = null;
    Token char_literal39 = null;
    AntlrPilarParser.annotationParam_return annotationParam34 = null;

    AntlrPilarParser.annotationParam_return annotationParam36 = null;

    AntlrPilarParser.exp_return exp38 = null;

    AntlrPilarParser.exp_return exp40 = null;

    Object t_tree = null;
    Object char_literal35_tree = null;
    Object char_literal37_tree = null;
    Object char_literal39_tree = null;
    RewriteRuleTokenStream stream_170 = new RewriteRuleTokenStream(adaptor,
        "token 170");
    RewriteRuleTokenStream stream_172 = new RewriteRuleTokenStream(adaptor,
        "token 172");
    RewriteRuleTokenStream stream_169 = new RewriteRuleTokenStream(adaptor,
        "token 169");
    RewriteRuleSubtreeStream stream_exp = new RewriteRuleSubtreeStream(adaptor,
        "rule exp");
    RewriteRuleSubtreeStream stream_annotationParam = new RewriteRuleSubtreeStream(
        adaptor, "rule annotationParam");
    try {
      if (state.backtracking > 0 && alreadyParsedRule(input, 16)) {
        return retval;
      }
      // /Users/robby/Repositories/sireum-parser/sireum-parser/src/main/java/org/sireum/pilar/parser/AntlrPilar.g:232:2: (t= '(' annotationParam ( ',' annotationParam )* ')' -> ^( LIST[$t] ( annotationParam )+ ) | exp ( ',' exp )* -> ^( LIST ( exp )+ ) )
      int alt12 = 2;
      alt12 = dfa12.predict(input);
      switch (alt12) {
        case 1:
        // /Users/robby/Repositories/sireum-parser/sireum-parser/src/main/java/org/sireum/pilar/parser/AntlrPilar.g:232:4: t= '(' annotationParam ( ',' annotationParam )* ')'
        {
          t = (Token) match(input, 169, FOLLOW_169_in_annotationParams1495);
          if (state.failed) return retval;
          if (state.backtracking == 0) stream_169.add(t);

          pushFollow(FOLLOW_annotationParam_in_annotationParams1497);
          annotationParam34 = annotationParam();

          state._fsp--;
          if (state.failed) return retval;
          if (state.backtracking == 0)
            stream_annotationParam.add(annotationParam34.getTree());
          // /Users/robby/Repositories/sireum-parser/sireum-parser/src/main/java/org/sireum/pilar/parser/AntlrPilar.g:233:8: ( ',' annotationParam )*
          loop10: do {
            int alt10 = 2;
            int LA10_0 = input.LA(1);

            if ((LA10_0 == 172)) {
              alt10 = 1;
            }

            switch (alt10) {
              case 1:
              // /Users/robby/Repositories/sireum-parser/sireum-parser/src/main/java/org/sireum/pilar/parser/AntlrPilar.g:233:10: ',' annotationParam
              {
                char_literal35 = (Token) match(
                    input,
                    172,
                    FOLLOW_172_in_annotationParams1508);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_172.add(char_literal35);

                pushFollow(FOLLOW_annotationParam_in_annotationParams1510);
                annotationParam36 = annotationParam();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0)
                  stream_annotationParam.add(annotationParam36.getTree());

              }
                break;

              default:
                break loop10;
            }
          } while (true);

          char_literal37 = (Token) match(
              input,
              170,
              FOLLOW_170_in_annotationParams1515);
          if (state.failed) return retval;
          if (state.backtracking == 0) stream_170.add(char_literal37);

          // AST REWRITE
          // elements: annotationParam
          // token labels: 
          // rule labels: retval
          // token list labels: 
          // rule list labels: 
          // wildcard labels: 
          if (state.backtracking == 0) {
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(
                adaptor, "rule retval", retval != null ? retval.tree : null);

            root_0 = (Object) adaptor.nil();
            // 233:41: -> ^( LIST[$t] ( annotationParam )+ )
            {
              // /Users/robby/Repositories/sireum-parser/sireum-parser/src/main/java/org/sireum/pilar/parser/AntlrPilar.g:233:44: ^( LIST[$t] ( annotationParam )+ )
              {
                Object root_1 = (Object) adaptor.nil();
                root_1 = (Object) adaptor.becomeRoot(
                    (Object) adaptor.create(LIST, t),
                    root_1);

                if (!(stream_annotationParam.hasNext())) {
                  throw new RewriteEarlyExitException();
                }
                while (stream_annotationParam.hasNext()) {
                  adaptor.addChild(root_1, stream_annotationParam.nextTree());

                }
                stream_annotationParam.reset();

                adaptor.addChild(root_0, root_1);
              }

            }

            retval.tree = root_0;
          }
        }
          break;
        case 2:
        // /Users/robby/Repositories/sireum-parser/sireum-parser/src/main/java/org/sireum/pilar/parser/AntlrPilar.g:234:4: exp ( ',' exp )*
        {
          pushFollow(FOLLOW_exp_in_annotationParams1534);
          exp38 = exp();

          state._fsp--;
          if (state.failed) return retval;
          if (state.backtracking == 0) stream_exp.add(exp38.getTree());
          // /Users/robby/Repositories/sireum-parser/sireum-parser/src/main/java/org/sireum/pilar/parser/AntlrPilar.g:234:8: ( ',' exp )*
          loop11: do {
            int alt11 = 2;
            alt11 = dfa11.predict(input);
            switch (alt11) {
              case 1:
              // /Users/robby/Repositories/sireum-parser/sireum-parser/src/main/java/org/sireum/pilar/parser/AntlrPilar.g:234:10: ',' exp
              {
                char_literal39 = (Token) match(
                    input,
                    172,
                    FOLLOW_172_in_annotationParams1538);
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_172.add(char_literal39);

                pushFollow(FOLLOW_exp_in_annotationParams1540);
                exp40 = exp();

                state._fsp--;
                if (state.failed) return retval;
                if (state.backtracking == 0) stream_exp.add(exp40.getTree());

              }
                break;

              default:
                break loop11;
            }
          } while (true);

          // AST REWRITE
          // elements: exp
          // token labels: 
          // rule labels: retval
          // token list labels: 
          // rule list labels: 
          // wildcard labels: 
          if (state.backtracking == 0) {
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(
                adaptor, "rule retval", retval != null ? retval.tree : null);

            root_0 = (Object) adaptor.nil();
            // 234:41: -> ^( LIST ( exp )+ )
            {
              // /Users/robby/Repositories/sireum-parser/sireum-parser/src/main/java/org/sireum/pilar/parser/AntlrPilar.g:234:44: ^( LIST ( exp )+ )
              {
                Object root_1 = (Object) adaptor.nil();
                root_1 = (Object) adaptor.becomeRoot(
                    (Object) adaptor.create(LIST, "LIST"),
                    root_1);

                if (!(stream_exp.hasNext())) {
                  throw new RewriteEarlyExitException();
                }
                while (stream_exp.hasNext()) {
                  adaptor.addChild(root_1, stream_exp.nextTree());

                }
                stream_exp.reset();

                adaptor.addChild(root_0, root_1);
              }

            }

            retval.tree = root_0;
          }
        }
          break;

      }
      retval.stop = input.LT(-1);

      if (state.backtracking == 0) {

        retval.tree = (Object) adaptor.rulePostProcessing(root_0);
        adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
      }
    } catch (RecognitionException re) {
      reportError(re);
      recover(input, re);
      retval.tree = (Object) adaptor.errorNode(
          input,
          retval.start,
          input.LT(-1),
          re);

    } finally {
      if (state.backtracking > 0) {
        memoize(input, 16, annotationParams_StartIndex);
      }
    }
    return retval;
  }