# Generated from JavaParser.g4 by ANTLR 4.7.2
# encoding: utf-8
import sys
from io import StringIO
from typing.io import TextIO

from antlr4 import *


def serializedATN():
    with StringIO() as buf:
        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3r")
        buf.write("\u059f\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
        buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
        buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
        buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
        buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
        buf.write('\4\37\t\37\4 \t \4!\t!\4"\t"\4#\t#\4$\t$\4%\t%\4&\t')
        buf.write("&\4'\t'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4")
        buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64")
        buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t")
        buf.write(";\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\t")
        buf.write("D\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\t")
        buf.write("M\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT\4U\tU\4V\t")
        buf.write("V\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4")
        buf.write("_\t_\4`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4")
        buf.write("h\th\4i\ti\4j\tj\3\2\5\2\u00d6\n\2\3\2\7\2\u00d9\n\2\f")
        buf.write("\2\16\2\u00dc\13\2\3\2\7\2\u00df\n\2\f\2\16\2\u00e2\13")
        buf.write("\2\3\2\3\2\3\3\7\3\u00e7\n\3\f\3\16\3\u00ea\13\3\3\3\3")
        buf.write("\3\3\3\3\3\3\4\3\4\5\4\u00f2\n\4\3\4\3\4\3\4\5\4\u00f7")
        buf.write("\n\4\3\4\3\4\3\5\7\5\u00fc\n\5\f\5\16\5\u00ff\13\5\3\5")
        buf.write("\3\5\3\5\3\5\5\5\u0105\n\5\3\5\5\5\u0108\n\5\3\6\3\6\3")
        buf.write("\6\3\6\3\6\5\6\u010f\n\6\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3")
        buf.write("\7\5\7\u0119\n\7\3\b\3\b\5\b\u011d\n\b\3\t\3\t\3\t\5\t")
        buf.write("\u0122\n\t\3\t\3\t\5\t\u0126\n\t\3\t\3\t\5\t\u012a\n\t")
        buf.write("\3\t\3\t\3\n\3\n\3\n\3\n\7\n\u0132\n\n\f\n\16\n\u0135")
        buf.write("\13\n\3\n\3\n\3\13\7\13\u013a\n\13\f\13\16\13\u013d\13")
        buf.write("\13\3\13\3\13\3\13\7\13\u0142\n\13\f\13\16\13\u0145\13")
        buf.write("\13\3\13\5\13\u0148\n\13\3\f\3\f\3\f\7\f\u014d\n\f\f\f")
        buf.write("\16\f\u0150\13\f\3\r\3\r\3\r\3\r\5\r\u0156\n\r\3\r\3\r")
        buf.write("\5\r\u015a\n\r\3\r\5\r\u015d\n\r\3\r\5\r\u0160\n\r\3\r")
        buf.write("\3\r\3\16\3\16\3\16\7\16\u0167\n\16\f\16\16\16\u016a\13")
        buf.write("\16\3\17\7\17\u016d\n\17\f\17\16\17\u0170\13\17\3\17\3")
        buf.write("\17\5\17\u0174\n\17\3\17\5\17\u0177\n\17\3\20\3\20\7\20")
        buf.write("\u017b\n\20\f\20\16\20\u017e\13\20\3\21\3\21\3\21\5\21")
        buf.write("\u0183\n\21\3\21\3\21\5\21\u0187\n\21\3\21\3\21\3\22\3")
        buf.write("\22\7\22\u018d\n\22\f\22\16\22\u0190\13\22\3\22\3\22\3")
        buf.write("\23\3\23\7\23\u0196\n\23\f\23\16\23\u0199\13\23\3\23\3")
        buf.write("\23\3\24\3\24\5\24\u019f\n\24\3\24\3\24\7\24\u01a3\n\24")
        buf.write("\f\24\16\24\u01a6\13\24\3\24\5\24\u01a9\n\24\3\25\3\25")
        buf.write("\3\25\3\25\3\25\3\25\3\25\3\25\3\25\5\25\u01b4\n\25\3")
        buf.write("\26\3\26\3\26\3\26\3\26\7\26\u01bb\n\26\f\26\16\26\u01be")
        buf.write("\13\26\3\26\3\26\5\26\u01c2\n\26\3\26\3\26\3\27\3\27\5")
        buf.write("\27\u01c8\n\27\3\30\3\30\5\30\u01cc\n\30\3\31\3\31\3\31")
        buf.write("\3\32\3\32\3\32\3\33\3\33\3\33\3\33\5\33\u01d8\n\33\3")
        buf.write("\33\3\33\3\34\3\34\3\34\3\34\3\35\7\35\u01e1\n\35\f\35")
        buf.write("\16\35\u01e4\13\35\3\35\3\35\5\35\u01e8\n\35\3\36\3\36")
        buf.write("\3\36\3\36\3\36\3\36\3\36\5\36\u01f1\n\36\3\37\3\37\3")
        buf.write("\37\3\37\7\37\u01f7\n\37\f\37\16\37\u01fa\13\37\3\37\3")
        buf.write("\37\3 \3 \3 \7 \u0201\n \f \16 \u0204\13 \3 \3 \3 \3!")
        buf.write("\7!\u020a\n!\f!\16!\u020d\13!\3!\3!\3!\7!\u0212\n!\f!")
        buf.write("\16!\u0215\13!\3!\3!\5!\u0219\n!\3!\3!\3!\3!\7!\u021f")
        buf.write('\n!\f!\16!\u0222\13!\3!\3!\5!\u0226\n!\3!\3!\3"\3"\3')
        buf.write('"\3"\3"\3"\5"\u0230\n"\3#\3#\3#\3$\3$\3$\7$\u0238')
        buf.write("\n$\f$\16$\u023b\13$\3%\3%\3%\5%\u0240\n%\3&\3&\3&\7&")
        buf.write("\u0245\n&\f&\16&\u0248\13&\3'\3'\5'\u024c\n'\3(\3")
        buf.write("(\3(\3(\7(\u0252\n(\f(\16(\u0255\13(\3(\5(\u0258\n(\5")
        buf.write("(\u025a\n(\3(\3(\3)\3)\5)\u0260\n)\3)\3)\3)\5)\u0265\n")
        buf.write(")\7)\u0267\n)\f)\16)\u026a\13)\3*\3*\7*\u026e\n*\f*\16")
        buf.write("*\u0271\13*\3*\3*\3*\5*\u0276\n*\5*\u0278\n*\3+\3+\3+")
        buf.write("\7+\u027d\n+\f+\16+\u0280\13+\3,\3,\5,\u0284\n,\3,\3,")
        buf.write("\3-\3-\3-\7-\u028b\n-\f-\16-\u028e\13-\3-\3-\5-\u0292")
        buf.write("\n-\3-\5-\u0295\n-\3.\7.\u0298\n.\f.\16.\u029b\13.\3.")
        buf.write("\3.\3.\3/\7/\u02a1\n/\f/\16/\u02a4\13/\3/\3/\7/\u02a8")
        buf.write("\n/\f/\16/\u02ab\13/\3/\3/\3/\3\60\3\60\3\60\7\60\u02b3")
        buf.write("\n\60\f\60\16\60\u02b6\13\60\3\61\3\61\3\61\3\61\3\61")
        buf.write("\3\61\5\61\u02be\n\61\3\62\3\62\3\63\3\63\3\64\3\64\7")
        buf.write("\64\u02c6\n\64\f\64\16\64\u02c9\13\64\3\64\3\64\3\64\3")
        buf.write("\65\3\65\3\65\5\65\u02d1\n\65\3\65\3\65\3\65\5\65\u02d6")
        buf.write("\n\65\3\65\5\65\u02d9\n\65\3\66\3\66\3\66\7\66\u02de\n")
        buf.write("\66\f\66\16\66\u02e1\13\66\3\67\3\67\3\67\3\67\38\38\3")
        buf.write("8\58\u02ea\n8\39\39\39\39\79\u02f0\n9\f9\169\u02f3\13")
        buf.write("9\59\u02f5\n9\39\59\u02f8\n9\39\39\3:\3:\3:\3:\3:\3;\3")
        buf.write(";\7;\u0303\n;\f;\16;\u0306\13;\3;\3;\3<\7<\u030b\n<\f")
        buf.write("<\16<\u030e\13<\3<\3<\5<\u0312\n<\3=\3=\3=\3=\3=\3=\5")
        buf.write("=\u031a\n=\3=\3=\5=\u031e\n=\3=\3=\5=\u0322\n=\3=\3=\5")
        buf.write("=\u0326\n=\5=\u0328\n=\3>\3>\5>\u032c\n>\3?\3?\3?\3?\5")
        buf.write("?\u0332\n?\3@\3@\3A\3A\3A\3B\3B\7B\u033b\nB\fB\16B\u033e")
        buf.write("\13B\3B\3B\3C\3C\3C\3C\3C\5C\u0347\nC\3D\7D\u034a\nD\f")
        buf.write("D\16D\u034d\13D\3D\3D\3D\3E\7E\u0353\nE\fE\16E\u0356\13")
        buf.write("E\3E\3E\5E\u035a\nE\3E\5E\u035d\nE\3F\3F\3F\3F\3F\5F\u0364")
        buf.write("\nF\3F\3F\3F\3F\3F\3F\3F\5F\u036d\nF\3F\3F\3F\3F\3F\3")
        buf.write("F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\6F\u0382\nF\r")
        buf.write("F\16F\u0383\3F\5F\u0387\nF\3F\5F\u038a\nF\3F\3F\3F\3F")
        buf.write("\7F\u0390\nF\fF\16F\u0393\13F\3F\5F\u0396\nF\3F\3F\3F")
        buf.write("\3F\7F\u039c\nF\fF\16F\u039f\13F\3F\7F\u03a2\nF\fF\16")
        buf.write("F\u03a5\13F\3F\3F\3F\3F\3F\3F\3F\3F\5F\u03af\nF\3F\3F")
        buf.write("\3F\3F\3F\3F\3F\5F\u03b8\nF\3F\3F\3F\5F\u03bd\nF\3F\3")
        buf.write("F\3F\3F\3F\3F\3F\3F\5F\u03c7\nF\3G\3G\3G\7G\u03cc\nG\f")
        buf.write("G\16G\u03cf\13G\3G\3G\3G\3G\3G\3H\3H\3H\7H\u03d9\nH\f")
        buf.write("H\16H\u03dc\13H\3I\3I\3I\3J\3J\3J\5J\u03e4\nJ\3J\3J\3")
        buf.write("K\3K\3K\7K\u03eb\nK\fK\16K\u03ee\13K\3L\7L\u03f1\nL\f")
        buf.write("L\16L\u03f4\13L\3L\3L\3L\3L\3L\3M\6M\u03fc\nM\rM\16M\u03fd")
        buf.write("\3M\6M\u0401\nM\rM\16M\u0402\3N\3N\3N\5N\u0408\nN\3N\3")
        buf.write("N\3N\5N\u040d\nN\3O\3O\5O\u0411\nO\3O\3O\5O\u0415\nO\3")
        buf.write("O\3O\5O\u0419\nO\5O\u041b\nO\3P\3P\5P\u041f\nP\3Q\7Q\u0422")
        buf.write("\nQ\fQ\16Q\u0425\13Q\3Q\3Q\3Q\3Q\3Q\3R\3R\3R\3R\3S\3S")
        buf.write("\3S\7S\u0433\nS\fS\16S\u0436\13S\3T\3T\3T\5T\u043b\nT")
        buf.write("\3T\3T\3T\3T\5T\u0441\nT\3T\3T\3T\3T\5T\u0447\nT\3T\5")
        buf.write("T\u044a\nT\3U\3U\3U\3U\3U\3U\3U\7U\u0453\nU\fU\16U\u0456")
        buf.write("\13U\3U\3U\3U\7U\u045b\nU\fU\16U\u045e\13U\3U\3U\3U\3")
        buf.write("U\3U\3U\3U\3U\3U\3U\3U\5U\u046b\nU\3U\3U\5U\u046f\nU\3")
        buf.write("U\3U\3U\5U\u0474\nU\3U\3U\5U\u0478\nU\3U\3U\3U\3U\3U\3")
        buf.write("U\3U\3U\3U\3U\3U\3U\3U\3U\5U\u0488\nU\3U\3U\3U\3U\3U\3")
        buf.write("U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3")
        buf.write("U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\5U\u04b0\n")
        buf.write("U\3U\3U\3U\3U\5U\u04b6\nU\3U\3U\3U\3U\3U\3U\3U\3U\3U\3")
        buf.write("U\3U\3U\3U\5U\u04c5\nU\3U\7U\u04c8\nU\fU\16U\u04cb\13")
        buf.write("U\3V\3V\3V\3V\3W\3W\3W\5W\u04d4\nW\3W\3W\3W\3W\3W\7W\u04db")
        buf.write("\nW\fW\16W\u04de\13W\3W\5W\u04e1\nW\3X\3X\5X\u04e5\nX")
        buf.write("\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\5Y\u04f7")
        buf.write("\nY\5Y\u04f9\nY\3Z\3Z\3Z\5Z\u04fe\nZ\3Z\7Z\u0501\nZ\f")
        buf.write("Z\16Z\u0504\13Z\3Z\3Z\5Z\u0508\nZ\3[\3[\3[\3[\3[\3[\3")
        buf.write("[\5[\u0511\n[\5[\u0513\n[\3\\\3\\\5\\\u0517\n\\\3\\\3")
        buf.write("\\\3\\\5\\\u051c\n\\\7\\\u051e\n\\\f\\\16\\\u0521\13\\")
        buf.write("\3\\\5\\\u0524\n\\\3]\3]\5]\u0528\n]\3]\3]\3^\3^\3^\3")
        buf.write("^\7^\u0530\n^\f^\16^\u0533\13^\3^\3^\3^\3^\3^\3^\3^\7")
        buf.write("^\u053c\n^\f^\16^\u053f\13^\3^\3^\7^\u0543\n^\f^\16^\u0546")
        buf.write("\13^\5^\u0548\n^\3_\3_\5_\u054c\n_\3`\3`\3`\3a\3a\3a\5")
        buf.write("a\u0554\na\3b\3b\3b\5b\u0559\nb\3c\3c\3c\3c\3d\3d\3d\7")
        buf.write("d\u0562\nd\fd\16d\u0565\13d\3e\7e\u0568\ne\fe\16e\u056b")
        buf.write("\13e\3e\3e\5e\u056f\ne\3e\7e\u0572\ne\fe\16e\u0575\13")
        buf.write("e\3e\3e\7e\u0579\ne\fe\16e\u057c\13e\3f\3f\3g\3g\3g\3")
        buf.write("g\7g\u0584\ng\fg\16g\u0587\13g\3g\3g\3h\3h\3h\3h\5h\u058f")
        buf.write("\nh\5h\u0591\nh\3i\3i\3i\3i\5i\u0597\ni\3j\3j\5j\u059b")
        buf.write("\nj\3j\3j\3j\2\3\u00a8k\2\4\6\b\n\f\16\20\22\24\26\30")
        buf.write('\32\34\36 "$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`b')
        buf.write("dfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c")
        buf.write("\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e")
        buf.write("\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0")
        buf.write("\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc\u00be\u00c0\u00c2")
        buf.write("\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce\u00d0\u00d2\2\16")
        buf.write("\4\2\23\23**\3\2\658\3\29:\3\2UX\3\2KL\4\2YZ^^\3\2WX\4")
        buf.write("\2IJPQ\4\2OORR\4\2HH_i\3\2UV\n\2\5\5\7\7\n\n\20\20\26")
        buf.write("\26\35\35\37\37''\2\u063f\2\u00d5\3\2\2\2\4\u00e8\3")
        buf.write("\2\2\2\6\u00ef\3\2\2\2\b\u0107\3\2\2\2\n\u010e\3\2\2\2")
        buf.write("\f\u0118\3\2\2\2\16\u011c\3\2\2\2\20\u011e\3\2\2\2\22")
        buf.write("\u012d\3\2\2\2\24\u013b\3\2\2\2\26\u0149\3\2\2\2\30\u0151")
        buf.write("\3\2\2\2\32\u0163\3\2\2\2\34\u016e\3\2\2\2\36\u0178\3")
        buf.write('\2\2\2 \u017f\3\2\2\2"\u018a\3\2\2\2$\u0193\3\2\2\2&')
        buf.write("\u01a8\3\2\2\2(\u01b3\3\2\2\2*\u01b5\3\2\2\2,\u01c7\3")
        buf.write("\2\2\2.\u01cb\3\2\2\2\60\u01cd\3\2\2\2\62\u01d0\3\2\2")
        buf.write("\2\64\u01d3\3\2\2\2\66\u01db\3\2\2\28\u01e7\3\2\2\2:\u01f0")
        buf.write("\3\2\2\2<\u01f2\3\2\2\2>\u01fd\3\2\2\2@\u020b\3\2\2\2")
        buf.write("B\u022f\3\2\2\2D\u0231\3\2\2\2F\u0234\3\2\2\2H\u023c\3")
        buf.write("\2\2\2J\u0241\3\2\2\2L\u024b\3\2\2\2N\u024d\3\2\2\2P\u025d")
        buf.write("\3\2\2\2R\u0277\3\2\2\2T\u0279\3\2\2\2V\u0281\3\2\2\2")
        buf.write("X\u0294\3\2\2\2Z\u0299\3\2\2\2\\\u02a2\3\2\2\2^\u02af")
        buf.write("\3\2\2\2`\u02bd\3\2\2\2b\u02bf\3\2\2\2d\u02c1\3\2\2\2")
        buf.write("f\u02c7\3\2\2\2h\u02d0\3\2\2\2j\u02da\3\2\2\2l\u02e2\3")
        buf.write("\2\2\2n\u02e9\3\2\2\2p\u02eb\3\2\2\2r\u02fb\3\2\2\2t\u0300")
        buf.write("\3\2\2\2v\u0311\3\2\2\2x\u0327\3\2\2\2z\u032b\3\2\2\2")
        buf.write("|\u032d\3\2\2\2~\u0333\3\2\2\2\u0080\u0335\3\2\2\2\u0082")
        buf.write("\u0338\3\2\2\2\u0084\u0346\3\2\2\2\u0086\u034b\3\2\2\2")
        buf.write("\u0088\u035c\3\2\2\2\u008a\u03c6\3\2\2\2\u008c\u03c8\3")
        buf.write("\2\2\2\u008e\u03d5\3\2\2\2\u0090\u03dd\3\2\2\2\u0092\u03e0")
        buf.write("\3\2\2\2\u0094\u03e7\3\2\2\2\u0096\u03f2\3\2\2\2\u0098")
        buf.write("\u03fb\3\2\2\2\u009a\u040c\3\2\2\2\u009c\u041a\3\2\2\2")
        buf.write("\u009e\u041e\3\2\2\2\u00a0\u0423\3\2\2\2\u00a2\u042b\3")
        buf.write("\2\2\2\u00a4\u042f\3\2\2\2\u00a6\u0449\3\2\2\2\u00a8\u0477")
        buf.write("\3\2\2\2\u00aa\u04cc\3\2\2\2\u00ac\u04e0\3\2\2\2\u00ae")
        buf.write("\u04e4\3\2\2\2\u00b0\u04f8\3\2\2\2\u00b2\u04fd\3\2\2\2")
        buf.write("\u00b4\u0512\3\2\2\2\u00b6\u0523\3\2\2\2\u00b8\u0525\3")
        buf.write("\2\2\2\u00ba\u052b\3\2\2\2\u00bc\u0549\3\2\2\2\u00be\u054d")
        buf.write("\3\2\2\2\u00c0\u0553\3\2\2\2\u00c2\u0558\3\2\2\2\u00c4")
        buf.write("\u055a\3\2\2\2\u00c6\u055e\3\2\2\2\u00c8\u0569\3\2\2\2")
        buf.write("\u00ca\u057d\3\2\2\2\u00cc\u057f\3\2\2\2\u00ce\u0590\3")
        buf.write("\2\2\2\u00d0\u0596\3\2\2\2\u00d2\u0598\3\2\2\2\u00d4\u00d6")
        buf.write("\5\4\3\2\u00d5\u00d4\3\2\2\2\u00d5\u00d6\3\2\2\2\u00d6")
        buf.write("\u00da\3\2\2\2\u00d7\u00d9\5\6\4\2\u00d8\u00d7\3\2\2\2")
        buf.write("\u00d9\u00dc\3\2\2\2\u00da\u00d8\3\2\2\2\u00da\u00db\3")
        buf.write("\2\2\2\u00db\u00e0\3\2\2\2\u00dc\u00da\3\2\2\2\u00dd\u00df")
        buf.write("\5\b\5\2\u00de\u00dd\3\2\2\2\u00df\u00e2\3\2\2\2\u00e0")
        buf.write("\u00de\3\2\2\2\u00e0\u00e1\3\2\2\2\u00e1\u00e3\3\2\2\2")
        buf.write("\u00e2\u00e0\3\2\2\2\u00e3\u00e4\7\2\2\3\u00e4\3\3\2\2")
        buf.write("\2\u00e5\u00e7\5h\65\2\u00e6\u00e5\3\2\2\2\u00e7\u00ea")
        buf.write("\3\2\2\2\u00e8\u00e6\3\2\2\2\u00e8\u00e9\3\2\2\2\u00e9")
        buf.write('\u00eb\3\2\2\2\u00ea\u00e8\3\2\2\2\u00eb\u00ec\7"\2\2')
        buf.write("\u00ec\u00ed\5^\60\2\u00ed\u00ee\7E\2\2\u00ee\5\3\2\2")
        buf.write("\2\u00ef\u00f1\7\33\2\2\u00f0\u00f2\7(\2\2\u00f1\u00f0")
        buf.write("\3\2\2\2\u00f1\u00f2\3\2\2\2\u00f2\u00f3\3\2\2\2\u00f3")
        buf.write("\u00f6\5^\60\2\u00f4\u00f5\7G\2\2\u00f5\u00f7\7Y\2\2\u00f6")
        buf.write("\u00f4\3\2\2\2\u00f6\u00f7\3\2\2\2\u00f7\u00f8\3\2\2\2")
        buf.write("\u00f8\u00f9\7E\2\2\u00f9\7\3\2\2\2\u00fa\u00fc\5\f\7")
        buf.write("\2\u00fb\u00fa\3\2\2\2\u00fc\u00ff\3\2\2\2\u00fd\u00fb")
        buf.write("\3\2\2\2\u00fd\u00fe\3\2\2\2\u00fe\u0104\3\2\2\2\u00ff")
        buf.write("\u00fd\3\2\2\2\u0100\u0105\5\20\t\2\u0101\u0105\5\30\r")
        buf.write("\2\u0102\u0105\5 \21\2\u0103\u0105\5r:\2\u0104\u0100\3")
        buf.write("\2\2\2\u0104\u0101\3\2\2\2\u0104\u0102\3\2\2\2\u0104\u0103")
        buf.write("\3\2\2\2\u0105\u0108\3\2\2\2\u0106\u0108\7E\2\2\u0107")
        buf.write("\u00fd\3\2\2\2\u0107\u0106\3\2\2\2\u0108\t\3\2\2\2\u0109")
        buf.write("\u010f\5\f\7\2\u010a\u010f\7 \2\2\u010b\u010f\7,\2\2\u010c")
        buf.write("\u010f\7\60\2\2\u010d\u010f\7\63\2\2\u010e\u0109\3\2\2")
        buf.write("\2\u010e\u010a\3\2\2\2\u010e\u010b\3\2\2\2\u010e\u010c")
        buf.write("\3\2\2\2\u010e\u010d\3\2\2\2\u010f\13\3\2\2\2\u0110\u0119")
        buf.write("\5h\65\2\u0111\u0119\7%\2\2\u0112\u0119\7$\2\2\u0113\u0119")
        buf.write("\7#\2\2\u0114\u0119\7(\2\2\u0115\u0119\7\3\2\2\u0116\u0119")
        buf.write("\7\24\2\2\u0117\u0119\7)\2\2\u0118\u0110\3\2\2\2\u0118")
        buf.write("\u0111\3\2\2\2\u0118\u0112\3\2\2\2\u0118\u0113\3\2\2\2")
        buf.write("\u0118\u0114\3\2\2\2\u0118\u0115\3\2\2\2\u0118\u0116\3")
        buf.write("\2\2\2\u0118\u0117\3\2\2\2\u0119\r\3\2\2\2\u011a\u011d")
        buf.write("\7\24\2\2\u011b\u011d\5h\65\2\u011c\u011a\3\2\2\2\u011c")
        buf.write("\u011b\3\2\2\2\u011d\17\3\2\2\2\u011e\u011f\7\13\2\2\u011f")
        buf.write("\u0121\7r\2\2\u0120\u0122\5\22\n\2\u0121\u0120\3\2\2\2")
        buf.write("\u0121\u0122\3\2\2\2\u0122\u0125\3\2\2\2\u0123\u0124\7")
        buf.write("\23\2\2\u0124\u0126\5\u00c8e\2\u0125\u0123\3\2\2\2\u0125")
        buf.write("\u0126\3\2\2\2\u0126\u0129\3\2\2\2\u0127\u0128\7\32\2")
        buf.write("\2\u0128\u012a\5\u00c6d\2\u0129\u0127\3\2\2\2\u0129\u012a")
        buf.write('\3\2\2\2\u012a\u012b\3\2\2\2\u012b\u012c\5"\22\2\u012c')
        buf.write("\21\3\2\2\2\u012d\u012e\7J\2\2\u012e\u0133\5\24\13\2\u012f")
        buf.write("\u0130\7F\2\2\u0130\u0132\5\24\13\2\u0131\u012f\3\2\2")
        buf.write("\2\u0132\u0135\3\2\2\2\u0133\u0131\3\2\2\2\u0133\u0134")
        buf.write("\3\2\2\2\u0134\u0136\3\2\2\2\u0135\u0133\3\2\2\2\u0136")
        buf.write("\u0137\7I\2\2\u0137\23\3\2\2\2\u0138\u013a\5h\65\2\u0139")
        buf.write("\u0138\3\2\2\2\u013a\u013d\3\2\2\2\u013b\u0139\3\2\2\2")
        buf.write("\u013b\u013c\3\2\2\2\u013c\u013e\3\2\2\2\u013d\u013b\3")
        buf.write("\2\2\2\u013e\u0147\7r\2\2\u013f\u0143\7\23\2\2\u0140\u0142")
        buf.write("\5h\65\2\u0141\u0140\3\2\2\2\u0142\u0145\3\2\2\2\u0143")
        buf.write("\u0141\3\2\2\2\u0143\u0144\3\2\2\2\u0144\u0146\3\2\2\2")
        buf.write("\u0145\u0143\3\2\2\2\u0146\u0148\5\26\f\2\u0147\u013f")
        buf.write("\3\2\2\2\u0147\u0148\3\2\2\2\u0148\25\3\2\2\2\u0149\u014e")
        buf.write("\5\u00c8e\2\u014a\u014b\7[\2\2\u014b\u014d\5\u00c8e\2")
        buf.write("\u014c\u014a\3\2\2\2\u014d\u0150\3\2\2\2\u014e\u014c\3")
        buf.write("\2\2\2\u014e\u014f\3\2\2\2\u014f\27\3\2\2\2\u0150\u014e")
        buf.write("\3\2\2\2\u0151\u0152\7\22\2\2\u0152\u0155\7r\2\2\u0153")
        buf.write("\u0154\7\32\2\2\u0154\u0156\5\u00c6d\2\u0155\u0153\3\2")
        buf.write("\2\2\u0155\u0156\3\2\2\2\u0156\u0157\3\2\2\2\u0157\u0159")
        buf.write("\7A\2\2\u0158\u015a\5\32\16\2\u0159\u0158\3\2\2\2\u0159")
        buf.write("\u015a\3\2\2\2\u015a\u015c\3\2\2\2\u015b\u015d\7F\2\2")
        buf.write("\u015c\u015b\3\2\2\2\u015c\u015d\3\2\2\2\u015d\u015f\3")
        buf.write("\2\2\2\u015e\u0160\5\36\20\2\u015f\u015e\3\2\2\2\u015f")
        buf.write("\u0160\3\2\2\2\u0160\u0161\3\2\2\2\u0161\u0162\7B\2\2")
        buf.write("\u0162\31\3\2\2\2\u0163\u0168\5\34\17\2\u0164\u0165\7")
        buf.write("F\2\2\u0165\u0167\5\34\17\2\u0166\u0164\3\2\2\2\u0167")
        buf.write("\u016a\3\2\2\2\u0168\u0166\3\2\2\2\u0168\u0169\3\2\2\2")
        buf.write("\u0169\33\3\2\2\2\u016a\u0168\3\2\2\2\u016b\u016d\5h\65")
        buf.write("\2\u016c\u016b\3\2\2\2\u016d\u0170\3\2\2\2\u016e\u016c")
        buf.write("\3\2\2\2\u016e\u016f\3\2\2\2\u016f\u0171\3\2\2\2\u0170")
        buf.write("\u016e\3\2\2\2\u0171\u0173\7r\2\2\u0172\u0174\5\u00d2")
        buf.write("j\2\u0173\u0172\3\2\2\2\u0173\u0174\3\2\2\2\u0174\u0176")
        buf.write('\3\2\2\2\u0175\u0177\5"\22\2\u0176\u0175\3\2\2\2\u0176')
        buf.write("\u0177\3\2\2\2\u0177\35\3\2\2\2\u0178\u017c\7E\2\2\u0179")
        buf.write("\u017b\5&\24\2\u017a\u0179\3\2\2\2\u017b\u017e\3\2\2\2")
        buf.write("\u017c\u017a\3\2\2\2\u017c\u017d\3\2\2\2\u017d\37\3\2")
        buf.write("\2\2\u017e\u017c\3\2\2\2\u017f\u0180\7\36\2\2\u0180\u0182")
        buf.write("\7r\2\2\u0181\u0183\5\22\n\2\u0182\u0181\3\2\2\2\u0182")
        buf.write("\u0183\3\2\2\2\u0183\u0186\3\2\2\2\u0184\u0185\7\23\2")
        buf.write("\2\u0185\u0187\5\u00c6d\2\u0186\u0184\3\2\2\2\u0186\u0187")
        buf.write("\3\2\2\2\u0187\u0188\3\2\2\2\u0188\u0189\5$\23\2\u0189")
        buf.write("!\3\2\2\2\u018a\u018e\7A\2\2\u018b\u018d\5&\24\2\u018c")
        buf.write("\u018b\3\2\2\2\u018d\u0190\3\2\2\2\u018e\u018c\3\2\2\2")
        buf.write("\u018e\u018f\3\2\2\2\u018f\u0191\3\2\2\2\u0190\u018e\3")
        buf.write("\2\2\2\u0191\u0192\7B\2\2\u0192#\3\2\2\2\u0193\u0197\7")
        buf.write("A\2\2\u0194\u0196\58\35\2\u0195\u0194\3\2\2\2\u0196\u0199")
        buf.write("\3\2\2\2\u0197\u0195\3\2\2\2\u0197\u0198\3\2\2\2\u0198")
        buf.write("\u019a\3\2\2\2\u0199\u0197\3\2\2\2\u019a\u019b\7B\2\2")
        buf.write("\u019b%\3\2\2\2\u019c\u01a9\7E\2\2\u019d\u019f\7(\2\2")
        buf.write("\u019e\u019d\3\2\2\2\u019e\u019f\3\2\2\2\u019f\u01a0\3")
        buf.write("\2\2\2\u01a0\u01a9\5\u0082B\2\u01a1\u01a3\5\n\6\2\u01a2")
        buf.write("\u01a1\3\2\2\2\u01a3\u01a6\3\2\2\2\u01a4\u01a2\3\2\2\2")
        buf.write("\u01a4\u01a5\3\2\2\2\u01a5\u01a7\3\2\2\2\u01a6\u01a4\3")
        buf.write("\2\2\2\u01a7\u01a9\5(\25\2\u01a8\u019c\3\2\2\2\u01a8\u019e")
        buf.write("\3\2\2\2\u01a8\u01a4\3\2\2\2\u01a9'\3\2\2\2\u01aa\u01b4")
        buf.write("\5*\26\2\u01ab\u01b4\5\60\31\2\u01ac\u01b4\5\66\34\2\u01ad")
        buf.write("\u01b4\5\64\33\2\u01ae\u01b4\5\62\32\2\u01af\u01b4\5 ")
        buf.write("\21\2\u01b0\u01b4\5r:\2\u01b1\u01b4\5\20\t\2\u01b2\u01b4")
        buf.write("\5\30\r\2\u01b3\u01aa\3\2\2\2\u01b3\u01ab\3\2\2\2\u01b3")
        buf.write("\u01ac\3\2\2\2\u01b3\u01ad\3\2\2\2\u01b3\u01ae\3\2\2\2")
        buf.write("\u01b3\u01af\3\2\2\2\u01b3\u01b0\3\2\2\2\u01b3\u01b1\3")
        buf.write("\2\2\2\u01b3\u01b2\3\2\2\2\u01b4)\3\2\2\2\u01b5\u01b6")
        buf.write("\5.\30\2\u01b6\u01b7\7r\2\2\u01b7\u01bc\5V,\2\u01b8\u01b9")
        buf.write("\7C\2\2\u01b9\u01bb\7D\2\2\u01ba\u01b8\3\2\2\2\u01bb\u01be")
        buf.write("\3\2\2\2\u01bc\u01ba\3\2\2\2\u01bc\u01bd\3\2\2\2\u01bd")
        buf.write("\u01c1\3\2\2\2\u01be\u01bc\3\2\2\2\u01bf\u01c0\7/\2\2")
        buf.write("\u01c0\u01c2\5T+\2\u01c1\u01bf\3\2\2\2\u01c1\u01c2\3\2")
        buf.write("\2\2\u01c2\u01c3\3\2\2\2\u01c3\u01c4\5,\27\2\u01c4+\3")
        buf.write("\2\2\2\u01c5\u01c8\5\u0082B\2\u01c6\u01c8\7E\2\2\u01c7")
        buf.write("\u01c5\3\2\2\2\u01c7\u01c6\3\2\2\2\u01c8-\3\2\2\2\u01c9")
        buf.write("\u01cc\5\u00c8e\2\u01ca\u01cc\7\62\2\2\u01cb\u01c9\3\2")
        buf.write("\2\2\u01cb\u01ca\3\2\2\2\u01cc/\3\2\2\2\u01cd\u01ce\5")
        buf.write("\22\n\2\u01ce\u01cf\5*\26\2\u01cf\61\3\2\2\2\u01d0\u01d1")
        buf.write("\5\22\n\2\u01d1\u01d2\5\64\33\2\u01d2\63\3\2\2\2\u01d3")
        buf.write("\u01d4\7r\2\2\u01d4\u01d7\5V,\2\u01d5\u01d6\7/\2\2\u01d6")
        buf.write("\u01d8\5T+\2\u01d7\u01d5\3\2\2\2\u01d7\u01d8\3\2\2\2\u01d8")
        buf.write("\u01d9\3\2\2\2\u01d9\u01da\5\u0082B\2\u01da\65\3\2\2\2")
        buf.write("\u01db\u01dc\5\u00c8e\2\u01dc\u01dd\5F$\2\u01dd\u01de")
        buf.write("\7E\2\2\u01de\67\3\2\2\2\u01df\u01e1\5\n\6\2\u01e0\u01df")
        buf.write("\3\2\2\2\u01e1\u01e4\3\2\2\2\u01e2\u01e0\3\2\2\2\u01e2")
        buf.write("\u01e3\3\2\2\2\u01e3\u01e5\3\2\2\2\u01e4\u01e2\3\2\2\2")
        buf.write("\u01e5\u01e8\5:\36\2\u01e6\u01e8\7E\2\2\u01e7\u01e2\3")
        buf.write("\2\2\2\u01e7\u01e6\3\2\2\2\u01e89\3\2\2\2\u01e9\u01f1")
        buf.write("\5<\37\2\u01ea\u01f1\5@!\2\u01eb\u01f1\5D#\2\u01ec\u01f1")
        buf.write("\5 \21\2\u01ed\u01f1\5r:\2\u01ee\u01f1\5\20\t\2\u01ef")
        buf.write("\u01f1\5\30\r\2\u01f0\u01e9\3\2\2\2\u01f0\u01ea\3\2\2")
        buf.write("\2\u01f0\u01eb\3\2\2\2\u01f0\u01ec\3\2\2\2\u01f0\u01ed")
        buf.write("\3\2\2\2\u01f0\u01ee\3\2\2\2\u01f0\u01ef\3\2\2\2\u01f1")
        buf.write(";\3\2\2\2\u01f2\u01f3\5\u00c8e\2\u01f3\u01f8\5> \2\u01f4")
        buf.write("\u01f5\7F\2\2\u01f5\u01f7\5> \2\u01f6\u01f4\3\2\2\2\u01f7")
        buf.write("\u01fa\3\2\2\2\u01f8\u01f6\3\2\2\2\u01f8\u01f9\3\2\2\2")
        buf.write("\u01f9\u01fb\3\2\2\2\u01fa\u01f8\3\2\2\2\u01fb\u01fc\7")
        buf.write("E\2\2\u01fc=\3\2\2\2\u01fd\u0202\7r\2\2\u01fe\u01ff\7")
        buf.write("C\2\2\u01ff\u0201\7D\2\2\u0200\u01fe\3\2\2\2\u0201\u0204")
        buf.write("\3\2\2\2\u0202\u0200\3\2\2\2\u0202\u0203\3\2\2\2\u0203")
        buf.write("\u0205\3\2\2\2\u0204\u0202\3\2\2\2\u0205\u0206\7H\2\2")
        buf.write("\u0206\u0207\5L'\2\u0207?\3\2\2\2\u0208\u020a\5B\"\2")
        buf.write("\u0209\u0208\3\2\2\2\u020a\u020d\3\2\2\2\u020b\u0209\3")
        buf.write("\2\2\2\u020b\u020c\3\2\2\2\u020c\u0218\3\2\2\2\u020d\u020b")
        buf.write("\3\2\2\2\u020e\u0219\5.\30\2\u020f\u0213\5\22\n\2\u0210")
        buf.write("\u0212\5h\65\2\u0211\u0210\3\2\2\2\u0212\u0215\3\2\2\2")
        buf.write("\u0213\u0211\3\2\2\2\u0213\u0214\3\2\2\2\u0214\u0216\3")
        buf.write("\2\2\2\u0215\u0213\3\2\2\2\u0216\u0217\5.\30\2\u0217\u0219")
        buf.write("\3\2\2\2\u0218\u020e\3\2\2\2\u0218\u020f\3\2\2\2\u0219")
        buf.write("\u021a\3\2\2\2\u021a\u021b\7r\2\2\u021b\u0220\5V,\2\u021c")
        buf.write("\u021d\7C\2\2\u021d\u021f\7D\2\2\u021e\u021c\3\2\2\2\u021f")
        buf.write("\u0222\3\2\2\2\u0220\u021e\3\2\2\2\u0220\u0221\3\2\2\2")
        buf.write("\u0221\u0225\3\2\2\2\u0222\u0220\3\2\2\2\u0223\u0224\7")
        buf.write("/\2\2\u0224\u0226\5T+\2\u0225\u0223\3\2\2\2\u0225\u0226")
        buf.write("\3\2\2\2\u0226\u0227\3\2\2\2\u0227\u0228\5,\27\2\u0228")
        buf.write("A\3\2\2\2\u0229\u0230\5h\65\2\u022a\u0230\7%\2\2\u022b")
        buf.write("\u0230\7\3\2\2\u022c\u0230\7\16\2\2\u022d\u0230\7(\2\2")
        buf.write("\u022e\u0230\7)\2\2\u022f\u0229\3\2\2\2\u022f\u022a\3")
        buf.write("\2\2\2\u022f\u022b\3\2\2\2\u022f\u022c\3\2\2\2\u022f\u022d")
        buf.write("\3\2\2\2\u022f\u022e\3\2\2\2\u0230C\3\2\2\2\u0231\u0232")
        buf.write("\5\22\n\2\u0232\u0233\5@!\2\u0233E\3\2\2\2\u0234\u0239")
        buf.write("\5H%\2\u0235\u0236\7F\2\2\u0236\u0238\5H%\2\u0237\u0235")
        buf.write("\3\2\2\2\u0238\u023b\3\2\2\2\u0239\u0237\3\2\2\2\u0239")
        buf.write("\u023a\3\2\2\2\u023aG\3\2\2\2\u023b\u0239\3\2\2\2\u023c")
        buf.write("\u023f\5J&\2\u023d\u023e\7H\2\2\u023e\u0240\5L'\2\u023f")
        buf.write("\u023d\3\2\2\2\u023f\u0240\3\2\2\2\u0240I\3\2\2\2\u0241")
        buf.write("\u0246\7r\2\2\u0242\u0243\7C\2\2\u0243\u0245\7D\2\2\u0244")
        buf.write("\u0242\3\2\2\2\u0245\u0248\3\2\2\2\u0246\u0244\3\2\2\2")
        buf.write("\u0246\u0247\3\2\2\2\u0247K\3\2\2\2\u0248\u0246\3\2\2")
        buf.write("\2\u0249\u024c\5N(\2\u024a\u024c\5\u00a8U\2\u024b\u0249")
        buf.write("\3\2\2\2\u024b\u024a\3\2\2\2\u024cM\3\2\2\2\u024d\u0259")
        buf.write("\7A\2\2\u024e\u0253\5L'\2\u024f\u0250\7F\2\2\u0250\u0252")
        buf.write("\5L'\2\u0251\u024f\3\2\2\2\u0252\u0255\3\2\2\2\u0253")
        buf.write("\u0251\3\2\2\2\u0253\u0254\3\2\2\2\u0254\u0257\3\2\2\2")
        buf.write("\u0255\u0253\3\2\2\2\u0256\u0258\7F\2\2\u0257\u0256\3")
        buf.write("\2\2\2\u0257\u0258\3\2\2\2\u0258\u025a\3\2\2\2\u0259\u024e")
        buf.write("\3\2\2\2\u0259\u025a\3\2\2\2\u025a\u025b\3\2\2\2\u025b")
        buf.write("\u025c\7B\2\2\u025cO\3\2\2\2\u025d\u025f\7r\2\2\u025e")
        buf.write("\u0260\5\u00ccg\2\u025f\u025e\3\2\2\2\u025f\u0260\3\2")
        buf.write("\2\2\u0260\u0268\3\2\2\2\u0261\u0262\7G\2\2\u0262\u0264")
        buf.write("\7r\2\2\u0263\u0265\5\u00ccg\2\u0264\u0263\3\2\2\2\u0264")
        buf.write("\u0265\3\2\2\2\u0265\u0267\3\2\2\2\u0266\u0261\3\2\2\2")
        buf.write("\u0267\u026a\3\2\2\2\u0268\u0266\3\2\2\2\u0268\u0269\3")
        buf.write("\2\2\2\u0269Q\3\2\2\2\u026a\u0268\3\2\2\2\u026b\u0278")
        buf.write("\5\u00c8e\2\u026c\u026e\5h\65\2\u026d\u026c\3\2\2\2\u026e")
        buf.write("\u0271\3\2\2\2\u026f\u026d\3\2\2\2\u026f\u0270\3\2\2\2")
        buf.write("\u0270\u0272\3\2\2\2\u0271\u026f\3\2\2\2\u0272\u0275\7")
        buf.write("M\2\2\u0273\u0274\t\2\2\2\u0274\u0276\5\u00c8e\2\u0275")
        buf.write("\u0273\3\2\2\2\u0275\u0276\3\2\2\2\u0276\u0278\3\2\2\2")
        buf.write("\u0277\u026b\3\2\2\2\u0277\u026f\3\2\2\2\u0278S\3\2\2")
        buf.write("\2\u0279\u027e\5^\60\2\u027a\u027b\7F\2\2\u027b\u027d")
        buf.write("\5^\60\2\u027c\u027a\3\2\2\2\u027d\u0280\3\2\2\2\u027e")
        buf.write("\u027c\3\2\2\2\u027e\u027f\3\2\2\2\u027fU\3\2\2\2\u0280")
        buf.write("\u027e\3\2\2\2\u0281\u0283\7?\2\2\u0282\u0284\5X-\2\u0283")
        buf.write("\u0282\3\2\2\2\u0283\u0284\3\2\2\2\u0284\u0285\3\2\2\2")
        buf.write("\u0285\u0286\7@\2\2\u0286W\3\2\2\2\u0287\u028c\5Z.\2\u0288")
        buf.write("\u0289\7F\2\2\u0289\u028b\5Z.\2\u028a\u0288\3\2\2\2\u028b")
        buf.write("\u028e\3\2\2\2\u028c\u028a\3\2\2\2\u028c\u028d\3\2\2\2")
        buf.write("\u028d\u0291\3\2\2\2\u028e\u028c\3\2\2\2\u028f\u0290\7")
        buf.write("F\2\2\u0290\u0292\5\\/\2\u0291\u028f\3\2\2\2\u0291\u0292")
        buf.write("\3\2\2\2\u0292\u0295\3\2\2\2\u0293\u0295\5\\/\2\u0294")
        buf.write("\u0287\3\2\2\2\u0294\u0293\3\2\2\2\u0295Y\3\2\2\2\u0296")
        buf.write("\u0298\5\16\b\2\u0297\u0296\3\2\2\2\u0298\u029b\3\2\2")
        buf.write("\2\u0299\u0297\3\2\2\2\u0299\u029a\3\2\2\2\u029a\u029c")
        buf.write("\3\2\2\2\u029b\u0299\3\2\2\2\u029c\u029d\5\u00c8e\2\u029d")
        buf.write("\u029e\5J&\2\u029e[\3\2\2\2\u029f\u02a1\5\16\b\2\u02a0")
        buf.write("\u029f\3\2\2\2\u02a1\u02a4\3\2\2\2\u02a2\u02a0\3\2\2\2")
        buf.write("\u02a2\u02a3\3\2\2\2\u02a3\u02a5\3\2\2\2\u02a4\u02a2\3")
        buf.write("\2\2\2\u02a5\u02a9\5\u00c8e\2\u02a6\u02a8\5h\65\2\u02a7")
        buf.write("\u02a6\3\2\2\2\u02a8\u02ab\3\2\2\2\u02a9\u02a7\3\2\2\2")
        buf.write("\u02a9\u02aa\3\2\2\2\u02aa\u02ac\3\2\2\2\u02ab\u02a9\3")
        buf.write("\2\2\2\u02ac\u02ad\7m\2\2\u02ad\u02ae\5J&\2\u02ae]\3\2")
        buf.write("\2\2\u02af\u02b4\7r\2\2\u02b0\u02b1\7G\2\2\u02b1\u02b3")
        buf.write("\7r\2\2\u02b2\u02b0\3\2\2\2\u02b3\u02b6\3\2\2\2\u02b4")
        buf.write("\u02b2\3\2\2\2\u02b4\u02b5\3\2\2\2\u02b5_\3\2\2\2\u02b6")
        buf.write("\u02b4\3\2\2\2\u02b7\u02be\5b\62\2\u02b8\u02be\5d\63\2")
        buf.write("\u02b9\u02be\7<\2\2\u02ba\u02be\7=\2\2\u02bb\u02be\7;")
        buf.write("\2\2\u02bc\u02be\7>\2\2\u02bd\u02b7\3\2\2\2\u02bd\u02b8")
        buf.write("\3\2\2\2\u02bd\u02b9\3\2\2\2\u02bd\u02ba\3\2\2\2\u02bd")
        buf.write("\u02bb\3\2\2\2\u02bd\u02bc\3\2\2\2\u02bea\3\2\2\2\u02bf")
        buf.write("\u02c0\t\3\2\2\u02c0c\3\2\2\2\u02c1\u02c2\t\4\2\2\u02c2")
        buf.write("e\3\2\2\2\u02c3\u02c4\7r\2\2\u02c4\u02c6\7G\2\2\u02c5")
        buf.write("\u02c3\3\2\2\2\u02c6\u02c9\3\2\2\2\u02c7\u02c5\3\2\2\2")
        buf.write("\u02c7\u02c8\3\2\2\2\u02c8\u02ca\3\2\2\2\u02c9\u02c7\3")
        buf.write("\2\2\2\u02ca\u02cb\7l\2\2\u02cb\u02cc\7r\2\2\u02ccg\3")
        buf.write("\2\2\2\u02cd\u02ce\7l\2\2\u02ce\u02d1\5^\60\2\u02cf\u02d1")
        buf.write("\5f\64\2\u02d0\u02cd\3\2\2\2\u02d0\u02cf\3\2\2\2\u02d1")
        buf.write("\u02d8\3\2\2\2\u02d2\u02d5\7?\2\2\u02d3\u02d6\5j\66\2")
        buf.write("\u02d4\u02d6\5n8\2\u02d5\u02d3\3\2\2\2\u02d5\u02d4\3\2")
        buf.write("\2\2\u02d5\u02d6\3\2\2\2\u02d6\u02d7\3\2\2\2\u02d7\u02d9")
        buf.write("\7@\2\2\u02d8\u02d2\3\2\2\2\u02d8\u02d9\3\2\2\2\u02d9")
        buf.write("i\3\2\2\2\u02da\u02df\5l\67\2\u02db\u02dc\7F\2\2\u02dc")
        buf.write("\u02de\5l\67\2\u02dd\u02db\3\2\2\2\u02de\u02e1\3\2\2\2")
        buf.write("\u02df\u02dd\3\2\2\2\u02df\u02e0\3\2\2\2\u02e0k\3\2\2")
        buf.write("\2\u02e1\u02df\3\2\2\2\u02e2\u02e3\7r\2\2\u02e3\u02e4")
        buf.write("\7H\2\2\u02e4\u02e5\5n8\2\u02e5m\3\2\2\2\u02e6\u02ea\5")
        buf.write("\u00a8U\2\u02e7\u02ea\5h\65\2\u02e8\u02ea\5p9\2\u02e9")
        buf.write("\u02e6\3\2\2\2\u02e9\u02e7\3\2\2\2\u02e9\u02e8\3\2\2\2")
        buf.write("\u02eao\3\2\2\2\u02eb\u02f4\7A\2\2\u02ec\u02f1\5n8\2\u02ed")
        buf.write("\u02ee\7F\2\2\u02ee\u02f0\5n8\2\u02ef\u02ed\3\2\2\2\u02f0")
        buf.write("\u02f3\3\2\2\2\u02f1\u02ef\3\2\2\2\u02f1\u02f2\3\2\2\2")
        buf.write("\u02f2\u02f5\3\2\2\2\u02f3\u02f1\3\2\2\2\u02f4\u02ec\3")
        buf.write("\2\2\2\u02f4\u02f5\3\2\2\2\u02f5\u02f7\3\2\2\2\u02f6\u02f8")
        buf.write("\7F\2\2\u02f7\u02f6\3\2\2\2\u02f7\u02f8\3\2\2\2\u02f8")
        buf.write("\u02f9\3\2\2\2\u02f9\u02fa\7B\2\2\u02faq\3\2\2\2\u02fb")
        buf.write("\u02fc\7l\2\2\u02fc\u02fd\7\36\2\2\u02fd\u02fe\7r\2\2")
        buf.write("\u02fe\u02ff\5t;\2\u02ffs\3\2\2\2\u0300\u0304\7A\2\2\u0301")
        buf.write("\u0303\5v<\2\u0302\u0301\3\2\2\2\u0303\u0306\3\2\2\2\u0304")
        buf.write("\u0302\3\2\2\2\u0304\u0305\3\2\2\2\u0305\u0307\3\2\2\2")
        buf.write("\u0306\u0304\3\2\2\2\u0307\u0308\7B\2\2\u0308u\3\2\2\2")
        buf.write("\u0309\u030b\5\n\6\2\u030a\u0309\3\2\2\2\u030b\u030e\3")
        buf.write("\2\2\2\u030c\u030a\3\2\2\2\u030c\u030d\3\2\2\2\u030d\u030f")
        buf.write("\3\2\2\2\u030e\u030c\3\2\2\2\u030f\u0312\5x=\2\u0310\u0312")
        buf.write("\7E\2\2\u0311\u030c\3\2\2\2\u0311\u0310\3\2\2\2\u0312")
        buf.write("w\3\2\2\2\u0313\u0314\5\u00c8e\2\u0314\u0315\5z>\2\u0315")
        buf.write("\u0316\7E\2\2\u0316\u0328\3\2\2\2\u0317\u0319\5\20\t\2")
        buf.write("\u0318\u031a\7E\2\2\u0319\u0318\3\2\2\2\u0319\u031a\3")
        buf.write("\2\2\2\u031a\u0328\3\2\2\2\u031b\u031d\5 \21\2\u031c\u031e")
        buf.write("\7E\2\2\u031d\u031c\3\2\2\2\u031d\u031e\3\2\2\2\u031e")
        buf.write("\u0328\3\2\2\2\u031f\u0321\5\30\r\2\u0320\u0322\7E\2\2")
        buf.write("\u0321\u0320\3\2\2\2\u0321\u0322\3\2\2\2\u0322\u0328\3")
        buf.write("\2\2\2\u0323\u0325\5r:\2\u0324\u0326\7E\2\2\u0325\u0324")
        buf.write("\3\2\2\2\u0325\u0326\3\2\2\2\u0326\u0328\3\2\2\2\u0327")
        buf.write("\u0313\3\2\2\2\u0327\u0317\3\2\2\2\u0327\u031b\3\2\2\2")
        buf.write("\u0327\u031f\3\2\2\2\u0327\u0323\3\2\2\2\u0328y\3\2\2")
        buf.write("\2\u0329\u032c\5|?\2\u032a\u032c\5~@\2\u032b\u0329\3\2")
        buf.write("\2\2\u032b\u032a\3\2\2\2\u032c{\3\2\2\2\u032d\u032e\7")
        buf.write("r\2\2\u032e\u032f\7?\2\2\u032f\u0331\7@\2\2\u0330\u0332")
        buf.write("\5\u0080A\2\u0331\u0330\3\2\2\2\u0331\u0332\3\2\2\2\u0332")
        buf.write("}\3\2\2\2\u0333\u0334\5F$\2\u0334\177\3\2\2\2\u0335\u0336")
        buf.write("\7\16\2\2\u0336\u0337\5n8\2\u0337\u0081\3\2\2\2\u0338")
        buf.write("\u033c\7A\2\2\u0339\u033b\5\u0084C\2\u033a\u0339\3\2\2")
        buf.write("\2\u033b\u033e\3\2\2\2\u033c\u033a\3\2\2\2\u033c\u033d")
        buf.write("\3\2\2\2\u033d\u033f\3\2\2\2\u033e\u033c\3\2\2\2\u033f")
        buf.write("\u0340\7B\2\2\u0340\u0083\3\2\2\2\u0341\u0342\5\u0086")
        buf.write("D\2\u0342\u0343\7E\2\2\u0343\u0347\3\2\2\2\u0344\u0347")
        buf.write("\5\u008aF\2\u0345\u0347\5\u0088E\2\u0346\u0341\3\2\2\2")
        buf.write("\u0346\u0344\3\2\2\2\u0346\u0345\3\2\2\2\u0347\u0085\3")
        buf.write("\2\2\2\u0348\u034a\5\16\b\2\u0349\u0348\3\2\2\2\u034a")
        buf.write("\u034d\3\2\2\2\u034b\u0349\3\2\2\2\u034b\u034c\3\2\2\2")
        buf.write("\u034c\u034e\3\2\2\2\u034d\u034b\3\2\2\2\u034e\u034f\5")
        buf.write("\u00c8e\2\u034f\u0350\5F$\2\u0350\u0087\3\2\2\2\u0351")
        buf.write("\u0353\5\f\7\2\u0352\u0351\3\2\2\2\u0353\u0356\3\2\2\2")
        buf.write("\u0354\u0352\3\2\2\2\u0354\u0355\3\2\2\2\u0355\u0359\3")
        buf.write("\2\2\2\u0356\u0354\3\2\2\2\u0357\u035a\5\20\t\2\u0358")
        buf.write("\u035a\5 \21\2\u0359\u0357\3\2\2\2\u0359\u0358\3\2\2\2")
        buf.write("\u035a\u035d\3\2\2\2\u035b\u035d\7E\2\2\u035c\u0354\3")
        buf.write("\2\2\2\u035c\u035b\3\2\2\2\u035d\u0089\3\2\2\2\u035e\u03c7")
        buf.write("\5\u0082B\2\u035f\u0360\7\4\2\2\u0360\u0363\5\u00a8U\2")
        buf.write("\u0361\u0362\7N\2\2\u0362\u0364\5\u00a8U\2\u0363\u0361")
        buf.write("\3\2\2\2\u0363\u0364\3\2\2\2\u0364\u0365\3\2\2\2\u0365")
        buf.write("\u0366\7E\2\2\u0366\u03c7\3\2\2\2\u0367\u0368\7\30\2\2")
        buf.write("\u0368\u0369\5\u00a2R\2\u0369\u036c\5\u008aF\2\u036a\u036b")
        buf.write("\7\21\2\2\u036b\u036d\5\u008aF\2\u036c\u036a\3\2\2\2\u036c")
        buf.write("\u036d\3\2\2\2\u036d\u03c7\3\2\2\2\u036e\u036f\7\27\2")
        buf.write("\2\u036f\u0370\7?\2\2\u0370\u0371\5\u009cO\2\u0371\u0372")
        buf.write("\7@\2\2\u0372\u0373\5\u008aF\2\u0373\u03c7\3\2\2\2\u0374")
        buf.write("\u0375\7\64\2\2\u0375\u0376\5\u00a2R\2\u0376\u0377\5\u008a")
        buf.write("F\2\u0377\u03c7\3\2\2\2\u0378\u0379\7\17\2\2\u0379\u037a")
        buf.write("\5\u008aF\2\u037a\u037b\7\64\2\2\u037b\u037c\5\u00a2R")
        buf.write("\2\u037c\u037d\7E\2\2\u037d\u03c7\3\2\2\2\u037e\u037f")
        buf.write("\7\61\2\2\u037f\u0389\5\u0082B\2\u0380\u0382\5\u008cG")
        buf.write("\2\u0381\u0380\3\2\2\2\u0382\u0383\3\2\2\2\u0383\u0381")
        buf.write("\3\2\2\2\u0383\u0384\3\2\2\2\u0384\u0386\3\2\2\2\u0385")
        buf.write("\u0387\5\u0090I\2\u0386\u0385\3\2\2\2\u0386\u0387\3\2")
        buf.write("\2\2\u0387\u038a\3\2\2\2\u0388\u038a\5\u0090I\2\u0389")
        buf.write("\u0381\3\2\2\2\u0389\u0388\3\2\2\2\u038a\u03c7\3\2\2\2")
        buf.write("\u038b\u038c\7\61\2\2\u038c\u038d\5\u0092J\2\u038d\u0391")
        buf.write("\5\u0082B\2\u038e\u0390\5\u008cG\2\u038f\u038e\3\2\2\2")
        buf.write("\u0390\u0393\3\2\2\2\u0391\u038f\3\2\2\2\u0391\u0392\3")
        buf.write("\2\2\2\u0392\u0395\3\2\2\2\u0393\u0391\3\2\2\2\u0394\u0396")
        buf.write("\5\u0090I\2\u0395\u0394\3\2\2\2\u0395\u0396\3\2\2\2\u0396")
        buf.write("\u03c7\3\2\2\2\u0397\u0398\7+\2\2\u0398\u0399\5\u00a2")
        buf.write("R\2\u0399\u039d\7A\2\2\u039a\u039c\5\u0098M\2\u039b\u039a")
        buf.write("\3\2\2\2\u039c\u039f\3\2\2\2\u039d\u039b\3\2\2\2\u039d")
        buf.write("\u039e\3\2\2\2\u039e\u03a3\3\2\2\2\u039f\u039d\3\2\2\2")
        buf.write("\u03a0\u03a2\5\u009aN\2\u03a1\u03a0\3\2\2\2\u03a2\u03a5")
        buf.write("\3\2\2\2\u03a3\u03a1\3\2\2\2\u03a3\u03a4\3\2\2\2\u03a4")
        buf.write("\u03a6\3\2\2\2\u03a5\u03a3\3\2\2\2\u03a6\u03a7\7B\2\2")
        buf.write("\u03a7\u03c7\3\2\2\2\u03a8\u03a9\7,\2\2\u03a9\u03aa\5")
        buf.write("\u00a2R\2\u03aa\u03ab\5\u0082B\2\u03ab\u03c7\3\2\2\2\u03ac")
        buf.write("\u03ae\7&\2\2\u03ad\u03af\5\u00a8U\2\u03ae\u03ad\3\2\2")
        buf.write("\2\u03ae\u03af\3\2\2\2\u03af\u03b0\3\2\2\2\u03b0\u03c7")
        buf.write("\7E\2\2\u03b1\u03b2\7.\2\2\u03b2\u03b3\5\u00a8U\2\u03b3")
        buf.write("\u03b4\7E\2\2\u03b4\u03c7\3\2\2\2\u03b5\u03b7\7\6\2\2")
        buf.write("\u03b6\u03b8\7r\2\2\u03b7\u03b6\3\2\2\2\u03b7\u03b8\3")
        buf.write("\2\2\2\u03b8\u03b9\3\2\2\2\u03b9\u03c7\7E\2\2\u03ba\u03bc")
        buf.write("\7\r\2\2\u03bb\u03bd\7r\2\2\u03bc\u03bb\3\2\2\2\u03bc")
        buf.write("\u03bd\3\2\2\2\u03bd\u03be\3\2\2\2\u03be\u03c7\7E\2\2")
        buf.write("\u03bf\u03c7\7E\2\2\u03c0\u03c1\5\u00a8U\2\u03c1\u03c2")
        buf.write("\7E\2\2\u03c2\u03c7\3\2\2\2\u03c3\u03c4\7r\2\2\u03c4\u03c5")
        buf.write("\7N\2\2\u03c5\u03c7\5\u008aF\2\u03c6\u035e\3\2\2\2\u03c6")
        buf.write("\u035f\3\2\2\2\u03c6\u0367\3\2\2\2\u03c6\u036e\3\2\2\2")
        buf.write("\u03c6\u0374\3\2\2\2\u03c6\u0378\3\2\2\2\u03c6\u037e\3")
        buf.write("\2\2\2\u03c6\u038b\3\2\2\2\u03c6\u0397\3\2\2\2\u03c6\u03a8")
        buf.write("\3\2\2\2\u03c6\u03ac\3\2\2\2\u03c6\u03b1\3\2\2\2\u03c6")
        buf.write("\u03b5\3\2\2\2\u03c6\u03ba\3\2\2\2\u03c6\u03bf\3\2\2\2")
        buf.write("\u03c6\u03c0\3\2\2\2\u03c6\u03c3\3\2\2\2\u03c7\u008b\3")
        buf.write("\2\2\2\u03c8\u03c9\7\t\2\2\u03c9\u03cd\7?\2\2\u03ca\u03cc")
        buf.write("\5\16\b\2\u03cb\u03ca\3\2\2\2\u03cc\u03cf\3\2\2\2\u03cd")
        buf.write("\u03cb\3\2\2\2\u03cd\u03ce\3\2\2\2\u03ce\u03d0\3\2\2\2")
        buf.write("\u03cf\u03cd\3\2\2\2\u03d0\u03d1\5\u008eH\2\u03d1\u03d2")
        buf.write("\7r\2\2\u03d2\u03d3\7@\2\2\u03d3\u03d4\5\u0082B\2\u03d4")
        buf.write("\u008d\3\2\2\2\u03d5\u03da\5^\60\2\u03d6\u03d7\7\\\2\2")
        buf.write("\u03d7\u03d9\5^\60\2\u03d8\u03d6\3\2\2\2\u03d9\u03dc\3")
        buf.write("\2\2\2\u03da\u03d8\3\2\2\2\u03da\u03db\3\2\2\2\u03db\u008f")
        buf.write("\3\2\2\2\u03dc\u03da\3\2\2\2\u03dd\u03de\7\25\2\2\u03de")
        buf.write("\u03df\5\u0082B\2\u03df\u0091\3\2\2\2\u03e0\u03e1\7?\2")
        buf.write("\2\u03e1\u03e3\5\u0094K\2\u03e2\u03e4\7E\2\2\u03e3\u03e2")
        buf.write("\3\2\2\2\u03e3\u03e4\3\2\2\2\u03e4\u03e5\3\2\2\2\u03e5")
        buf.write("\u03e6\7@\2\2\u03e6\u0093\3\2\2\2\u03e7\u03ec\5\u0096")
        buf.write("L\2\u03e8\u03e9\7E\2\2\u03e9\u03eb\5\u0096L\2\u03ea\u03e8")
        buf.write("\3\2\2\2\u03eb\u03ee\3\2\2\2\u03ec\u03ea\3\2\2\2\u03ec")
        buf.write("\u03ed\3\2\2\2\u03ed\u0095\3\2\2\2\u03ee\u03ec\3\2\2\2")
        buf.write("\u03ef\u03f1\5\16\b\2\u03f0\u03ef\3\2\2\2\u03f1\u03f4")
        buf.write("\3\2\2\2\u03f2\u03f0\3\2\2\2\u03f2\u03f3\3\2\2\2\u03f3")
        buf.write("\u03f5\3\2\2\2\u03f4\u03f2\3\2\2\2\u03f5\u03f6\5P)\2\u03f6")
        buf.write("\u03f7\5J&\2\u03f7\u03f8\7H\2\2\u03f8\u03f9\5\u00a8U\2")
        buf.write("\u03f9\u0097\3\2\2\2\u03fa\u03fc\5\u009aN\2\u03fb\u03fa")
        buf.write("\3\2\2\2\u03fc\u03fd\3\2\2\2\u03fd\u03fb\3\2\2\2\u03fd")
        buf.write("\u03fe\3\2\2\2\u03fe\u0400\3\2\2\2\u03ff\u0401\5\u0084")
        buf.write("C\2\u0400\u03ff\3\2\2\2\u0401\u0402\3\2\2\2\u0402\u0400")
        buf.write("\3\2\2\2\u0402\u0403\3\2\2\2\u0403\u0099\3\2\2\2\u0404")
        buf.write("\u0407\7\b\2\2\u0405\u0408\5\u00a8U\2\u0406\u0408\7r\2")
        buf.write("\2\u0407\u0405\3\2\2\2\u0407\u0406\3\2\2\2\u0408\u0409")
        buf.write("\3\2\2\2\u0409\u040d\7N\2\2\u040a\u040b\7\16\2\2\u040b")
        buf.write("\u040d\7N\2\2\u040c\u0404\3\2\2\2\u040c\u040a\3\2\2\2")
        buf.write("\u040d\u009b\3\2\2\2\u040e\u041b\5\u00a0Q\2\u040f\u0411")
        buf.write("\5\u009eP\2\u0410\u040f\3\2\2\2\u0410\u0411\3\2\2\2\u0411")
        buf.write("\u0412\3\2\2\2\u0412\u0414\7E\2\2\u0413\u0415\5\u00a8")
        buf.write("U\2\u0414\u0413\3\2\2\2\u0414\u0415\3\2\2\2\u0415\u0416")
        buf.write("\3\2\2\2\u0416\u0418\7E\2\2\u0417\u0419\5\u00a4S\2\u0418")
        buf.write("\u0417\3\2\2\2\u0418\u0419\3\2\2\2\u0419\u041b\3\2\2\2")
        buf.write("\u041a\u040e\3\2\2\2\u041a\u0410\3\2\2\2\u041b\u009d\3")
        buf.write("\2\2\2\u041c\u041f\5\u0086D\2\u041d\u041f\5\u00a4S\2\u041e")
        buf.write("\u041c\3\2\2\2\u041e\u041d\3\2\2\2\u041f\u009f\3\2\2\2")
        buf.write("\u0420\u0422\5\16\b\2\u0421\u0420\3\2\2\2\u0422\u0425")
        buf.write("\3\2\2\2\u0423\u0421\3\2\2\2\u0423\u0424\3\2\2\2\u0424")
        buf.write("\u0426\3\2\2\2\u0425\u0423\3\2\2\2\u0426\u0427\5\u00c8")
        buf.write("e\2\u0427\u0428\5J&\2\u0428\u0429\7N\2\2\u0429\u042a\5")
        buf.write("\u00a8U\2\u042a\u00a1\3\2\2\2\u042b\u042c\7?\2\2\u042c")
        buf.write("\u042d\5\u00a8U\2\u042d\u042e\7@\2\2\u042e\u00a3\3\2\2")
        buf.write("\2\u042f\u0434\5\u00a8U\2\u0430\u0431\7F\2\2\u0431\u0433")
        buf.write("\5\u00a8U\2\u0432\u0430\3\2\2\2\u0433\u0436\3\2\2\2\u0434")
        buf.write("\u0432\3\2\2\2\u0434\u0435\3\2\2\2\u0435\u00a5\3\2\2\2")
        buf.write("\u0436\u0434\3\2\2\2\u0437\u0438\7r\2\2\u0438\u043a\7")
        buf.write("?\2\2\u0439\u043b\5\u00a4S\2\u043a\u0439\3\2\2\2\u043a")
        buf.write("\u043b\3\2\2\2\u043b\u043c\3\2\2\2\u043c\u044a\7@\2\2")
        buf.write("\u043d\u043e\7-\2\2\u043e\u0440\7?\2\2\u043f\u0441\5\u00a4")
        buf.write("S\2\u0440\u043f\3\2\2\2\u0440\u0441\3\2\2\2\u0441\u0442")
        buf.write("\3\2\2\2\u0442\u044a\7@\2\2\u0443\u0444\7*\2\2\u0444\u0446")
        buf.write("\7?\2\2\u0445\u0447\5\u00a4S\2\u0446\u0445\3\2\2\2\u0446")
        buf.write("\u0447\3\2\2\2\u0447\u0448\3\2\2\2\u0448\u044a\7@\2\2")
        buf.write("\u0449\u0437\3\2\2\2\u0449\u043d\3\2\2\2\u0449\u0443\3")
        buf.write("\2\2\2\u044a\u00a7\3\2\2\2\u044b\u044c\bU\1\2\u044c\u0478")
        buf.write("\5\u00b0Y\2\u044d\u0478\5\u00a6T\2\u044e\u044f\7!\2\2")
        buf.write("\u044f\u0478\5\u00b4[\2\u0450\u0454\7?\2\2\u0451\u0453")
        buf.write("\5h\65\2\u0452\u0451\3\2\2\2\u0453\u0456\3\2\2\2\u0454")
        buf.write("\u0452\3\2\2\2\u0454\u0455\3\2\2\2\u0455\u0457\3\2\2\2")
        buf.write("\u0456\u0454\3\2\2\2\u0457\u045c\5\u00c8e\2\u0458\u0459")
        buf.write("\7[\2\2\u0459\u045b\5\u00c8e\2\u045a\u0458\3\2\2\2\u045b")
        buf.write("\u045e\3\2\2\2\u045c\u045a\3\2\2\2\u045c\u045d\3\2\2\2")
        buf.write("\u045d\u045f\3\2\2\2\u045e\u045c\3\2\2\2\u045f\u0460\7")
        buf.write("@\2\2\u0460\u0461\5\u00a8U\27\u0461\u0478\3\2\2\2\u0462")
        buf.write("\u0463\t\5\2\2\u0463\u0478\5\u00a8U\25\u0464\u0465\t\6")
        buf.write("\2\2\u0465\u0478\5\u00a8U\24\u0466\u0478\5\u00aaV\2\u0467")
        buf.write("\u0468\5\u00c8e\2\u0468\u046e\7k\2\2\u0469\u046b\5\u00cc")
        buf.write("g\2\u046a\u0469\3\2\2\2\u046a\u046b\3\2\2\2\u046b\u046c")
        buf.write("\3\2\2\2\u046c\u046f\7r\2\2\u046d\u046f\7!\2\2\u046e\u046a")
        buf.write("\3\2\2\2\u046e\u046d\3\2\2\2\u046f\u0478\3\2\2\2\u0470")
        buf.write("\u0471\5\u00b2Z\2\u0471\u0473\7k\2\2\u0472\u0474\5\u00cc")
        buf.write("g\2\u0473\u0472\3\2\2\2\u0473\u0474\3\2\2\2\u0474\u0475")
        buf.write("\3\2\2\2\u0475\u0476\7!\2\2\u0476\u0478\3\2\2\2\u0477")
        buf.write("\u044b\3\2\2\2\u0477\u044d\3\2\2\2\u0477\u044e\3\2\2\2")
        buf.write("\u0477\u0450\3\2\2\2\u0477\u0462\3\2\2\2\u0477\u0464\3")
        buf.write("\2\2\2\u0477\u0466\3\2\2\2\u0477\u0467\3\2\2\2\u0477\u0470")
        buf.write("\3\2\2\2\u0478\u04c9\3\2\2\2\u0479\u047a\f\23\2\2\u047a")
        buf.write("\u047b\t\7\2\2\u047b\u04c8\5\u00a8U\24\u047c\u047d\f\22")
        buf.write("\2\2\u047d\u047e\t\b\2\2\u047e\u04c8\5\u00a8U\23\u047f")
        buf.write("\u0487\f\21\2\2\u0480\u0481\7J\2\2\u0481\u0488\7J\2\2")
        buf.write("\u0482\u0483\7I\2\2\u0483\u0484\7I\2\2\u0484\u0488\7I")
        buf.write("\2\2\u0485\u0486\7I\2\2\u0486\u0488\7I\2\2\u0487\u0480")
        buf.write("\3\2\2\2\u0487\u0482\3\2\2\2\u0487\u0485\3\2\2\2\u0488")
        buf.write("\u0489\3\2\2\2\u0489\u04c8\5\u00a8U\22\u048a\u048b\f\20")
        buf.write("\2\2\u048b\u048c\t\t\2\2\u048c\u04c8\5\u00a8U\21\u048d")
        buf.write("\u048e\f\16\2\2\u048e\u048f\t\n\2\2\u048f\u04c8\5\u00a8")
        buf.write("U\17\u0490\u0491\f\r\2\2\u0491\u0492\7[\2\2\u0492\u04c8")
        buf.write("\5\u00a8U\16\u0493\u0494\f\f\2\2\u0494\u0495\7]\2\2\u0495")
        buf.write("\u04c8\5\u00a8U\r\u0496\u0497\f\13\2\2\u0497\u0498\7\\")
        buf.write("\2\2\u0498\u04c8\5\u00a8U\f\u0499\u049a\f\n\2\2\u049a")
        buf.write("\u049b\7S\2\2\u049b\u04c8\5\u00a8U\13\u049c\u049d\f\t")
        buf.write("\2\2\u049d\u049e\7T\2\2\u049e\u04c8\5\u00a8U\n\u049f\u04a0")
        buf.write("\f\b\2\2\u04a0\u04a1\7M\2\2\u04a1\u04a2\5\u00a8U\2\u04a2")
        buf.write("\u04a3\7N\2\2\u04a3\u04a4\5\u00a8U\b\u04a4\u04c8\3\2\2")
        buf.write("\2\u04a5\u04a6\f\7\2\2\u04a6\u04a7\t\13\2\2\u04a7\u04c8")
        buf.write("\5\u00a8U\7\u04a8\u04a9\f\33\2\2\u04a9\u04b5\7G\2\2\u04aa")
        buf.write("\u04b6\7r\2\2\u04ab\u04b6\5\u00a6T\2\u04ac\u04b6\7-\2")
        buf.write("\2\u04ad\u04af\7!\2\2\u04ae\u04b0\5\u00c4c\2\u04af\u04ae")
        buf.write("\3\2\2\2\u04af\u04b0\3\2\2\2\u04b0\u04b1\3\2\2\2\u04b1")
        buf.write("\u04b6\5\u00b8]\2\u04b2\u04b3\7*\2\2\u04b3\u04b6\5\u00ce")
        buf.write("h\2\u04b4\u04b6\5\u00be`\2\u04b5\u04aa\3\2\2\2\u04b5\u04ab")
        buf.write("\3\2\2\2\u04b5\u04ac\3\2\2\2\u04b5\u04ad\3\2\2\2\u04b5")
        buf.write("\u04b2\3\2\2\2\u04b5\u04b4\3\2\2\2\u04b6\u04c8\3\2\2\2")
        buf.write("\u04b7\u04b8\f\32\2\2\u04b8\u04b9\7C\2\2\u04b9\u04ba\5")
        buf.write("\u00a8U\2\u04ba\u04bb\7D\2\2\u04bb\u04c8\3\2\2\2\u04bc")
        buf.write("\u04bd\f\26\2\2\u04bd\u04c8\t\f\2\2\u04be\u04bf\f\17\2")
        buf.write("\2\u04bf\u04c0\7\34\2\2\u04c0\u04c8\5\u00c8e\2\u04c1\u04c2")
        buf.write("\f\5\2\2\u04c2\u04c4\7k\2\2\u04c3\u04c5\5\u00ccg\2\u04c4")
        buf.write("\u04c3\3\2\2\2\u04c4\u04c5\3\2\2\2\u04c5\u04c6\3\2\2\2")
        buf.write("\u04c6\u04c8\7r\2\2\u04c7\u0479\3\2\2\2\u04c7\u047c\3")
        buf.write("\2\2\2\u04c7\u047f\3\2\2\2\u04c7\u048a\3\2\2\2\u04c7\u048d")
        buf.write("\3\2\2\2\u04c7\u0490\3\2\2\2\u04c7\u0493\3\2\2\2\u04c7")
        buf.write("\u0496\3\2\2\2\u04c7\u0499\3\2\2\2\u04c7\u049c\3\2\2\2")
        buf.write("\u04c7\u049f\3\2\2\2\u04c7\u04a5\3\2\2\2\u04c7\u04a8\3")
        buf.write("\2\2\2\u04c7\u04b7\3\2\2\2\u04c7\u04bc\3\2\2\2\u04c7\u04be")
        buf.write("\3\2\2\2\u04c7\u04c1\3\2\2\2\u04c8\u04cb\3\2\2\2\u04c9")
        buf.write("\u04c7\3\2\2\2\u04c9\u04ca\3\2\2\2\u04ca\u00a9\3\2\2\2")
        buf.write("\u04cb\u04c9\3\2\2\2\u04cc\u04cd\5\u00acW\2\u04cd\u04ce")
        buf.write("\7j\2\2\u04ce\u04cf\5\u00aeX\2\u04cf\u00ab\3\2\2\2\u04d0")
        buf.write("\u04e1\7r\2\2\u04d1\u04d3\7?\2\2\u04d2\u04d4\5X-\2\u04d3")
        buf.write("\u04d2\3\2\2\2\u04d3\u04d4\3\2\2\2\u04d4\u04d5\3\2\2\2")
        buf.write("\u04d5\u04e1\7@\2\2\u04d6\u04d7\7?\2\2\u04d7\u04dc\7r")
        buf.write("\2\2\u04d8\u04d9\7F\2\2\u04d9\u04db\7r\2\2\u04da\u04d8")
        buf.write("\3\2\2\2\u04db\u04de\3\2\2\2\u04dc\u04da\3\2\2\2\u04dc")
        buf.write("\u04dd\3\2\2\2\u04dd\u04df\3\2\2\2\u04de\u04dc\3\2\2\2")
        buf.write("\u04df\u04e1\7@\2\2\u04e0\u04d0\3\2\2\2\u04e0\u04d1\3")
        buf.write("\2\2\2\u04e0\u04d6\3\2\2\2\u04e1\u00ad\3\2\2\2\u04e2\u04e5")
        buf.write("\5\u00a8U\2\u04e3\u04e5\5\u0082B\2\u04e4\u04e2\3\2\2\2")
        buf.write("\u04e4\u04e3\3\2\2\2\u04e5\u00af\3\2\2\2\u04e6\u04e7\7")
        buf.write("?\2\2\u04e7\u04e8\5\u00a8U\2\u04e8\u04e9\7@\2\2\u04e9")
        buf.write("\u04f9\3\2\2\2\u04ea\u04f9\7-\2\2\u04eb\u04f9\7*\2\2\u04ec")
        buf.write("\u04f9\5`\61\2\u04ed\u04f9\7r\2\2\u04ee\u04ef\5.\30\2")
        buf.write("\u04ef\u04f0\7G\2\2\u04f0\u04f1\7\13\2\2\u04f1\u04f9\3")
        buf.write("\2\2\2\u04f2\u04f6\5\u00c4c\2\u04f3\u04f7\5\u00d0i\2\u04f4")
        buf.write("\u04f5\7-\2\2\u04f5\u04f7\5\u00d2j\2\u04f6\u04f3\3\2\2")
        buf.write("\2\u04f6\u04f4\3\2\2\2\u04f7\u04f9\3\2\2\2\u04f8\u04e6")
        buf.write("\3\2\2\2\u04f8\u04ea\3\2\2\2\u04f8\u04eb\3\2\2\2\u04f8")
        buf.write("\u04ec\3\2\2\2\u04f8\u04ed\3\2\2\2\u04f8\u04ee\3\2\2\2")
        buf.write("\u04f8\u04f2\3\2\2\2\u04f9\u00b1\3\2\2\2\u04fa\u04fb\5")
        buf.write("P)\2\u04fb\u04fc\7G\2\2\u04fc\u04fe\3\2\2\2\u04fd\u04fa")
        buf.write("\3\2\2\2\u04fd\u04fe\3\2\2\2\u04fe\u0502\3\2\2\2\u04ff")
        buf.write("\u0501\5h\65\2\u0500\u04ff\3\2\2\2\u0501\u0504\3\2\2\2")
        buf.write("\u0502\u0500\3\2\2\2\u0502\u0503\3\2\2\2\u0503\u0505\3")
        buf.write("\2\2\2\u0504\u0502\3\2\2\2\u0505\u0507\7r\2\2\u0506\u0508")
        buf.write("\5\u00ccg\2\u0507\u0506\3\2\2\2\u0507\u0508\3\2\2\2\u0508")
        buf.write("\u00b3\3\2\2\2\u0509\u050a\5\u00c4c\2\u050a\u050b\5\u00b6")
        buf.write("\\\2\u050b\u050c\5\u00bc_\2\u050c\u0513\3\2\2\2\u050d")
        buf.write("\u0510\5\u00b6\\\2\u050e\u0511\5\u00ba^\2\u050f\u0511")
        buf.write("\5\u00bc_\2\u0510\u050e\3\2\2\2\u0510\u050f\3\2\2\2\u0511")
        buf.write("\u0513\3\2\2\2\u0512\u0509\3\2\2\2\u0512\u050d\3\2\2\2")
        buf.write("\u0513\u00b5\3\2\2\2\u0514\u0516\7r\2\2\u0515\u0517\5")
        buf.write("\u00c0a\2\u0516\u0515\3\2\2\2\u0516\u0517\3\2\2\2\u0517")
        buf.write("\u051f\3\2\2\2\u0518\u0519\7G\2\2\u0519\u051b\7r\2\2\u051a")
        buf.write("\u051c\5\u00c0a\2\u051b\u051a\3\2\2\2\u051b\u051c\3\2")
        buf.write("\2\2\u051c\u051e\3\2\2\2\u051d\u0518\3\2\2\2\u051e\u0521")
        buf.write("\3\2\2\2\u051f\u051d\3\2\2\2\u051f\u0520\3\2\2\2\u0520")
        buf.write("\u0524\3\2\2\2\u0521\u051f\3\2\2\2\u0522\u0524\5\u00ca")
        buf.write("f\2\u0523\u0514\3\2\2\2\u0523\u0522\3\2\2\2\u0524\u00b7")
        buf.write("\3\2\2\2\u0525\u0527\7r\2\2\u0526\u0528\5\u00c2b\2\u0527")
        buf.write("\u0526\3\2\2\2\u0527\u0528\3\2\2\2\u0528\u0529\3\2\2\2")
        buf.write("\u0529\u052a\5\u00bc_\2\u052a\u00b9\3\2\2\2\u052b\u0547")
        buf.write("\7C\2\2\u052c\u0531\7D\2\2\u052d\u052e\7C\2\2\u052e\u0530")
        buf.write("\7D\2\2\u052f\u052d\3\2\2\2\u0530\u0533\3\2\2\2\u0531")
        buf.write("\u052f\3\2\2\2\u0531\u0532\3\2\2\2\u0532\u0534\3\2\2\2")
        buf.write("\u0533\u0531\3\2\2\2\u0534\u0548\5N(\2\u0535\u0536\5\u00a8")
        buf.write("U\2\u0536\u053d\7D\2\2\u0537\u0538\7C\2\2\u0538\u0539")
        buf.write("\5\u00a8U\2\u0539\u053a\7D\2\2\u053a\u053c\3\2\2\2\u053b")
        buf.write("\u0537\3\2\2\2\u053c\u053f\3\2\2\2\u053d\u053b\3\2\2\2")
        buf.write("\u053d\u053e\3\2\2\2\u053e\u0544\3\2\2\2\u053f\u053d\3")
        buf.write("\2\2\2\u0540\u0541\7C\2\2\u0541\u0543\7D\2\2\u0542\u0540")
        buf.write("\3\2\2\2\u0543\u0546\3\2\2\2\u0544\u0542\3\2\2\2\u0544")
        buf.write("\u0545\3\2\2\2\u0545\u0548\3\2\2\2\u0546\u0544\3\2\2\2")
        buf.write("\u0547\u052c\3\2\2\2\u0547\u0535\3\2\2\2\u0548\u00bb\3")
        buf.write('\2\2\2\u0549\u054b\5\u00d2j\2\u054a\u054c\5"\22\2\u054b')
        buf.write("\u054a\3\2\2\2\u054b\u054c\3\2\2\2\u054c\u00bd\3\2\2\2")
        buf.write("\u054d\u054e\5\u00c4c\2\u054e\u054f\5\u00d0i\2\u054f\u00bf")
        buf.write("\3\2\2\2\u0550\u0551\7J\2\2\u0551\u0554\7I\2\2\u0552\u0554")
        buf.write("\5\u00ccg\2\u0553\u0550\3\2\2\2\u0553\u0552\3\2\2\2\u0554")
        buf.write("\u00c1\3\2\2\2\u0555\u0556\7J\2\2\u0556\u0559\7I\2\2\u0557")
        buf.write("\u0559\5\u00c4c\2\u0558\u0555\3\2\2\2\u0558\u0557\3\2")
        buf.write("\2\2\u0559\u00c3\3\2\2\2\u055a\u055b\7J\2\2\u055b\u055c")
        buf.write("\5\u00c6d\2\u055c\u055d\7I\2\2\u055d\u00c5\3\2\2\2\u055e")
        buf.write("\u0563\5\u00c8e\2\u055f\u0560\7F\2\2\u0560\u0562\5\u00c8")
        buf.write("e\2\u0561\u055f\3\2\2\2\u0562\u0565\3\2\2\2\u0563\u0561")
        buf.write("\3\2\2\2\u0563\u0564\3\2\2\2\u0564\u00c7\3\2\2\2\u0565")
        buf.write("\u0563\3\2\2\2\u0566\u0568\5h\65\2\u0567\u0566\3\2\2\2")
        buf.write("\u0568\u056b\3\2\2\2\u0569\u0567\3\2\2\2\u0569\u056a\3")
        buf.write("\2\2\2\u056a\u056e\3\2\2\2\u056b\u0569\3\2\2\2\u056c\u056f")
        buf.write("\5P)\2\u056d\u056f\5\u00caf\2\u056e\u056c\3\2\2\2\u056e")
        buf.write("\u056d\3\2\2\2\u056f\u057a\3\2\2\2\u0570\u0572\5h\65\2")
        buf.write("\u0571\u0570\3\2\2\2\u0572\u0575\3\2\2\2\u0573\u0571\3")
        buf.write("\2\2\2\u0573\u0574\3\2\2\2\u0574\u0576\3\2\2\2\u0575\u0573")
        buf.write("\3\2\2\2\u0576\u0577\7C\2\2\u0577\u0579\7D\2\2\u0578\u0573")
        buf.write("\3\2\2\2\u0579\u057c\3\2\2\2\u057a\u0578\3\2\2\2\u057a")
        buf.write("\u057b\3\2\2\2\u057b\u00c9\3\2\2\2\u057c\u057a\3\2\2\2")
        buf.write("\u057d\u057e\t\r\2\2\u057e\u00cb\3\2\2\2\u057f\u0580\7")
        buf.write("J\2\2\u0580\u0585\5R*\2\u0581\u0582\7F\2\2\u0582\u0584")
        buf.write("\5R*\2\u0583\u0581\3\2\2\2\u0584\u0587\3\2\2\2\u0585\u0583")
        buf.write("\3\2\2\2\u0585\u0586\3\2\2\2\u0586\u0588\3\2\2\2\u0587")
        buf.write("\u0585\3\2\2\2\u0588\u0589\7I\2\2\u0589\u00cd\3\2\2\2")
        buf.write("\u058a\u0591\5\u00d2j\2\u058b\u058c\7G\2\2\u058c\u058e")
        buf.write("\7r\2\2\u058d\u058f\5\u00d2j\2\u058e\u058d\3\2\2\2\u058e")
        buf.write("\u058f\3\2\2\2\u058f\u0591\3\2\2\2\u0590\u058a\3\2\2\2")
        buf.write("\u0590\u058b\3\2\2\2\u0591\u00cf\3\2\2\2\u0592\u0593\7")
        buf.write("*\2\2\u0593\u0597\5\u00ceh\2\u0594\u0595\7r\2\2\u0595")
        buf.write("\u0597\5\u00d2j\2\u0596\u0592\3\2\2\2\u0596\u0594\3\2")
        buf.write("\2\2\u0597\u00d1\3\2\2\2\u0598\u059a\7?\2\2\u0599\u059b")
        buf.write("\5\u00a4S\2\u059a\u0599\3\2\2\2\u059a\u059b\3\2\2\2\u059b")
        buf.write("\u059c\3\2\2\2\u059c\u059d\7@\2\2\u059d\u00d3\3\2\2\2")
        buf.write("\u00b5\u00d5\u00da\u00e0\u00e8\u00f1\u00f6\u00fd\u0104")
        buf.write("\u0107\u010e\u0118\u011c\u0121\u0125\u0129\u0133\u013b")
        buf.write("\u0143\u0147\u014e\u0155\u0159\u015c\u015f\u0168\u016e")
        buf.write("\u0173\u0176\u017c\u0182\u0186\u018e\u0197\u019e\u01a4")
        buf.write("\u01a8\u01b3\u01bc\u01c1\u01c7\u01cb\u01d7\u01e2\u01e7")
        buf.write("\u01f0\u01f8\u0202\u020b\u0213\u0218\u0220\u0225\u022f")
        buf.write("\u0239\u023f\u0246\u024b\u0253\u0257\u0259\u025f\u0264")
        buf.write("\u0268\u026f\u0275\u0277\u027e\u0283\u028c\u0291\u0294")
        buf.write("\u0299\u02a2\u02a9\u02b4\u02bd\u02c7\u02d0\u02d5\u02d8")
        buf.write("\u02df\u02e9\u02f1\u02f4\u02f7\u0304\u030c\u0311\u0319")
        buf.write("\u031d\u0321\u0325\u0327\u032b\u0331\u033c\u0346\u034b")
        buf.write("\u0354\u0359\u035c\u0363\u036c\u0383\u0386\u0389\u0391")
        buf.write("\u0395\u039d\u03a3\u03ae\u03b7\u03bc\u03c6\u03cd\u03da")
        buf.write("\u03e3\u03ec\u03f2\u03fd\u0402\u0407\u040c\u0410\u0414")
        buf.write("\u0418\u041a\u041e\u0423\u0434\u043a\u0440\u0446\u0449")
        buf.write("\u0454\u045c\u046a\u046e\u0473\u0477\u0487\u04af\u04b5")
        buf.write("\u04c4\u04c7\u04c9\u04d3\u04dc\u04e0\u04e4\u04f6\u04f8")
        buf.write("\u04fd\u0502\u0507\u0510\u0512\u0516\u051b\u051f\u0523")
        buf.write("\u0527\u0531\u053d\u0544\u0547\u054b\u0553\u0558\u0563")
        buf.write("\u0569\u056e\u0573\u057a\u0585\u058e\u0590\u0596\u059a")
        return buf.getvalue()


class JavaParser(Parser):

    grammarFileName = "JavaParser.g4"

    atn = ATNDeserializer().deserialize(serializedATN())

    decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)]

    sharedContextCache = PredictionContextCache()

    literalNames = [
        "<INVALID>",
        "'abstract'",
        "'assert'",
        "'boolean'",
        "'break'",
        "'byte'",
        "'case'",
        "'catch'",
        "'char'",
        "'class'",
        "'const'",
        "'continue'",
        "'default'",
        "'do'",
        "'double'",
        "'else'",
        "'enum'",
        "'extends'",
        "'final'",
        "'finally'",
        "'float'",
        "'for'",
        "'if'",
        "'goto'",
        "'implements'",
        "'import'",
        "'instanceof'",
        "'int'",
        "'interface'",
        "'long'",
        "'native'",
        "'new'",
        "'package'",
        "'private'",
        "'protected'",
        "'public'",
        "'return'",
        "'short'",
        "'static'",
        "'strictfp'",
        "'super'",
        "'switch'",
        "'synchronized'",
        "'this'",
        "'throw'",
        "'throws'",
        "'transient'",
        "'try'",
        "'void'",
        "'volatile'",
        "'while'",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "<INVALID>",
        "'null'",
        "'('",
        "')'",
        "'{'",
        "'}'",
        "'['",
        "']'",
        "';'",
        "','",
        "'.'",
        "'='",
        "'>'",
        "'<'",
        "'!'",
        "'~'",
        "'?'",
        "':'",
        "'=='",
        "'<='",
        "'>='",
        "'!='",
        "'&&'",
        "'||'",
        "'++'",
        "'--'",
        "'+'",
        "'-'",
        "'*'",
        "'/'",
        "'&'",
        "'|'",
        "'^'",
        "'%'",
        "'+='",
        "'-='",
        "'*='",
        "'/='",
        "'&='",
        "'|='",
        "'^='",
        "'%='",
        "'<<='",
        "'>>='",
        "'>>>='",
        "'->'",
        "'::'",
        "'@'",
        "'...'",
    ]

    symbolicNames = [
        "<INVALID>",
        "ABSTRACT",
        "ASSERT",
        "BOOLEAN",
        "BREAK",
        "BYTE",
        "CASE",
        "CATCH",
        "CHAR",
        "CLASS",
        "CONST",
        "CONTINUE",
        "DEFAULT",
        "DO",
        "DOUBLE",
        "ELSE",
        "ENUM",
        "EXTENDS",
        "FINAL",
        "FINALLY",
        "FLOAT",
        "FOR",
        "IF",
        "GOTO",
        "IMPLEMENTS",
        "IMPORT",
        "INSTANCEOF",
        "INT",
        "INTERFACE",
        "LONG",
        "NATIVE",
        "NEW",
        "PACKAGE",
        "PRIVATE",
        "PROTECTED",
        "PUBLIC",
        "RETURN",
        "SHORT",
        "STATIC",
        "STRICTFP",
        "SUPER",
        "SWITCH",
        "SYNCHRONIZED",
        "THIS",
        "THROW",
        "THROWS",
        "TRANSIENT",
        "TRY",
        "VOID",
        "VOLATILE",
        "WHILE",
        "DECIMAL_LITERAL",
        "HEX_LITERAL",
        "OCT_LITERAL",
        "BINARY_LITERAL",
        "FLOAT_LITERAL",
        "HEX_FLOAT_LITERAL",
        "BOOL_LITERAL",
        "CHAR_LITERAL",
        "STRING_LITERAL",
        "NULL_LITERAL",
        "LPAREN",
        "RPAREN",
        "LBRACE",
        "RBRACE",
        "LBRACK",
        "RBRACK",
        "SEMI",
        "COMMA",
        "DOT",
        "ASSIGN",
        "GT",
        "LT",
        "BANG",
        "TILDE",
        "QUESTION",
        "COLON",
        "EQUAL",
        "LE",
        "GE",
        "NOTEQUAL",
        "AND",
        "OR",
        "INC",
        "DEC",
        "ADD",
        "SUB",
        "MUL",
        "DIV",
        "BITAND",
        "BITOR",
        "CARET",
        "MOD",
        "ADD_ASSIGN",
        "SUB_ASSIGN",
        "MUL_ASSIGN",
        "DIV_ASSIGN",
        "AND_ASSIGN",
        "OR_ASSIGN",
        "XOR_ASSIGN",
        "MOD_ASSIGN",
        "LSHIFT_ASSIGN",
        "RSHIFT_ASSIGN",
        "URSHIFT_ASSIGN",
        "ARROW",
        "COLONCOLON",
        "AT",
        "ELLIPSIS",
        "WS",
        "COMMENT",
        "LINE_COMMENT",
        "JAVADOC_COMMENT",
        "IDENTIFIER",
    ]

    RULE_compilationUnit = 0
    RULE_packageDeclaration = 1
    RULE_importDeclaration = 2
    RULE_typeDeclaration = 3
    RULE_modifier = 4
    RULE_classOrInterfaceModifier = 5
    RULE_variableModifier = 6
    RULE_classDeclaration = 7
    RULE_typeParameters = 8
    RULE_typeParameter = 9
    RULE_typeBound = 10
    RULE_enumDeclaration = 11
    RULE_enumConstants = 12
    RULE_enumConstant = 13
    RULE_enumBodyDeclarations = 14
    RULE_interfaceDeclaration = 15
    RULE_classBody = 16
    RULE_interfaceBody = 17
    RULE_classBodyDeclaration = 18
    RULE_memberDeclaration = 19
    RULE_methodDeclaration = 20
    RULE_methodBody = 21
    RULE_typeTypeOrVoid = 22
    RULE_genericMethodDeclaration = 23
    RULE_genericConstructorDeclaration = 24
    RULE_constructorDeclaration = 25
    RULE_fieldDeclaration = 26
    RULE_interfaceBodyDeclaration = 27
    RULE_interfaceMemberDeclaration = 28
    RULE_constDeclaration = 29
    RULE_constantDeclarator = 30
    RULE_interfaceMethodDeclaration = 31
    RULE_interfaceMethodModifier = 32
    RULE_genericInterfaceMethodDeclaration = 33
    RULE_variableDeclarators = 34
    RULE_variableDeclarator = 35
    RULE_variableDeclaratorId = 36
    RULE_variableInitializer = 37
    RULE_arrayInitializer = 38
    RULE_classOrInterfaceType = 39
    RULE_typeArgument = 40
    RULE_qualifiedNameList = 41
    RULE_formalParameters = 42
    RULE_formalParameterList = 43
    RULE_formalParameter = 44
    RULE_lastFormalParameter = 45
    RULE_qualifiedName = 46
    RULE_literal = 47
    RULE_integerLiteral = 48
    RULE_floatLiteral = 49
    RULE_altAnnotationQualifiedName = 50
    RULE_annotation = 51
    RULE_elementValuePairs = 52
    RULE_elementValuePair = 53
    RULE_elementValue = 54
    RULE_elementValueArrayInitializer = 55
    RULE_annotationTypeDeclaration = 56
    RULE_annotationTypeBody = 57
    RULE_annotationTypeElementDeclaration = 58
    RULE_annotationTypeElementRest = 59
    RULE_annotationMethodOrConstantRest = 60
    RULE_annotationMethodRest = 61
    RULE_annotationConstantRest = 62
    RULE_defaultValue = 63
    RULE_block = 64
    RULE_blockStatement = 65
    RULE_localVariableDeclaration = 66
    RULE_localTypeDeclaration = 67
    RULE_statement = 68
    RULE_catchClause = 69
    RULE_catchType = 70
    RULE_finallyBlock = 71
    RULE_resourceSpecification = 72
    RULE_resources = 73
    RULE_resource = 74
    RULE_switchBlockStatementGroup = 75
    RULE_switchLabel = 76
    RULE_forControl = 77
    RULE_forInit = 78
    RULE_enhancedForControl = 79
    RULE_parExpression = 80
    RULE_expressionList = 81
    RULE_methodCall = 82
    RULE_expression = 83
    RULE_lambdaExpression = 84
    RULE_lambdaParameters = 85
    RULE_lambdaBody = 86
    RULE_primary = 87
    RULE_classType = 88
    RULE_creator = 89
    RULE_createdName = 90
    RULE_innerCreator = 91
    RULE_arrayCreatorRest = 92
    RULE_classCreatorRest = 93
    RULE_explicitGenericInvocation = 94
    RULE_typeArgumentsOrDiamond = 95
    RULE_nonWildcardTypeArgumentsOrDiamond = 96
    RULE_nonWildcardTypeArguments = 97
    RULE_typeList = 98
    RULE_typeType = 99
    RULE_primitiveType = 100
    RULE_typeArguments = 101
    RULE_superSuffix = 102
    RULE_explicitGenericInvocationSuffix = 103
    RULE_arguments = 104

    ruleNames = [
        "compilationUnit",
        "packageDeclaration",
        "importDeclaration",
        "typeDeclaration",
        "modifier",
        "classOrInterfaceModifier",
        "variableModifier",
        "classDeclaration",
        "typeParameters",
        "typeParameter",
        "typeBound",
        "enumDeclaration",
        "enumConstants",
        "enumConstant",
        "enumBodyDeclarations",
        "interfaceDeclaration",
        "classBody",
        "interfaceBody",
        "classBodyDeclaration",
        "memberDeclaration",
        "methodDeclaration",
        "methodBody",
        "typeTypeOrVoid",
        "genericMethodDeclaration",
        "genericConstructorDeclaration",
        "constructorDeclaration",
        "fieldDeclaration",
        "interfaceBodyDeclaration",
        "interfaceMemberDeclaration",
        "constDeclaration",
        "constantDeclarator",
        "interfaceMethodDeclaration",
        "interfaceMethodModifier",
        "genericInterfaceMethodDeclaration",
        "variableDeclarators",
        "variableDeclarator",
        "variableDeclaratorId",
        "variableInitializer",
        "arrayInitializer",
        "classOrInterfaceType",
        "typeArgument",
        "qualifiedNameList",
        "formalParameters",
        "formalParameterList",
        "formalParameter",
        "lastFormalParameter",
        "qualifiedName",
        "literal",
        "integerLiteral",
        "floatLiteral",
        "altAnnotationQualifiedName",
        "annotation",
        "elementValuePairs",
        "elementValuePair",
        "elementValue",
        "elementValueArrayInitializer",
        "annotationTypeDeclaration",
        "annotationTypeBody",
        "annotationTypeElementDeclaration",
        "annotationTypeElementRest",
        "annotationMethodOrConstantRest",
        "annotationMethodRest",
        "annotationConstantRest",
        "defaultValue",
        "block",
        "blockStatement",
        "localVariableDeclaration",
        "localTypeDeclaration",
        "statement",
        "catchClause",
        "catchType",
        "finallyBlock",
        "resourceSpecification",
        "resources",
        "resource",
        "switchBlockStatementGroup",
        "switchLabel",
        "forControl",
        "forInit",
        "enhancedForControl",
        "parExpression",
        "expressionList",
        "methodCall",
        "expression",
        "lambdaExpression",
        "lambdaParameters",
        "lambdaBody",
        "primary",
        "classType",
        "creator",
        "createdName",
        "innerCreator",
        "arrayCreatorRest",
        "classCreatorRest",
        "explicitGenericInvocation",
        "typeArgumentsOrDiamond",
        "nonWildcardTypeArgumentsOrDiamond",
        "nonWildcardTypeArguments",
        "typeList",
        "typeType",
        "primitiveType",
        "typeArguments",
        "superSuffix",
        "explicitGenericInvocationSuffix",
        "arguments",
    ]

    EOF = Token.EOF
    ABSTRACT = 1
    ASSERT = 2
    BOOLEAN = 3
    BREAK = 4
    BYTE = 5
    CASE = 6
    CATCH = 7
    CHAR = 8
    CLASS = 9
    CONST = 10
    CONTINUE = 11
    DEFAULT = 12
    DO = 13
    DOUBLE = 14
    ELSE = 15
    ENUM = 16
    EXTENDS = 17
    FINAL = 18
    FINALLY = 19
    FLOAT = 20
    FOR = 21
    IF = 22
    GOTO = 23
    IMPLEMENTS = 24
    IMPORT = 25
    INSTANCEOF = 26
    INT = 27
    INTERFACE = 28
    LONG = 29
    NATIVE = 30
    NEW = 31
    PACKAGE = 32
    PRIVATE = 33
    PROTECTED = 34
    PUBLIC = 35
    RETURN = 36
    SHORT = 37
    STATIC = 38
    STRICTFP = 39
    SUPER = 40
    SWITCH = 41
    SYNCHRONIZED = 42
    THIS = 43
    THROW = 44
    THROWS = 45
    TRANSIENT = 46
    TRY = 47
    VOID = 48
    VOLATILE = 49
    WHILE = 50
    DECIMAL_LITERAL = 51
    HEX_LITERAL = 52
    OCT_LITERAL = 53
    BINARY_LITERAL = 54
    FLOAT_LITERAL = 55
    HEX_FLOAT_LITERAL = 56
    BOOL_LITERAL = 57
    CHAR_LITERAL = 58
    STRING_LITERAL = 59
    NULL_LITERAL = 60
    LPAREN = 61
    RPAREN = 62
    LBRACE = 63
    RBRACE = 64
    LBRACK = 65
    RBRACK = 66
    SEMI = 67
    COMMA = 68
    DOT = 69
    ASSIGN = 70
    GT = 71
    LT = 72
    BANG = 73
    TILDE = 74
    QUESTION = 75
    COLON = 76
    EQUAL = 77
    LE = 78
    GE = 79
    NOTEQUAL = 80
    AND = 81
    OR = 82
    INC = 83
    DEC = 84
    ADD = 85
    SUB = 86
    MUL = 87
    DIV = 88
    BITAND = 89
    BITOR = 90
    CARET = 91
    MOD = 92
    ADD_ASSIGN = 93
    SUB_ASSIGN = 94
    MUL_ASSIGN = 95
    DIV_ASSIGN = 96
    AND_ASSIGN = 97
    OR_ASSIGN = 98
    XOR_ASSIGN = 99
    MOD_ASSIGN = 100
    LSHIFT_ASSIGN = 101
    RSHIFT_ASSIGN = 102
    URSHIFT_ASSIGN = 103
    ARROW = 104
    COLONCOLON = 105
    AT = 106
    ELLIPSIS = 107
    WS = 108
    COMMENT = 109
    LINE_COMMENT = 110
    JAVADOC_COMMENT = 111
    IDENTIFIER = 112

    def __init__(self, input: TokenStream, output: TextIO = sys.stdout):
        super().__init__(input, output)
        self.checkVersion("4.7.2")
        self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
        self._predicates = None

    class CompilationUnitContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def EOF(self):
            return self.getToken(JavaParser.EOF, 0)

        def packageDeclaration(self):
            return self.getTypedRuleContext(JavaParser.PackageDeclarationContext, 0)

        def importDeclaration(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.ImportDeclarationContext)
            else:
                return self.getTypedRuleContext(JavaParser.ImportDeclarationContext, i)

        def typeDeclaration(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.TypeDeclarationContext)
            else:
                return self.getTypedRuleContext(JavaParser.TypeDeclarationContext, i)

        def getRuleIndex(self):
            return JavaParser.RULE_compilationUnit

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCompilationUnit"):
                listener.enterCompilationUnit(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCompilationUnit"):
                listener.exitCompilationUnit(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitCompilationUnit"):
                return visitor.visitCompilationUnit(self)
            else:
                return visitor.visitChildren(self)

    def compilationUnit(self):

        localctx = JavaParser.CompilationUnitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_compilationUnit)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 211
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 0, self._ctx)
            if la_ == 1:
                self.state = 210
                self.packageDeclaration()

            self.state = 216
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == JavaParser.IMPORT:
                self.state = 213
                self.importDeclaration()
                self.state = 218
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 222
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (
                ((_la) & ~0x3F) == 0
                and (
                    (1 << _la)
                    & (
                        (1 << JavaParser.ABSTRACT)
                        | (1 << JavaParser.CLASS)
                        | (1 << JavaParser.ENUM)
                        | (1 << JavaParser.FINAL)
                        | (1 << JavaParser.INTERFACE)
                        | (1 << JavaParser.PRIVATE)
                        | (1 << JavaParser.PROTECTED)
                        | (1 << JavaParser.PUBLIC)
                        | (1 << JavaParser.STATIC)
                        | (1 << JavaParser.STRICTFP)
                    )
                )
                != 0
            ) or (
                (((_la - 67)) & ~0x3F) == 0
                and (
                    (1 << (_la - 67))
                    & (
                        (1 << (JavaParser.SEMI - 67))
                        | (1 << (JavaParser.AT - 67))
                        | (1 << (JavaParser.IDENTIFIER - 67))
                    )
                )
                != 0
            ):
                self.state = 219
                self.typeDeclaration()
                self.state = 224
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 225
            self.match(JavaParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class PackageDeclarationContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def PACKAGE(self):
            return self.getToken(JavaParser.PACKAGE, 0)

        def qualifiedName(self):
            return self.getTypedRuleContext(JavaParser.QualifiedNameContext, 0)

        def SEMI(self):
            return self.getToken(JavaParser.SEMI, 0)

        def annotation(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.AnnotationContext)
            else:
                return self.getTypedRuleContext(JavaParser.AnnotationContext, i)

        def getRuleIndex(self):
            return JavaParser.RULE_packageDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterPackageDeclaration"):
                listener.enterPackageDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitPackageDeclaration"):
                listener.exitPackageDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitPackageDeclaration"):
                return visitor.visitPackageDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def packageDeclaration(self):

        localctx = JavaParser.PackageDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_packageDeclaration)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 230
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == JavaParser.AT or _la == JavaParser.IDENTIFIER:
                self.state = 227
                self.annotation()
                self.state = 232
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 233
            self.match(JavaParser.PACKAGE)
            self.state = 234
            self.qualifiedName()
            self.state = 235
            self.match(JavaParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ImportDeclarationContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def IMPORT(self):
            return self.getToken(JavaParser.IMPORT, 0)

        def qualifiedName(self):
            return self.getTypedRuleContext(JavaParser.QualifiedNameContext, 0)

        def SEMI(self):
            return self.getToken(JavaParser.SEMI, 0)

        def STATIC(self):
            return self.getToken(JavaParser.STATIC, 0)

        def DOT(self):
            return self.getToken(JavaParser.DOT, 0)

        def MUL(self):
            return self.getToken(JavaParser.MUL, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_importDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterImportDeclaration"):
                listener.enterImportDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitImportDeclaration"):
                listener.exitImportDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitImportDeclaration"):
                return visitor.visitImportDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def importDeclaration(self):

        localctx = JavaParser.ImportDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_importDeclaration)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 237
            self.match(JavaParser.IMPORT)
            self.state = 239
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == JavaParser.STATIC:
                self.state = 238
                self.match(JavaParser.STATIC)

            self.state = 241
            self.qualifiedName()
            self.state = 244
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == JavaParser.DOT:
                self.state = 242
                self.match(JavaParser.DOT)
                self.state = 243
                self.match(JavaParser.MUL)

            self.state = 246
            self.match(JavaParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class TypeDeclarationContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def classDeclaration(self):
            return self.getTypedRuleContext(JavaParser.ClassDeclarationContext, 0)

        def enumDeclaration(self):
            return self.getTypedRuleContext(JavaParser.EnumDeclarationContext, 0)

        def interfaceDeclaration(self):
            return self.getTypedRuleContext(JavaParser.InterfaceDeclarationContext, 0)

        def annotationTypeDeclaration(self):
            return self.getTypedRuleContext(JavaParser.AnnotationTypeDeclarationContext, 0)

        def classOrInterfaceModifier(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.ClassOrInterfaceModifierContext)
            else:
                return self.getTypedRuleContext(JavaParser.ClassOrInterfaceModifierContext, i)

        def SEMI(self):
            return self.getToken(JavaParser.SEMI, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_typeDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterTypeDeclaration"):
                listener.enterTypeDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitTypeDeclaration"):
                listener.exitTypeDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitTypeDeclaration"):
                return visitor.visitTypeDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def typeDeclaration(self):

        localctx = JavaParser.TypeDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_typeDeclaration)
        try:
            self.state = 261
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [
                JavaParser.ABSTRACT,
                JavaParser.CLASS,
                JavaParser.ENUM,
                JavaParser.FINAL,
                JavaParser.INTERFACE,
                JavaParser.PRIVATE,
                JavaParser.PROTECTED,
                JavaParser.PUBLIC,
                JavaParser.STATIC,
                JavaParser.STRICTFP,
                JavaParser.AT,
                JavaParser.IDENTIFIER,
            ]:
                self.enterOuterAlt(localctx, 1)
                self.state = 251
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 6, self._ctx)
                while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 248
                        self.classOrInterfaceModifier()
                    self.state = 253
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input, 6, self._ctx)

                self.state = 258
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [JavaParser.CLASS]:
                    self.state = 254
                    self.classDeclaration()
                    pass
                elif token in [JavaParser.ENUM]:
                    self.state = 255
                    self.enumDeclaration()
                    pass
                elif token in [JavaParser.INTERFACE]:
                    self.state = 256
                    self.interfaceDeclaration()
                    pass
                elif token in [JavaParser.AT]:
                    self.state = 257
                    self.annotationTypeDeclaration()
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [JavaParser.SEMI]:
                self.enterOuterAlt(localctx, 2)
                self.state = 260
                self.match(JavaParser.SEMI)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ModifierContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def classOrInterfaceModifier(self):
            return self.getTypedRuleContext(JavaParser.ClassOrInterfaceModifierContext, 0)

        def NATIVE(self):
            return self.getToken(JavaParser.NATIVE, 0)

        def SYNCHRONIZED(self):
            return self.getToken(JavaParser.SYNCHRONIZED, 0)

        def TRANSIENT(self):
            return self.getToken(JavaParser.TRANSIENT, 0)

        def VOLATILE(self):
            return self.getToken(JavaParser.VOLATILE, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_modifier

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterModifier"):
                listener.enterModifier(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitModifier"):
                listener.exitModifier(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitModifier"):
                return visitor.visitModifier(self)
            else:
                return visitor.visitChildren(self)

    def modifier(self):

        localctx = JavaParser.ModifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_modifier)
        try:
            self.state = 268
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [
                JavaParser.ABSTRACT,
                JavaParser.FINAL,
                JavaParser.PRIVATE,
                JavaParser.PROTECTED,
                JavaParser.PUBLIC,
                JavaParser.STATIC,
                JavaParser.STRICTFP,
                JavaParser.AT,
                JavaParser.IDENTIFIER,
            ]:
                self.enterOuterAlt(localctx, 1)
                self.state = 263
                self.classOrInterfaceModifier()
                pass
            elif token in [JavaParser.NATIVE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 264
                self.match(JavaParser.NATIVE)
                pass
            elif token in [JavaParser.SYNCHRONIZED]:
                self.enterOuterAlt(localctx, 3)
                self.state = 265
                self.match(JavaParser.SYNCHRONIZED)
                pass
            elif token in [JavaParser.TRANSIENT]:
                self.enterOuterAlt(localctx, 4)
                self.state = 266
                self.match(JavaParser.TRANSIENT)
                pass
            elif token in [JavaParser.VOLATILE]:
                self.enterOuterAlt(localctx, 5)
                self.state = 267
                self.match(JavaParser.VOLATILE)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ClassOrInterfaceModifierContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def annotation(self):
            return self.getTypedRuleContext(JavaParser.AnnotationContext, 0)

        def PUBLIC(self):
            return self.getToken(JavaParser.PUBLIC, 0)

        def PROTECTED(self):
            return self.getToken(JavaParser.PROTECTED, 0)

        def PRIVATE(self):
            return self.getToken(JavaParser.PRIVATE, 0)

        def STATIC(self):
            return self.getToken(JavaParser.STATIC, 0)

        def ABSTRACT(self):
            return self.getToken(JavaParser.ABSTRACT, 0)

        def FINAL(self):
            return self.getToken(JavaParser.FINAL, 0)

        def STRICTFP(self):
            return self.getToken(JavaParser.STRICTFP, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_classOrInterfaceModifier

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterClassOrInterfaceModifier"):
                listener.enterClassOrInterfaceModifier(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitClassOrInterfaceModifier"):
                listener.exitClassOrInterfaceModifier(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitClassOrInterfaceModifier"):
                return visitor.visitClassOrInterfaceModifier(self)
            else:
                return visitor.visitChildren(self)

    def classOrInterfaceModifier(self):

        localctx = JavaParser.ClassOrInterfaceModifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_classOrInterfaceModifier)
        try:
            self.state = 278
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [JavaParser.AT, JavaParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 270
                self.annotation()
                pass
            elif token in [JavaParser.PUBLIC]:
                self.enterOuterAlt(localctx, 2)
                self.state = 271
                self.match(JavaParser.PUBLIC)
                pass
            elif token in [JavaParser.PROTECTED]:
                self.enterOuterAlt(localctx, 3)
                self.state = 272
                self.match(JavaParser.PROTECTED)
                pass
            elif token in [JavaParser.PRIVATE]:
                self.enterOuterAlt(localctx, 4)
                self.state = 273
                self.match(JavaParser.PRIVATE)
                pass
            elif token in [JavaParser.STATIC]:
                self.enterOuterAlt(localctx, 5)
                self.state = 274
                self.match(JavaParser.STATIC)
                pass
            elif token in [JavaParser.ABSTRACT]:
                self.enterOuterAlt(localctx, 6)
                self.state = 275
                self.match(JavaParser.ABSTRACT)
                pass
            elif token in [JavaParser.FINAL]:
                self.enterOuterAlt(localctx, 7)
                self.state = 276
                self.match(JavaParser.FINAL)
                pass
            elif token in [JavaParser.STRICTFP]:
                self.enterOuterAlt(localctx, 8)
                self.state = 277
                self.match(JavaParser.STRICTFP)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class VariableModifierContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def FINAL(self):
            return self.getToken(JavaParser.FINAL, 0)

        def annotation(self):
            return self.getTypedRuleContext(JavaParser.AnnotationContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_variableModifier

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterVariableModifier"):
                listener.enterVariableModifier(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitVariableModifier"):
                listener.exitVariableModifier(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitVariableModifier"):
                return visitor.visitVariableModifier(self)
            else:
                return visitor.visitChildren(self)

    def variableModifier(self):

        localctx = JavaParser.VariableModifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_variableModifier)
        try:
            self.state = 282
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [JavaParser.FINAL]:
                self.enterOuterAlt(localctx, 1)
                self.state = 280
                self.match(JavaParser.FINAL)
                pass
            elif token in [JavaParser.AT, JavaParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 281
                self.annotation()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ClassDeclarationContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CLASS(self):
            return self.getToken(JavaParser.CLASS, 0)

        def IDENTIFIER(self):
            return self.getToken(JavaParser.IDENTIFIER, 0)

        def classBody(self):
            return self.getTypedRuleContext(JavaParser.ClassBodyContext, 0)

        def typeParameters(self):
            return self.getTypedRuleContext(JavaParser.TypeParametersContext, 0)

        def EXTENDS(self):
            return self.getToken(JavaParser.EXTENDS, 0)

        def typeType(self):
            return self.getTypedRuleContext(JavaParser.TypeTypeContext, 0)

        def IMPLEMENTS(self):
            return self.getToken(JavaParser.IMPLEMENTS, 0)

        def typeList(self):
            return self.getTypedRuleContext(JavaParser.TypeListContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_classDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterClassDeclaration"):
                listener.enterClassDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitClassDeclaration"):
                listener.exitClassDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitClassDeclaration"):
                return visitor.visitClassDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def classDeclaration(self):

        localctx = JavaParser.ClassDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_classDeclaration)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 284
            self.match(JavaParser.CLASS)
            self.state = 285
            self.match(JavaParser.IDENTIFIER)
            self.state = 287
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == JavaParser.LT:
                self.state = 286
                self.typeParameters()

            self.state = 291
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == JavaParser.EXTENDS:
                self.state = 289
                self.match(JavaParser.EXTENDS)
                self.state = 290
                self.typeType()

            self.state = 295
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == JavaParser.IMPLEMENTS:
                self.state = 293
                self.match(JavaParser.IMPLEMENTS)
                self.state = 294
                self.typeList()

            self.state = 297
            self.classBody()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class TypeParametersContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LT(self):
            return self.getToken(JavaParser.LT, 0)

        def typeParameter(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.TypeParameterContext)
            else:
                return self.getTypedRuleContext(JavaParser.TypeParameterContext, i)

        def GT(self):
            return self.getToken(JavaParser.GT, 0)

        def COMMA(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.COMMA)
            else:
                return self.getToken(JavaParser.COMMA, i)

        def getRuleIndex(self):
            return JavaParser.RULE_typeParameters

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterTypeParameters"):
                listener.enterTypeParameters(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitTypeParameters"):
                listener.exitTypeParameters(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitTypeParameters"):
                return visitor.visitTypeParameters(self)
            else:
                return visitor.visitChildren(self)

    def typeParameters(self):

        localctx = JavaParser.TypeParametersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_typeParameters)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 299
            self.match(JavaParser.LT)
            self.state = 300
            self.typeParameter()
            self.state = 305
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == JavaParser.COMMA:
                self.state = 301
                self.match(JavaParser.COMMA)
                self.state = 302
                self.typeParameter()
                self.state = 307
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 308
            self.match(JavaParser.GT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class TypeParameterContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def IDENTIFIER(self):
            return self.getToken(JavaParser.IDENTIFIER, 0)

        def annotation(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.AnnotationContext)
            else:
                return self.getTypedRuleContext(JavaParser.AnnotationContext, i)

        def EXTENDS(self):
            return self.getToken(JavaParser.EXTENDS, 0)

        def typeBound(self):
            return self.getTypedRuleContext(JavaParser.TypeBoundContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_typeParameter

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterTypeParameter"):
                listener.enterTypeParameter(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitTypeParameter"):
                listener.exitTypeParameter(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitTypeParameter"):
                return visitor.visitTypeParameter(self)
            else:
                return visitor.visitChildren(self)

    def typeParameter(self):

        localctx = JavaParser.TypeParameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_typeParameter)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 313
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input, 16, self._ctx)
            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 310
                    self.annotation()
                self.state = 315
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 16, self._ctx)

            self.state = 316
            self.match(JavaParser.IDENTIFIER)
            self.state = 325
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == JavaParser.EXTENDS:
                self.state = 317
                self.match(JavaParser.EXTENDS)
                self.state = 321
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 17, self._ctx)
                while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 318
                        self.annotation()
                    self.state = 323
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input, 17, self._ctx)

                self.state = 324
                self.typeBound()

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class TypeBoundContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeType(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.TypeTypeContext)
            else:
                return self.getTypedRuleContext(JavaParser.TypeTypeContext, i)

        def BITAND(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.BITAND)
            else:
                return self.getToken(JavaParser.BITAND, i)

        def getRuleIndex(self):
            return JavaParser.RULE_typeBound

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterTypeBound"):
                listener.enterTypeBound(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitTypeBound"):
                listener.exitTypeBound(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitTypeBound"):
                return visitor.visitTypeBound(self)
            else:
                return visitor.visitChildren(self)

    def typeBound(self):

        localctx = JavaParser.TypeBoundContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_typeBound)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 327
            self.typeType()
            self.state = 332
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == JavaParser.BITAND:
                self.state = 328
                self.match(JavaParser.BITAND)
                self.state = 329
                self.typeType()
                self.state = 334
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class EnumDeclarationContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ENUM(self):
            return self.getToken(JavaParser.ENUM, 0)

        def IDENTIFIER(self):
            return self.getToken(JavaParser.IDENTIFIER, 0)

        def LBRACE(self):
            return self.getToken(JavaParser.LBRACE, 0)

        def RBRACE(self):
            return self.getToken(JavaParser.RBRACE, 0)

        def IMPLEMENTS(self):
            return self.getToken(JavaParser.IMPLEMENTS, 0)

        def typeList(self):
            return self.getTypedRuleContext(JavaParser.TypeListContext, 0)

        def enumConstants(self):
            return self.getTypedRuleContext(JavaParser.EnumConstantsContext, 0)

        def COMMA(self):
            return self.getToken(JavaParser.COMMA, 0)

        def enumBodyDeclarations(self):
            return self.getTypedRuleContext(JavaParser.EnumBodyDeclarationsContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_enumDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterEnumDeclaration"):
                listener.enterEnumDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitEnumDeclaration"):
                listener.exitEnumDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitEnumDeclaration"):
                return visitor.visitEnumDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def enumDeclaration(self):

        localctx = JavaParser.EnumDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_enumDeclaration)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 335
            self.match(JavaParser.ENUM)
            self.state = 336
            self.match(JavaParser.IDENTIFIER)
            self.state = 339
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == JavaParser.IMPLEMENTS:
                self.state = 337
                self.match(JavaParser.IMPLEMENTS)
                self.state = 338
                self.typeList()

            self.state = 341
            self.match(JavaParser.LBRACE)
            self.state = 343
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == JavaParser.AT or _la == JavaParser.IDENTIFIER:
                self.state = 342
                self.enumConstants()

            self.state = 346
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == JavaParser.COMMA:
                self.state = 345
                self.match(JavaParser.COMMA)

            self.state = 349
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == JavaParser.SEMI:
                self.state = 348
                self.enumBodyDeclarations()

            self.state = 351
            self.match(JavaParser.RBRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class EnumConstantsContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def enumConstant(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.EnumConstantContext)
            else:
                return self.getTypedRuleContext(JavaParser.EnumConstantContext, i)

        def COMMA(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.COMMA)
            else:
                return self.getToken(JavaParser.COMMA, i)

        def getRuleIndex(self):
            return JavaParser.RULE_enumConstants

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterEnumConstants"):
                listener.enterEnumConstants(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitEnumConstants"):
                listener.exitEnumConstants(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitEnumConstants"):
                return visitor.visitEnumConstants(self)
            else:
                return visitor.visitChildren(self)

    def enumConstants(self):

        localctx = JavaParser.EnumConstantsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_enumConstants)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 353
            self.enumConstant()
            self.state = 358
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input, 24, self._ctx)
            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 354
                    self.match(JavaParser.COMMA)
                    self.state = 355
                    self.enumConstant()
                self.state = 360
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 24, self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class EnumConstantContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def IDENTIFIER(self):
            return self.getToken(JavaParser.IDENTIFIER, 0)

        def annotation(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.AnnotationContext)
            else:
                return self.getTypedRuleContext(JavaParser.AnnotationContext, i)

        def arguments(self):
            return self.getTypedRuleContext(JavaParser.ArgumentsContext, 0)

        def classBody(self):
            return self.getTypedRuleContext(JavaParser.ClassBodyContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_enumConstant

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterEnumConstant"):
                listener.enterEnumConstant(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitEnumConstant"):
                listener.exitEnumConstant(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitEnumConstant"):
                return visitor.visitEnumConstant(self)
            else:
                return visitor.visitChildren(self)

    def enumConstant(self):

        localctx = JavaParser.EnumConstantContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_enumConstant)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 364
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input, 25, self._ctx)
            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 361
                    self.annotation()
                self.state = 366
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 25, self._ctx)

            self.state = 367
            self.match(JavaParser.IDENTIFIER)
            self.state = 369
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == JavaParser.LPAREN:
                self.state = 368
                self.arguments()

            self.state = 372
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == JavaParser.LBRACE:
                self.state = 371
                self.classBody()

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class EnumBodyDeclarationsContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def SEMI(self):
            return self.getToken(JavaParser.SEMI, 0)

        def classBodyDeclaration(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.ClassBodyDeclarationContext)
            else:
                return self.getTypedRuleContext(JavaParser.ClassBodyDeclarationContext, i)

        def getRuleIndex(self):
            return JavaParser.RULE_enumBodyDeclarations

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterEnumBodyDeclarations"):
                listener.enterEnumBodyDeclarations(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitEnumBodyDeclarations"):
                listener.exitEnumBodyDeclarations(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitEnumBodyDeclarations"):
                return visitor.visitEnumBodyDeclarations(self)
            else:
                return visitor.visitChildren(self)

    def enumBodyDeclarations(self):

        localctx = JavaParser.EnumBodyDeclarationsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_enumBodyDeclarations)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 374
            self.match(JavaParser.SEMI)
            self.state = 378
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (
                ((_la) & ~0x3F) == 0
                and (
                    (1 << _la)
                    & (
                        (1 << JavaParser.ABSTRACT)
                        | (1 << JavaParser.BOOLEAN)
                        | (1 << JavaParser.BYTE)
                        | (1 << JavaParser.CHAR)
                        | (1 << JavaParser.CLASS)
                        | (1 << JavaParser.DOUBLE)
                        | (1 << JavaParser.ENUM)
                        | (1 << JavaParser.FINAL)
                        | (1 << JavaParser.FLOAT)
                        | (1 << JavaParser.INT)
                        | (1 << JavaParser.INTERFACE)
                        | (1 << JavaParser.LONG)
                        | (1 << JavaParser.NATIVE)
                        | (1 << JavaParser.PRIVATE)
                        | (1 << JavaParser.PROTECTED)
                        | (1 << JavaParser.PUBLIC)
                        | (1 << JavaParser.SHORT)
                        | (1 << JavaParser.STATIC)
                        | (1 << JavaParser.STRICTFP)
                        | (1 << JavaParser.SYNCHRONIZED)
                        | (1 << JavaParser.TRANSIENT)
                        | (1 << JavaParser.VOID)
                        | (1 << JavaParser.VOLATILE)
                        | (1 << JavaParser.LBRACE)
                    )
                )
                != 0
            ) or (
                (((_la - 67)) & ~0x3F) == 0
                and (
                    (1 << (_la - 67))
                    & (
                        (1 << (JavaParser.SEMI - 67))
                        | (1 << (JavaParser.LT - 67))
                        | (1 << (JavaParser.AT - 67))
                        | (1 << (JavaParser.IDENTIFIER - 67))
                    )
                )
                != 0
            ):
                self.state = 375
                self.classBodyDeclaration()
                self.state = 380
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class InterfaceDeclarationContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def INTERFACE(self):
            return self.getToken(JavaParser.INTERFACE, 0)

        def IDENTIFIER(self):
            return self.getToken(JavaParser.IDENTIFIER, 0)

        def interfaceBody(self):
            return self.getTypedRuleContext(JavaParser.InterfaceBodyContext, 0)

        def typeParameters(self):
            return self.getTypedRuleContext(JavaParser.TypeParametersContext, 0)

        def EXTENDS(self):
            return self.getToken(JavaParser.EXTENDS, 0)

        def typeList(self):
            return self.getTypedRuleContext(JavaParser.TypeListContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_interfaceDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterInterfaceDeclaration"):
                listener.enterInterfaceDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitInterfaceDeclaration"):
                listener.exitInterfaceDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitInterfaceDeclaration"):
                return visitor.visitInterfaceDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def interfaceDeclaration(self):

        localctx = JavaParser.InterfaceDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_interfaceDeclaration)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 381
            self.match(JavaParser.INTERFACE)
            self.state = 382
            self.match(JavaParser.IDENTIFIER)
            self.state = 384
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == JavaParser.LT:
                self.state = 383
                self.typeParameters()

            self.state = 388
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == JavaParser.EXTENDS:
                self.state = 386
                self.match(JavaParser.EXTENDS)
                self.state = 387
                self.typeList()

            self.state = 390
            self.interfaceBody()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ClassBodyContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LBRACE(self):
            return self.getToken(JavaParser.LBRACE, 0)

        def RBRACE(self):
            return self.getToken(JavaParser.RBRACE, 0)

        def classBodyDeclaration(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.ClassBodyDeclarationContext)
            else:
                return self.getTypedRuleContext(JavaParser.ClassBodyDeclarationContext, i)

        def getRuleIndex(self):
            return JavaParser.RULE_classBody

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterClassBody"):
                listener.enterClassBody(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitClassBody"):
                listener.exitClassBody(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitClassBody"):
                return visitor.visitClassBody(self)
            else:
                return visitor.visitChildren(self)

    def classBody(self):

        localctx = JavaParser.ClassBodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_classBody)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 392
            self.match(JavaParser.LBRACE)
            self.state = 396
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (
                ((_la) & ~0x3F) == 0
                and (
                    (1 << _la)
                    & (
                        (1 << JavaParser.ABSTRACT)
                        | (1 << JavaParser.BOOLEAN)
                        | (1 << JavaParser.BYTE)
                        | (1 << JavaParser.CHAR)
                        | (1 << JavaParser.CLASS)
                        | (1 << JavaParser.DOUBLE)
                        | (1 << JavaParser.ENUM)
                        | (1 << JavaParser.FINAL)
                        | (1 << JavaParser.FLOAT)
                        | (1 << JavaParser.INT)
                        | (1 << JavaParser.INTERFACE)
                        | (1 << JavaParser.LONG)
                        | (1 << JavaParser.NATIVE)
                        | (1 << JavaParser.PRIVATE)
                        | (1 << JavaParser.PROTECTED)
                        | (1 << JavaParser.PUBLIC)
                        | (1 << JavaParser.SHORT)
                        | (1 << JavaParser.STATIC)
                        | (1 << JavaParser.STRICTFP)
                        | (1 << JavaParser.SYNCHRONIZED)
                        | (1 << JavaParser.TRANSIENT)
                        | (1 << JavaParser.VOID)
                        | (1 << JavaParser.VOLATILE)
                        | (1 << JavaParser.LBRACE)
                    )
                )
                != 0
            ) or (
                (((_la - 67)) & ~0x3F) == 0
                and (
                    (1 << (_la - 67))
                    & (
                        (1 << (JavaParser.SEMI - 67))
                        | (1 << (JavaParser.LT - 67))
                        | (1 << (JavaParser.AT - 67))
                        | (1 << (JavaParser.IDENTIFIER - 67))
                    )
                )
                != 0
            ):
                self.state = 393
                self.classBodyDeclaration()
                self.state = 398
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 399
            self.match(JavaParser.RBRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class InterfaceBodyContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LBRACE(self):
            return self.getToken(JavaParser.LBRACE, 0)

        def RBRACE(self):
            return self.getToken(JavaParser.RBRACE, 0)

        def interfaceBodyDeclaration(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.InterfaceBodyDeclarationContext)
            else:
                return self.getTypedRuleContext(JavaParser.InterfaceBodyDeclarationContext, i)

        def getRuleIndex(self):
            return JavaParser.RULE_interfaceBody

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterInterfaceBody"):
                listener.enterInterfaceBody(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitInterfaceBody"):
                listener.exitInterfaceBody(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitInterfaceBody"):
                return visitor.visitInterfaceBody(self)
            else:
                return visitor.visitChildren(self)

    def interfaceBody(self):

        localctx = JavaParser.InterfaceBodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_interfaceBody)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 401
            self.match(JavaParser.LBRACE)
            self.state = 405
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (
                ((_la) & ~0x3F) == 0
                and (
                    (1 << _la)
                    & (
                        (1 << JavaParser.ABSTRACT)
                        | (1 << JavaParser.BOOLEAN)
                        | (1 << JavaParser.BYTE)
                        | (1 << JavaParser.CHAR)
                        | (1 << JavaParser.CLASS)
                        | (1 << JavaParser.DEFAULT)
                        | (1 << JavaParser.DOUBLE)
                        | (1 << JavaParser.ENUM)
                        | (1 << JavaParser.FINAL)
                        | (1 << JavaParser.FLOAT)
                        | (1 << JavaParser.INT)
                        | (1 << JavaParser.INTERFACE)
                        | (1 << JavaParser.LONG)
                        | (1 << JavaParser.NATIVE)
                        | (1 << JavaParser.PRIVATE)
                        | (1 << JavaParser.PROTECTED)
                        | (1 << JavaParser.PUBLIC)
                        | (1 << JavaParser.SHORT)
                        | (1 << JavaParser.STATIC)
                        | (1 << JavaParser.STRICTFP)
                        | (1 << JavaParser.SYNCHRONIZED)
                        | (1 << JavaParser.TRANSIENT)
                        | (1 << JavaParser.VOID)
                        | (1 << JavaParser.VOLATILE)
                    )
                )
                != 0
            ) or (
                (((_la - 67)) & ~0x3F) == 0
                and (
                    (1 << (_la - 67))
                    & (
                        (1 << (JavaParser.SEMI - 67))
                        | (1 << (JavaParser.LT - 67))
                        | (1 << (JavaParser.AT - 67))
                        | (1 << (JavaParser.IDENTIFIER - 67))
                    )
                )
                != 0
            ):
                self.state = 402
                self.interfaceBodyDeclaration()
                self.state = 407
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 408
            self.match(JavaParser.RBRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ClassBodyDeclarationContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def SEMI(self):
            return self.getToken(JavaParser.SEMI, 0)

        def block(self):
            return self.getTypedRuleContext(JavaParser.BlockContext, 0)

        def STATIC(self):
            return self.getToken(JavaParser.STATIC, 0)

        def memberDeclaration(self):
            return self.getTypedRuleContext(JavaParser.MemberDeclarationContext, 0)

        def modifier(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.ModifierContext)
            else:
                return self.getTypedRuleContext(JavaParser.ModifierContext, i)

        def getRuleIndex(self):
            return JavaParser.RULE_classBodyDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterClassBodyDeclaration"):
                listener.enterClassBodyDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitClassBodyDeclaration"):
                listener.exitClassBodyDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitClassBodyDeclaration"):
                return visitor.visitClassBodyDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def classBodyDeclaration(self):

        localctx = JavaParser.ClassBodyDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_classBodyDeclaration)
        self._la = 0  # Token type
        try:
            self.state = 422
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 35, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 410
                self.match(JavaParser.SEMI)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 412
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la == JavaParser.STATIC:
                    self.state = 411
                    self.match(JavaParser.STATIC)

                self.state = 414
                self.block()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 418
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 34, self._ctx)
                while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 415
                        self.modifier()
                    self.state = 420
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input, 34, self._ctx)

                self.state = 421
                self.memberDeclaration()
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class MemberDeclarationContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def methodDeclaration(self):
            return self.getTypedRuleContext(JavaParser.MethodDeclarationContext, 0)

        def genericMethodDeclaration(self):
            return self.getTypedRuleContext(JavaParser.GenericMethodDeclarationContext, 0)

        def fieldDeclaration(self):
            return self.getTypedRuleContext(JavaParser.FieldDeclarationContext, 0)

        def constructorDeclaration(self):
            return self.getTypedRuleContext(JavaParser.ConstructorDeclarationContext, 0)

        def genericConstructorDeclaration(self):
            return self.getTypedRuleContext(JavaParser.GenericConstructorDeclarationContext, 0)

        def interfaceDeclaration(self):
            return self.getTypedRuleContext(JavaParser.InterfaceDeclarationContext, 0)

        def annotationTypeDeclaration(self):
            return self.getTypedRuleContext(JavaParser.AnnotationTypeDeclarationContext, 0)

        def classDeclaration(self):
            return self.getTypedRuleContext(JavaParser.ClassDeclarationContext, 0)

        def enumDeclaration(self):
            return self.getTypedRuleContext(JavaParser.EnumDeclarationContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_memberDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterMemberDeclaration"):
                listener.enterMemberDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitMemberDeclaration"):
                listener.exitMemberDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitMemberDeclaration"):
                return visitor.visitMemberDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def memberDeclaration(self):

        localctx = JavaParser.MemberDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_memberDeclaration)
        try:
            self.state = 433
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 36, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 424
                self.methodDeclaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 425
                self.genericMethodDeclaration()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 426
                self.fieldDeclaration()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 427
                self.constructorDeclaration()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 428
                self.genericConstructorDeclaration()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 429
                self.interfaceDeclaration()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 430
                self.annotationTypeDeclaration()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 431
                self.classDeclaration()
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 432
                self.enumDeclaration()
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class MethodDeclarationContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeTypeOrVoid(self):
            return self.getTypedRuleContext(JavaParser.TypeTypeOrVoidContext, 0)

        def IDENTIFIER(self):
            return self.getToken(JavaParser.IDENTIFIER, 0)

        def formalParameters(self):
            return self.getTypedRuleContext(JavaParser.FormalParametersContext, 0)

        def methodBody(self):
            return self.getTypedRuleContext(JavaParser.MethodBodyContext, 0)

        def LBRACK(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.LBRACK)
            else:
                return self.getToken(JavaParser.LBRACK, i)

        def RBRACK(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.RBRACK)
            else:
                return self.getToken(JavaParser.RBRACK, i)

        def THROWS(self):
            return self.getToken(JavaParser.THROWS, 0)

        def qualifiedNameList(self):
            return self.getTypedRuleContext(JavaParser.QualifiedNameListContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_methodDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterMethodDeclaration"):
                listener.enterMethodDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitMethodDeclaration"):
                listener.exitMethodDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitMethodDeclaration"):
                return visitor.visitMethodDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def methodDeclaration(self):

        localctx = JavaParser.MethodDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_methodDeclaration)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 435
            self.typeTypeOrVoid()
            self.state = 436
            self.match(JavaParser.IDENTIFIER)
            self.state = 437
            self.formalParameters()
            self.state = 442
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == JavaParser.LBRACK:
                self.state = 438
                self.match(JavaParser.LBRACK)
                self.state = 439
                self.match(JavaParser.RBRACK)
                self.state = 444
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 447
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == JavaParser.THROWS:
                self.state = 445
                self.match(JavaParser.THROWS)
                self.state = 446
                self.qualifiedNameList()

            self.state = 449
            self.methodBody()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class MethodBodyContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def block(self):
            return self.getTypedRuleContext(JavaParser.BlockContext, 0)

        def SEMI(self):
            return self.getToken(JavaParser.SEMI, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_methodBody

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterMethodBody"):
                listener.enterMethodBody(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitMethodBody"):
                listener.exitMethodBody(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitMethodBody"):
                return visitor.visitMethodBody(self)
            else:
                return visitor.visitChildren(self)

    def methodBody(self):

        localctx = JavaParser.MethodBodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_methodBody)
        try:
            self.state = 453
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [JavaParser.LBRACE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 451
                self.block()
                pass
            elif token in [JavaParser.SEMI]:
                self.enterOuterAlt(localctx, 2)
                self.state = 452
                self.match(JavaParser.SEMI)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class TypeTypeOrVoidContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeType(self):
            return self.getTypedRuleContext(JavaParser.TypeTypeContext, 0)

        def VOID(self):
            return self.getToken(JavaParser.VOID, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_typeTypeOrVoid

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterTypeTypeOrVoid"):
                listener.enterTypeTypeOrVoid(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitTypeTypeOrVoid"):
                listener.exitTypeTypeOrVoid(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitTypeTypeOrVoid"):
                return visitor.visitTypeTypeOrVoid(self)
            else:
                return visitor.visitChildren(self)

    def typeTypeOrVoid(self):

        localctx = JavaParser.TypeTypeOrVoidContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_typeTypeOrVoid)
        try:
            self.state = 457
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [
                JavaParser.BOOLEAN,
                JavaParser.BYTE,
                JavaParser.CHAR,
                JavaParser.DOUBLE,
                JavaParser.FLOAT,
                JavaParser.INT,
                JavaParser.LONG,
                JavaParser.SHORT,
                JavaParser.AT,
                JavaParser.IDENTIFIER,
            ]:
                self.enterOuterAlt(localctx, 1)
                self.state = 455
                self.typeType()
                pass
            elif token in [JavaParser.VOID]:
                self.enterOuterAlt(localctx, 2)
                self.state = 456
                self.match(JavaParser.VOID)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class GenericMethodDeclarationContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeParameters(self):
            return self.getTypedRuleContext(JavaParser.TypeParametersContext, 0)

        def methodDeclaration(self):
            return self.getTypedRuleContext(JavaParser.MethodDeclarationContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_genericMethodDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterGenericMethodDeclaration"):
                listener.enterGenericMethodDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitGenericMethodDeclaration"):
                listener.exitGenericMethodDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitGenericMethodDeclaration"):
                return visitor.visitGenericMethodDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def genericMethodDeclaration(self):

        localctx = JavaParser.GenericMethodDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_genericMethodDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 459
            self.typeParameters()
            self.state = 460
            self.methodDeclaration()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class GenericConstructorDeclarationContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeParameters(self):
            return self.getTypedRuleContext(JavaParser.TypeParametersContext, 0)

        def constructorDeclaration(self):
            return self.getTypedRuleContext(JavaParser.ConstructorDeclarationContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_genericConstructorDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterGenericConstructorDeclaration"):
                listener.enterGenericConstructorDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitGenericConstructorDeclaration"):
                listener.exitGenericConstructorDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitGenericConstructorDeclaration"):
                return visitor.visitGenericConstructorDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def genericConstructorDeclaration(self):

        localctx = JavaParser.GenericConstructorDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_genericConstructorDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 462
            self.typeParameters()
            self.state = 463
            self.constructorDeclaration()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ConstructorDeclarationContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.constructorBody = None  # BlockContext

        def IDENTIFIER(self):
            return self.getToken(JavaParser.IDENTIFIER, 0)

        def formalParameters(self):
            return self.getTypedRuleContext(JavaParser.FormalParametersContext, 0)

        def block(self):
            return self.getTypedRuleContext(JavaParser.BlockContext, 0)

        def THROWS(self):
            return self.getToken(JavaParser.THROWS, 0)

        def qualifiedNameList(self):
            return self.getTypedRuleContext(JavaParser.QualifiedNameListContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_constructorDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterConstructorDeclaration"):
                listener.enterConstructorDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitConstructorDeclaration"):
                listener.exitConstructorDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitConstructorDeclaration"):
                return visitor.visitConstructorDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def constructorDeclaration(self):

        localctx = JavaParser.ConstructorDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_constructorDeclaration)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 465
            self.match(JavaParser.IDENTIFIER)
            self.state = 466
            self.formalParameters()
            self.state = 469
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == JavaParser.THROWS:
                self.state = 467
                self.match(JavaParser.THROWS)
                self.state = 468
                self.qualifiedNameList()

            self.state = 471
            localctx.constructorBody = self.block()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class FieldDeclarationContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeType(self):
            return self.getTypedRuleContext(JavaParser.TypeTypeContext, 0)

        def variableDeclarators(self):
            return self.getTypedRuleContext(JavaParser.VariableDeclaratorsContext, 0)

        def SEMI(self):
            return self.getToken(JavaParser.SEMI, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_fieldDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterFieldDeclaration"):
                listener.enterFieldDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitFieldDeclaration"):
                listener.exitFieldDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitFieldDeclaration"):
                return visitor.visitFieldDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def fieldDeclaration(self):

        localctx = JavaParser.FieldDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_fieldDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 473
            self.typeType()
            self.state = 474
            self.variableDeclarators()
            self.state = 475
            self.match(JavaParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class InterfaceBodyDeclarationContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def interfaceMemberDeclaration(self):
            return self.getTypedRuleContext(JavaParser.InterfaceMemberDeclarationContext, 0)

        def modifier(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.ModifierContext)
            else:
                return self.getTypedRuleContext(JavaParser.ModifierContext, i)

        def SEMI(self):
            return self.getToken(JavaParser.SEMI, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_interfaceBodyDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterInterfaceBodyDeclaration"):
                listener.enterInterfaceBodyDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitInterfaceBodyDeclaration"):
                listener.exitInterfaceBodyDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitInterfaceBodyDeclaration"):
                return visitor.visitInterfaceBodyDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def interfaceBodyDeclaration(self):

        localctx = JavaParser.InterfaceBodyDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_interfaceBodyDeclaration)
        try:
            self.state = 485
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [
                JavaParser.ABSTRACT,
                JavaParser.BOOLEAN,
                JavaParser.BYTE,
                JavaParser.CHAR,
                JavaParser.CLASS,
                JavaParser.DEFAULT,
                JavaParser.DOUBLE,
                JavaParser.ENUM,
                JavaParser.FINAL,
                JavaParser.FLOAT,
                JavaParser.INT,
                JavaParser.INTERFACE,
                JavaParser.LONG,
                JavaParser.NATIVE,
                JavaParser.PRIVATE,
                JavaParser.PROTECTED,
                JavaParser.PUBLIC,
                JavaParser.SHORT,
                JavaParser.STATIC,
                JavaParser.STRICTFP,
                JavaParser.SYNCHRONIZED,
                JavaParser.TRANSIENT,
                JavaParser.VOID,
                JavaParser.VOLATILE,
                JavaParser.LT,
                JavaParser.AT,
                JavaParser.IDENTIFIER,
            ]:
                self.enterOuterAlt(localctx, 1)
                self.state = 480
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 42, self._ctx)
                while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 477
                        self.modifier()
                    self.state = 482
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input, 42, self._ctx)

                self.state = 483
                self.interfaceMemberDeclaration()
                pass
            elif token in [JavaParser.SEMI]:
                self.enterOuterAlt(localctx, 2)
                self.state = 484
                self.match(JavaParser.SEMI)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class InterfaceMemberDeclarationContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def constDeclaration(self):
            return self.getTypedRuleContext(JavaParser.ConstDeclarationContext, 0)

        def interfaceMethodDeclaration(self):
            return self.getTypedRuleContext(JavaParser.InterfaceMethodDeclarationContext, 0)

        def genericInterfaceMethodDeclaration(self):
            return self.getTypedRuleContext(JavaParser.GenericInterfaceMethodDeclarationContext, 0)

        def interfaceDeclaration(self):
            return self.getTypedRuleContext(JavaParser.InterfaceDeclarationContext, 0)

        def annotationTypeDeclaration(self):
            return self.getTypedRuleContext(JavaParser.AnnotationTypeDeclarationContext, 0)

        def classDeclaration(self):
            return self.getTypedRuleContext(JavaParser.ClassDeclarationContext, 0)

        def enumDeclaration(self):
            return self.getTypedRuleContext(JavaParser.EnumDeclarationContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_interfaceMemberDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterInterfaceMemberDeclaration"):
                listener.enterInterfaceMemberDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitInterfaceMemberDeclaration"):
                listener.exitInterfaceMemberDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitInterfaceMemberDeclaration"):
                return visitor.visitInterfaceMemberDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def interfaceMemberDeclaration(self):

        localctx = JavaParser.InterfaceMemberDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_interfaceMemberDeclaration)
        try:
            self.state = 494
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 44, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 487
                self.constDeclaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 488
                self.interfaceMethodDeclaration()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 489
                self.genericInterfaceMethodDeclaration()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 490
                self.interfaceDeclaration()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 491
                self.annotationTypeDeclaration()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 492
                self.classDeclaration()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 493
                self.enumDeclaration()
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ConstDeclarationContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeType(self):
            return self.getTypedRuleContext(JavaParser.TypeTypeContext, 0)

        def constantDeclarator(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.ConstantDeclaratorContext)
            else:
                return self.getTypedRuleContext(JavaParser.ConstantDeclaratorContext, i)

        def SEMI(self):
            return self.getToken(JavaParser.SEMI, 0)

        def COMMA(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.COMMA)
            else:
                return self.getToken(JavaParser.COMMA, i)

        def getRuleIndex(self):
            return JavaParser.RULE_constDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterConstDeclaration"):
                listener.enterConstDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitConstDeclaration"):
                listener.exitConstDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitConstDeclaration"):
                return visitor.visitConstDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def constDeclaration(self):

        localctx = JavaParser.ConstDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_constDeclaration)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 496
            self.typeType()
            self.state = 497
            self.constantDeclarator()
            self.state = 502
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == JavaParser.COMMA:
                self.state = 498
                self.match(JavaParser.COMMA)
                self.state = 499
                self.constantDeclarator()
                self.state = 504
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 505
            self.match(JavaParser.SEMI)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ConstantDeclaratorContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def IDENTIFIER(self):
            return self.getToken(JavaParser.IDENTIFIER, 0)

        def ASSIGN(self):
            return self.getToken(JavaParser.ASSIGN, 0)

        def variableInitializer(self):
            return self.getTypedRuleContext(JavaParser.VariableInitializerContext, 0)

        def LBRACK(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.LBRACK)
            else:
                return self.getToken(JavaParser.LBRACK, i)

        def RBRACK(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.RBRACK)
            else:
                return self.getToken(JavaParser.RBRACK, i)

        def getRuleIndex(self):
            return JavaParser.RULE_constantDeclarator

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterConstantDeclarator"):
                listener.enterConstantDeclarator(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitConstantDeclarator"):
                listener.exitConstantDeclarator(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitConstantDeclarator"):
                return visitor.visitConstantDeclarator(self)
            else:
                return visitor.visitChildren(self)

    def constantDeclarator(self):

        localctx = JavaParser.ConstantDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_constantDeclarator)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 507
            self.match(JavaParser.IDENTIFIER)
            self.state = 512
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == JavaParser.LBRACK:
                self.state = 508
                self.match(JavaParser.LBRACK)
                self.state = 509
                self.match(JavaParser.RBRACK)
                self.state = 514
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 515
            self.match(JavaParser.ASSIGN)
            self.state = 516
            self.variableInitializer()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class InterfaceMethodDeclarationContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def IDENTIFIER(self):
            return self.getToken(JavaParser.IDENTIFIER, 0)

        def formalParameters(self):
            return self.getTypedRuleContext(JavaParser.FormalParametersContext, 0)

        def methodBody(self):
            return self.getTypedRuleContext(JavaParser.MethodBodyContext, 0)

        def typeTypeOrVoid(self):
            return self.getTypedRuleContext(JavaParser.TypeTypeOrVoidContext, 0)

        def typeParameters(self):
            return self.getTypedRuleContext(JavaParser.TypeParametersContext, 0)

        def interfaceMethodModifier(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.InterfaceMethodModifierContext)
            else:
                return self.getTypedRuleContext(JavaParser.InterfaceMethodModifierContext, i)

        def LBRACK(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.LBRACK)
            else:
                return self.getToken(JavaParser.LBRACK, i)

        def RBRACK(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.RBRACK)
            else:
                return self.getToken(JavaParser.RBRACK, i)

        def THROWS(self):
            return self.getToken(JavaParser.THROWS, 0)

        def qualifiedNameList(self):
            return self.getTypedRuleContext(JavaParser.QualifiedNameListContext, 0)

        def annotation(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.AnnotationContext)
            else:
                return self.getTypedRuleContext(JavaParser.AnnotationContext, i)

        def getRuleIndex(self):
            return JavaParser.RULE_interfaceMethodDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterInterfaceMethodDeclaration"):
                listener.enterInterfaceMethodDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitInterfaceMethodDeclaration"):
                listener.exitInterfaceMethodDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitInterfaceMethodDeclaration"):
                return visitor.visitInterfaceMethodDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def interfaceMethodDeclaration(self):

        localctx = JavaParser.InterfaceMethodDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_interfaceMethodDeclaration)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 521
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input, 47, self._ctx)
            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 518
                    self.interfaceMethodModifier()
                self.state = 523
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 47, self._ctx)

            self.state = 534
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [
                JavaParser.BOOLEAN,
                JavaParser.BYTE,
                JavaParser.CHAR,
                JavaParser.DOUBLE,
                JavaParser.FLOAT,
                JavaParser.INT,
                JavaParser.LONG,
                JavaParser.SHORT,
                JavaParser.VOID,
                JavaParser.AT,
                JavaParser.IDENTIFIER,
            ]:
                self.state = 524
                self.typeTypeOrVoid()
                pass
            elif token in [JavaParser.LT]:
                self.state = 525
                self.typeParameters()
                self.state = 529
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 48, self._ctx)
                while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 526
                        self.annotation()
                    self.state = 531
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input, 48, self._ctx)

                self.state = 532
                self.typeTypeOrVoid()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 536
            self.match(JavaParser.IDENTIFIER)
            self.state = 537
            self.formalParameters()
            self.state = 542
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == JavaParser.LBRACK:
                self.state = 538
                self.match(JavaParser.LBRACK)
                self.state = 539
                self.match(JavaParser.RBRACK)
                self.state = 544
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 547
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == JavaParser.THROWS:
                self.state = 545
                self.match(JavaParser.THROWS)
                self.state = 546
                self.qualifiedNameList()

            self.state = 549
            self.methodBody()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class InterfaceMethodModifierContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def annotation(self):
            return self.getTypedRuleContext(JavaParser.AnnotationContext, 0)

        def PUBLIC(self):
            return self.getToken(JavaParser.PUBLIC, 0)

        def ABSTRACT(self):
            return self.getToken(JavaParser.ABSTRACT, 0)

        def DEFAULT(self):
            return self.getToken(JavaParser.DEFAULT, 0)

        def STATIC(self):
            return self.getToken(JavaParser.STATIC, 0)

        def STRICTFP(self):
            return self.getToken(JavaParser.STRICTFP, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_interfaceMethodModifier

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterInterfaceMethodModifier"):
                listener.enterInterfaceMethodModifier(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitInterfaceMethodModifier"):
                listener.exitInterfaceMethodModifier(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitInterfaceMethodModifier"):
                return visitor.visitInterfaceMethodModifier(self)
            else:
                return visitor.visitChildren(self)

    def interfaceMethodModifier(self):

        localctx = JavaParser.InterfaceMethodModifierContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_interfaceMethodModifier)
        try:
            self.state = 557
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [JavaParser.AT, JavaParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 551
                self.annotation()
                pass
            elif token in [JavaParser.PUBLIC]:
                self.enterOuterAlt(localctx, 2)
                self.state = 552
                self.match(JavaParser.PUBLIC)
                pass
            elif token in [JavaParser.ABSTRACT]:
                self.enterOuterAlt(localctx, 3)
                self.state = 553
                self.match(JavaParser.ABSTRACT)
                pass
            elif token in [JavaParser.DEFAULT]:
                self.enterOuterAlt(localctx, 4)
                self.state = 554
                self.match(JavaParser.DEFAULT)
                pass
            elif token in [JavaParser.STATIC]:
                self.enterOuterAlt(localctx, 5)
                self.state = 555
                self.match(JavaParser.STATIC)
                pass
            elif token in [JavaParser.STRICTFP]:
                self.enterOuterAlt(localctx, 6)
                self.state = 556
                self.match(JavaParser.STRICTFP)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class GenericInterfaceMethodDeclarationContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeParameters(self):
            return self.getTypedRuleContext(JavaParser.TypeParametersContext, 0)

        def interfaceMethodDeclaration(self):
            return self.getTypedRuleContext(JavaParser.InterfaceMethodDeclarationContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_genericInterfaceMethodDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterGenericInterfaceMethodDeclaration"):
                listener.enterGenericInterfaceMethodDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitGenericInterfaceMethodDeclaration"):
                listener.exitGenericInterfaceMethodDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitGenericInterfaceMethodDeclaration"):
                return visitor.visitGenericInterfaceMethodDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def genericInterfaceMethodDeclaration(self):

        localctx = JavaParser.GenericInterfaceMethodDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_genericInterfaceMethodDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 559
            self.typeParameters()
            self.state = 560
            self.interfaceMethodDeclaration()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class VariableDeclaratorsContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def variableDeclarator(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.VariableDeclaratorContext)
            else:
                return self.getTypedRuleContext(JavaParser.VariableDeclaratorContext, i)

        def COMMA(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.COMMA)
            else:
                return self.getToken(JavaParser.COMMA, i)

        def getRuleIndex(self):
            return JavaParser.RULE_variableDeclarators

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterVariableDeclarators"):
                listener.enterVariableDeclarators(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitVariableDeclarators"):
                listener.exitVariableDeclarators(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitVariableDeclarators"):
                return visitor.visitVariableDeclarators(self)
            else:
                return visitor.visitChildren(self)

    def variableDeclarators(self):

        localctx = JavaParser.VariableDeclaratorsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_variableDeclarators)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 562
            self.variableDeclarator()
            self.state = 567
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == JavaParser.COMMA:
                self.state = 563
                self.match(JavaParser.COMMA)
                self.state = 564
                self.variableDeclarator()
                self.state = 569
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class VariableDeclaratorContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def variableDeclaratorId(self):
            return self.getTypedRuleContext(JavaParser.VariableDeclaratorIdContext, 0)

        def ASSIGN(self):
            return self.getToken(JavaParser.ASSIGN, 0)

        def variableInitializer(self):
            return self.getTypedRuleContext(JavaParser.VariableInitializerContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_variableDeclarator

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterVariableDeclarator"):
                listener.enterVariableDeclarator(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitVariableDeclarator"):
                listener.exitVariableDeclarator(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitVariableDeclarator"):
                return visitor.visitVariableDeclarator(self)
            else:
                return visitor.visitChildren(self)

    def variableDeclarator(self):

        localctx = JavaParser.VariableDeclaratorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_variableDeclarator)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 570
            self.variableDeclaratorId()
            self.state = 573
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == JavaParser.ASSIGN:
                self.state = 571
                self.match(JavaParser.ASSIGN)
                self.state = 572
                self.variableInitializer()

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class VariableDeclaratorIdContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def IDENTIFIER(self):
            return self.getToken(JavaParser.IDENTIFIER, 0)

        def LBRACK(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.LBRACK)
            else:
                return self.getToken(JavaParser.LBRACK, i)

        def RBRACK(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.RBRACK)
            else:
                return self.getToken(JavaParser.RBRACK, i)

        def getRuleIndex(self):
            return JavaParser.RULE_variableDeclaratorId

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterVariableDeclaratorId"):
                listener.enterVariableDeclaratorId(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitVariableDeclaratorId"):
                listener.exitVariableDeclaratorId(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitVariableDeclaratorId"):
                return visitor.visitVariableDeclaratorId(self)
            else:
                return visitor.visitChildren(self)

    def variableDeclaratorId(self):

        localctx = JavaParser.VariableDeclaratorIdContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_variableDeclaratorId)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 575
            self.match(JavaParser.IDENTIFIER)
            self.state = 580
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == JavaParser.LBRACK:
                self.state = 576
                self.match(JavaParser.LBRACK)
                self.state = 577
                self.match(JavaParser.RBRACK)
                self.state = 582
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class VariableInitializerContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def arrayInitializer(self):
            return self.getTypedRuleContext(JavaParser.ArrayInitializerContext, 0)

        def expression(self):
            return self.getTypedRuleContext(JavaParser.ExpressionContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_variableInitializer

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterVariableInitializer"):
                listener.enterVariableInitializer(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitVariableInitializer"):
                listener.exitVariableInitializer(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitVariableInitializer"):
                return visitor.visitVariableInitializer(self)
            else:
                return visitor.visitChildren(self)

    def variableInitializer(self):

        localctx = JavaParser.VariableInitializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_variableInitializer)
        try:
            self.state = 585
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [JavaParser.LBRACE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 583
                self.arrayInitializer()
                pass
            elif token in [
                JavaParser.BOOLEAN,
                JavaParser.BYTE,
                JavaParser.CHAR,
                JavaParser.DOUBLE,
                JavaParser.FLOAT,
                JavaParser.INT,
                JavaParser.LONG,
                JavaParser.NEW,
                JavaParser.SHORT,
                JavaParser.SUPER,
                JavaParser.THIS,
                JavaParser.VOID,
                JavaParser.DECIMAL_LITERAL,
                JavaParser.HEX_LITERAL,
                JavaParser.OCT_LITERAL,
                JavaParser.BINARY_LITERAL,
                JavaParser.FLOAT_LITERAL,
                JavaParser.HEX_FLOAT_LITERAL,
                JavaParser.BOOL_LITERAL,
                JavaParser.CHAR_LITERAL,
                JavaParser.STRING_LITERAL,
                JavaParser.NULL_LITERAL,
                JavaParser.LPAREN,
                JavaParser.LT,
                JavaParser.BANG,
                JavaParser.TILDE,
                JavaParser.INC,
                JavaParser.DEC,
                JavaParser.ADD,
                JavaParser.SUB,
                JavaParser.AT,
                JavaParser.IDENTIFIER,
            ]:
                self.enterOuterAlt(localctx, 2)
                self.state = 584
                self.expression(0)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ArrayInitializerContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LBRACE(self):
            return self.getToken(JavaParser.LBRACE, 0)

        def RBRACE(self):
            return self.getToken(JavaParser.RBRACE, 0)

        def variableInitializer(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.VariableInitializerContext)
            else:
                return self.getTypedRuleContext(JavaParser.VariableInitializerContext, i)

        def COMMA(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.COMMA)
            else:
                return self.getToken(JavaParser.COMMA, i)

        def getRuleIndex(self):
            return JavaParser.RULE_arrayInitializer

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterArrayInitializer"):
                listener.enterArrayInitializer(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitArrayInitializer"):
                listener.exitArrayInitializer(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitArrayInitializer"):
                return visitor.visitArrayInitializer(self)
            else:
                return visitor.visitChildren(self)

    def arrayInitializer(self):

        localctx = JavaParser.ArrayInitializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_arrayInitializer)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 587
            self.match(JavaParser.LBRACE)
            self.state = 599
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (
                ((_la) & ~0x3F) == 0
                and (
                    (1 << _la)
                    & (
                        (1 << JavaParser.BOOLEAN)
                        | (1 << JavaParser.BYTE)
                        | (1 << JavaParser.CHAR)
                        | (1 << JavaParser.DOUBLE)
                        | (1 << JavaParser.FLOAT)
                        | (1 << JavaParser.INT)
                        | (1 << JavaParser.LONG)
                        | (1 << JavaParser.NEW)
                        | (1 << JavaParser.SHORT)
                        | (1 << JavaParser.SUPER)
                        | (1 << JavaParser.THIS)
                        | (1 << JavaParser.VOID)
                        | (1 << JavaParser.DECIMAL_LITERAL)
                        | (1 << JavaParser.HEX_LITERAL)
                        | (1 << JavaParser.OCT_LITERAL)
                        | (1 << JavaParser.BINARY_LITERAL)
                        | (1 << JavaParser.FLOAT_LITERAL)
                        | (1 << JavaParser.HEX_FLOAT_LITERAL)
                        | (1 << JavaParser.BOOL_LITERAL)
                        | (1 << JavaParser.CHAR_LITERAL)
                        | (1 << JavaParser.STRING_LITERAL)
                        | (1 << JavaParser.NULL_LITERAL)
                        | (1 << JavaParser.LPAREN)
                        | (1 << JavaParser.LBRACE)
                    )
                )
                != 0
            ) or (
                (((_la - 72)) & ~0x3F) == 0
                and (
                    (1 << (_la - 72))
                    & (
                        (1 << (JavaParser.LT - 72))
                        | (1 << (JavaParser.BANG - 72))
                        | (1 << (JavaParser.TILDE - 72))
                        | (1 << (JavaParser.INC - 72))
                        | (1 << (JavaParser.DEC - 72))
                        | (1 << (JavaParser.ADD - 72))
                        | (1 << (JavaParser.SUB - 72))
                        | (1 << (JavaParser.AT - 72))
                        | (1 << (JavaParser.IDENTIFIER - 72))
                    )
                )
                != 0
            ):
                self.state = 588
                self.variableInitializer()
                self.state = 593
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 57, self._ctx)
                while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 589
                        self.match(JavaParser.COMMA)
                        self.state = 590
                        self.variableInitializer()
                    self.state = 595
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input, 57, self._ctx)

                self.state = 597
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la == JavaParser.COMMA:
                    self.state = 596
                    self.match(JavaParser.COMMA)

            self.state = 601
            self.match(JavaParser.RBRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ClassOrInterfaceTypeContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def IDENTIFIER(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.IDENTIFIER)
            else:
                return self.getToken(JavaParser.IDENTIFIER, i)

        def typeArguments(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.TypeArgumentsContext)
            else:
                return self.getTypedRuleContext(JavaParser.TypeArgumentsContext, i)

        def DOT(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.DOT)
            else:
                return self.getToken(JavaParser.DOT, i)

        def getRuleIndex(self):
            return JavaParser.RULE_classOrInterfaceType

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterClassOrInterfaceType"):
                listener.enterClassOrInterfaceType(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitClassOrInterfaceType"):
                listener.exitClassOrInterfaceType(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitClassOrInterfaceType"):
                return visitor.visitClassOrInterfaceType(self)
            else:
                return visitor.visitChildren(self)

    def classOrInterfaceType(self):

        localctx = JavaParser.ClassOrInterfaceTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_classOrInterfaceType)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 603
            self.match(JavaParser.IDENTIFIER)
            self.state = 605
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 60, self._ctx)
            if la_ == 1:
                self.state = 604
                self.typeArguments()

            self.state = 614
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input, 62, self._ctx)
            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 607
                    self.match(JavaParser.DOT)
                    self.state = 608
                    self.match(JavaParser.IDENTIFIER)
                    self.state = 610
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input, 61, self._ctx)
                    if la_ == 1:
                        self.state = 609
                        self.typeArguments()

                self.state = 616
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 62, self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class TypeArgumentContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeType(self):
            return self.getTypedRuleContext(JavaParser.TypeTypeContext, 0)

        def QUESTION(self):
            return self.getToken(JavaParser.QUESTION, 0)

        def annotation(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.AnnotationContext)
            else:
                return self.getTypedRuleContext(JavaParser.AnnotationContext, i)

        def EXTENDS(self):
            return self.getToken(JavaParser.EXTENDS, 0)

        def SUPER(self):
            return self.getToken(JavaParser.SUPER, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_typeArgument

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterTypeArgument"):
                listener.enterTypeArgument(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitTypeArgument"):
                listener.exitTypeArgument(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitTypeArgument"):
                return visitor.visitTypeArgument(self)
            else:
                return visitor.visitChildren(self)

    def typeArgument(self):

        localctx = JavaParser.TypeArgumentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_typeArgument)
        self._la = 0  # Token type
        try:
            self.state = 629
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 65, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 617
                self.typeType()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 621
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la == JavaParser.AT or _la == JavaParser.IDENTIFIER:
                    self.state = 618
                    self.annotation()
                    self.state = 623
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 624
                self.match(JavaParser.QUESTION)
                self.state = 627
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la == JavaParser.EXTENDS or _la == JavaParser.SUPER:
                    self.state = 625
                    _la = self._input.LA(1)
                    if not (_la == JavaParser.EXTENDS or _la == JavaParser.SUPER):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()
                    self.state = 626
                    self.typeType()

                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class QualifiedNameListContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def qualifiedName(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.QualifiedNameContext)
            else:
                return self.getTypedRuleContext(JavaParser.QualifiedNameContext, i)

        def COMMA(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.COMMA)
            else:
                return self.getToken(JavaParser.COMMA, i)

        def getRuleIndex(self):
            return JavaParser.RULE_qualifiedNameList

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterQualifiedNameList"):
                listener.enterQualifiedNameList(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitQualifiedNameList"):
                listener.exitQualifiedNameList(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitQualifiedNameList"):
                return visitor.visitQualifiedNameList(self)
            else:
                return visitor.visitChildren(self)

    def qualifiedNameList(self):

        localctx = JavaParser.QualifiedNameListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_qualifiedNameList)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 631
            self.qualifiedName()
            self.state = 636
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == JavaParser.COMMA:
                self.state = 632
                self.match(JavaParser.COMMA)
                self.state = 633
                self.qualifiedName()
                self.state = 638
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class FormalParametersContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LPAREN(self):
            return self.getToken(JavaParser.LPAREN, 0)

        def RPAREN(self):
            return self.getToken(JavaParser.RPAREN, 0)

        def formalParameterList(self):
            return self.getTypedRuleContext(JavaParser.FormalParameterListContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_formalParameters

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterFormalParameters"):
                listener.enterFormalParameters(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitFormalParameters"):
                listener.exitFormalParameters(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitFormalParameters"):
                return visitor.visitFormalParameters(self)
            else:
                return visitor.visitChildren(self)

    def formalParameters(self):

        localctx = JavaParser.FormalParametersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_formalParameters)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 639
            self.match(JavaParser.LPAREN)
            self.state = 641
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (
                (
                    ((_la) & ~0x3F) == 0
                    and (
                        (1 << _la)
                        & (
                            (1 << JavaParser.BOOLEAN)
                            | (1 << JavaParser.BYTE)
                            | (1 << JavaParser.CHAR)
                            | (1 << JavaParser.DOUBLE)
                            | (1 << JavaParser.FINAL)
                            | (1 << JavaParser.FLOAT)
                            | (1 << JavaParser.INT)
                            | (1 << JavaParser.LONG)
                            | (1 << JavaParser.SHORT)
                        )
                    )
                    != 0
                )
                or _la == JavaParser.AT
                or _la == JavaParser.IDENTIFIER
            ):
                self.state = 640
                self.formalParameterList()

            self.state = 643
            self.match(JavaParser.RPAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class FormalParameterListContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def formalParameter(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.FormalParameterContext)
            else:
                return self.getTypedRuleContext(JavaParser.FormalParameterContext, i)

        def COMMA(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.COMMA)
            else:
                return self.getToken(JavaParser.COMMA, i)

        def lastFormalParameter(self):
            return self.getTypedRuleContext(JavaParser.LastFormalParameterContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_formalParameterList

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterFormalParameterList"):
                listener.enterFormalParameterList(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitFormalParameterList"):
                listener.exitFormalParameterList(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitFormalParameterList"):
                return visitor.visitFormalParameterList(self)
            else:
                return visitor.visitChildren(self)

    def formalParameterList(self):

        localctx = JavaParser.FormalParameterListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_formalParameterList)
        self._la = 0  # Token type
        try:
            self.state = 658
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 70, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 645
                self.formalParameter()
                self.state = 650
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 68, self._ctx)
                while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 646
                        self.match(JavaParser.COMMA)
                        self.state = 647
                        self.formalParameter()
                    self.state = 652
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input, 68, self._ctx)

                self.state = 655
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la == JavaParser.COMMA:
                    self.state = 653
                    self.match(JavaParser.COMMA)
                    self.state = 654
                    self.lastFormalParameter()

                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 657
                self.lastFormalParameter()
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class FormalParameterContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeType(self):
            return self.getTypedRuleContext(JavaParser.TypeTypeContext, 0)

        def variableDeclaratorId(self):
            return self.getTypedRuleContext(JavaParser.VariableDeclaratorIdContext, 0)

        def variableModifier(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.VariableModifierContext)
            else:
                return self.getTypedRuleContext(JavaParser.VariableModifierContext, i)

        def getRuleIndex(self):
            return JavaParser.RULE_formalParameter

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterFormalParameter"):
                listener.enterFormalParameter(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitFormalParameter"):
                listener.exitFormalParameter(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitFormalParameter"):
                return visitor.visitFormalParameter(self)
            else:
                return visitor.visitChildren(self)

    def formalParameter(self):

        localctx = JavaParser.FormalParameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_formalParameter)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 663
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input, 71, self._ctx)
            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 660
                    self.variableModifier()
                self.state = 665
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 71, self._ctx)

            self.state = 666
            self.typeType()
            self.state = 667
            self.variableDeclaratorId()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class LastFormalParameterContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeType(self):
            return self.getTypedRuleContext(JavaParser.TypeTypeContext, 0)

        def ELLIPSIS(self):
            return self.getToken(JavaParser.ELLIPSIS, 0)

        def variableDeclaratorId(self):
            return self.getTypedRuleContext(JavaParser.VariableDeclaratorIdContext, 0)

        def variableModifier(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.VariableModifierContext)
            else:
                return self.getTypedRuleContext(JavaParser.VariableModifierContext, i)

        def annotation(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.AnnotationContext)
            else:
                return self.getTypedRuleContext(JavaParser.AnnotationContext, i)

        def getRuleIndex(self):
            return JavaParser.RULE_lastFormalParameter

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterLastFormalParameter"):
                listener.enterLastFormalParameter(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitLastFormalParameter"):
                listener.exitLastFormalParameter(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitLastFormalParameter"):
                return visitor.visitLastFormalParameter(self)
            else:
                return visitor.visitChildren(self)

    def lastFormalParameter(self):

        localctx = JavaParser.LastFormalParameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_lastFormalParameter)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 672
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input, 72, self._ctx)
            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 669
                    self.variableModifier()
                self.state = 674
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 72, self._ctx)

            self.state = 675
            self.typeType()
            self.state = 679
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == JavaParser.AT or _la == JavaParser.IDENTIFIER:
                self.state = 676
                self.annotation()
                self.state = 681
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 682
            self.match(JavaParser.ELLIPSIS)
            self.state = 683
            self.variableDeclaratorId()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class QualifiedNameContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def IDENTIFIER(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.IDENTIFIER)
            else:
                return self.getToken(JavaParser.IDENTIFIER, i)

        def DOT(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.DOT)
            else:
                return self.getToken(JavaParser.DOT, i)

        def getRuleIndex(self):
            return JavaParser.RULE_qualifiedName

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterQualifiedName"):
                listener.enterQualifiedName(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitQualifiedName"):
                listener.exitQualifiedName(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitQualifiedName"):
                return visitor.visitQualifiedName(self)
            else:
                return visitor.visitChildren(self)

    def qualifiedName(self):

        localctx = JavaParser.QualifiedNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_qualifiedName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 685
            self.match(JavaParser.IDENTIFIER)
            self.state = 690
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input, 74, self._ctx)
            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 686
                    self.match(JavaParser.DOT)
                    self.state = 687
                    self.match(JavaParser.IDENTIFIER)
                self.state = 692
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 74, self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class LiteralContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def integerLiteral(self):
            return self.getTypedRuleContext(JavaParser.IntegerLiteralContext, 0)

        def floatLiteral(self):
            return self.getTypedRuleContext(JavaParser.FloatLiteralContext, 0)

        def CHAR_LITERAL(self):
            return self.getToken(JavaParser.CHAR_LITERAL, 0)

        def STRING_LITERAL(self):
            return self.getToken(JavaParser.STRING_LITERAL, 0)

        def BOOL_LITERAL(self):
            return self.getToken(JavaParser.BOOL_LITERAL, 0)

        def NULL_LITERAL(self):
            return self.getToken(JavaParser.NULL_LITERAL, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_literal

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterLiteral"):
                listener.enterLiteral(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitLiteral"):
                listener.exitLiteral(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitLiteral"):
                return visitor.visitLiteral(self)
            else:
                return visitor.visitChildren(self)

    def literal(self):

        localctx = JavaParser.LiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_literal)
        try:
            self.state = 699
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [
                JavaParser.DECIMAL_LITERAL,
                JavaParser.HEX_LITERAL,
                JavaParser.OCT_LITERAL,
                JavaParser.BINARY_LITERAL,
            ]:
                self.enterOuterAlt(localctx, 1)
                self.state = 693
                self.integerLiteral()
                pass
            elif token in [JavaParser.FLOAT_LITERAL, JavaParser.HEX_FLOAT_LITERAL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 694
                self.floatLiteral()
                pass
            elif token in [JavaParser.CHAR_LITERAL]:
                self.enterOuterAlt(localctx, 3)
                self.state = 695
                self.match(JavaParser.CHAR_LITERAL)
                pass
            elif token in [JavaParser.STRING_LITERAL]:
                self.enterOuterAlt(localctx, 4)
                self.state = 696
                self.match(JavaParser.STRING_LITERAL)
                pass
            elif token in [JavaParser.BOOL_LITERAL]:
                self.enterOuterAlt(localctx, 5)
                self.state = 697
                self.match(JavaParser.BOOL_LITERAL)
                pass
            elif token in [JavaParser.NULL_LITERAL]:
                self.enterOuterAlt(localctx, 6)
                self.state = 698
                self.match(JavaParser.NULL_LITERAL)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class IntegerLiteralContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def DECIMAL_LITERAL(self):
            return self.getToken(JavaParser.DECIMAL_LITERAL, 0)

        def HEX_LITERAL(self):
            return self.getToken(JavaParser.HEX_LITERAL, 0)

        def OCT_LITERAL(self):
            return self.getToken(JavaParser.OCT_LITERAL, 0)

        def BINARY_LITERAL(self):
            return self.getToken(JavaParser.BINARY_LITERAL, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_integerLiteral

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterIntegerLiteral"):
                listener.enterIntegerLiteral(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitIntegerLiteral"):
                listener.exitIntegerLiteral(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitIntegerLiteral"):
                return visitor.visitIntegerLiteral(self)
            else:
                return visitor.visitChildren(self)

    def integerLiteral(self):

        localctx = JavaParser.IntegerLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_integerLiteral)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 701
            _la = self._input.LA(1)
            if not (
                (
                    ((_la) & ~0x3F) == 0
                    and (
                        (1 << _la)
                        & (
                            (1 << JavaParser.DECIMAL_LITERAL)
                            | (1 << JavaParser.HEX_LITERAL)
                            | (1 << JavaParser.OCT_LITERAL)
                            | (1 << JavaParser.BINARY_LITERAL)
                        )
                    )
                    != 0
                )
            ):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class FloatLiteralContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def FLOAT_LITERAL(self):
            return self.getToken(JavaParser.FLOAT_LITERAL, 0)

        def HEX_FLOAT_LITERAL(self):
            return self.getToken(JavaParser.HEX_FLOAT_LITERAL, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_floatLiteral

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterFloatLiteral"):
                listener.enterFloatLiteral(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitFloatLiteral"):
                listener.exitFloatLiteral(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitFloatLiteral"):
                return visitor.visitFloatLiteral(self)
            else:
                return visitor.visitChildren(self)

    def floatLiteral(self):

        localctx = JavaParser.FloatLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_floatLiteral)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 703
            _la = self._input.LA(1)
            if not (_la == JavaParser.FLOAT_LITERAL or _la == JavaParser.HEX_FLOAT_LITERAL):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class AltAnnotationQualifiedNameContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def AT(self):
            return self.getToken(JavaParser.AT, 0)

        def IDENTIFIER(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.IDENTIFIER)
            else:
                return self.getToken(JavaParser.IDENTIFIER, i)

        def DOT(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.DOT)
            else:
                return self.getToken(JavaParser.DOT, i)

        def getRuleIndex(self):
            return JavaParser.RULE_altAnnotationQualifiedName

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterAltAnnotationQualifiedName"):
                listener.enterAltAnnotationQualifiedName(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitAltAnnotationQualifiedName"):
                listener.exitAltAnnotationQualifiedName(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitAltAnnotationQualifiedName"):
                return visitor.visitAltAnnotationQualifiedName(self)
            else:
                return visitor.visitChildren(self)

    def altAnnotationQualifiedName(self):

        localctx = JavaParser.AltAnnotationQualifiedNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_altAnnotationQualifiedName)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 709
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == JavaParser.IDENTIFIER:
                self.state = 705
                self.match(JavaParser.IDENTIFIER)
                self.state = 706
                self.match(JavaParser.DOT)
                self.state = 711
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 712
            self.match(JavaParser.AT)
            self.state = 713
            self.match(JavaParser.IDENTIFIER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class AnnotationContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def AT(self):
            return self.getToken(JavaParser.AT, 0)

        def qualifiedName(self):
            return self.getTypedRuleContext(JavaParser.QualifiedNameContext, 0)

        def altAnnotationQualifiedName(self):
            return self.getTypedRuleContext(JavaParser.AltAnnotationQualifiedNameContext, 0)

        def LPAREN(self):
            return self.getToken(JavaParser.LPAREN, 0)

        def RPAREN(self):
            return self.getToken(JavaParser.RPAREN, 0)

        def elementValuePairs(self):
            return self.getTypedRuleContext(JavaParser.ElementValuePairsContext, 0)

        def elementValue(self):
            return self.getTypedRuleContext(JavaParser.ElementValueContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_annotation

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterAnnotation"):
                listener.enterAnnotation(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitAnnotation"):
                listener.exitAnnotation(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitAnnotation"):
                return visitor.visitAnnotation(self)
            else:
                return visitor.visitChildren(self)

    def annotation(self):

        localctx = JavaParser.AnnotationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_annotation)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 718
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 77, self._ctx)
            if la_ == 1:
                self.state = 715
                self.match(JavaParser.AT)
                self.state = 716
                self.qualifiedName()
                pass

            elif la_ == 2:
                self.state = 717
                self.altAnnotationQualifiedName()
                pass

            self.state = 726
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == JavaParser.LPAREN:
                self.state = 720
                self.match(JavaParser.LPAREN)
                self.state = 723
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input, 78, self._ctx)
                if la_ == 1:
                    self.state = 721
                    self.elementValuePairs()

                elif la_ == 2:
                    self.state = 722
                    self.elementValue()

                self.state = 725
                self.match(JavaParser.RPAREN)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ElementValuePairsContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def elementValuePair(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.ElementValuePairContext)
            else:
                return self.getTypedRuleContext(JavaParser.ElementValuePairContext, i)

        def COMMA(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.COMMA)
            else:
                return self.getToken(JavaParser.COMMA, i)

        def getRuleIndex(self):
            return JavaParser.RULE_elementValuePairs

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterElementValuePairs"):
                listener.enterElementValuePairs(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitElementValuePairs"):
                listener.exitElementValuePairs(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitElementValuePairs"):
                return visitor.visitElementValuePairs(self)
            else:
                return visitor.visitChildren(self)

    def elementValuePairs(self):

        localctx = JavaParser.ElementValuePairsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_elementValuePairs)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 728
            self.elementValuePair()
            self.state = 733
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == JavaParser.COMMA:
                self.state = 729
                self.match(JavaParser.COMMA)
                self.state = 730
                self.elementValuePair()
                self.state = 735
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ElementValuePairContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def IDENTIFIER(self):
            return self.getToken(JavaParser.IDENTIFIER, 0)

        def ASSIGN(self):
            return self.getToken(JavaParser.ASSIGN, 0)

        def elementValue(self):
            return self.getTypedRuleContext(JavaParser.ElementValueContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_elementValuePair

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterElementValuePair"):
                listener.enterElementValuePair(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitElementValuePair"):
                listener.exitElementValuePair(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitElementValuePair"):
                return visitor.visitElementValuePair(self)
            else:
                return visitor.visitChildren(self)

    def elementValuePair(self):

        localctx = JavaParser.ElementValuePairContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_elementValuePair)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 736
            self.match(JavaParser.IDENTIFIER)
            self.state = 737
            self.match(JavaParser.ASSIGN)
            self.state = 738
            self.elementValue()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ElementValueContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self):
            return self.getTypedRuleContext(JavaParser.ExpressionContext, 0)

        def annotation(self):
            return self.getTypedRuleContext(JavaParser.AnnotationContext, 0)

        def elementValueArrayInitializer(self):
            return self.getTypedRuleContext(JavaParser.ElementValueArrayInitializerContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_elementValue

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterElementValue"):
                listener.enterElementValue(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitElementValue"):
                listener.exitElementValue(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitElementValue"):
                return visitor.visitElementValue(self)
            else:
                return visitor.visitChildren(self)

    def elementValue(self):

        localctx = JavaParser.ElementValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_elementValue)
        try:
            self.state = 743
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 81, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 740
                self.expression(0)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 741
                self.annotation()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 742
                self.elementValueArrayInitializer()
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ElementValueArrayInitializerContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LBRACE(self):
            return self.getToken(JavaParser.LBRACE, 0)

        def RBRACE(self):
            return self.getToken(JavaParser.RBRACE, 0)

        def elementValue(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.ElementValueContext)
            else:
                return self.getTypedRuleContext(JavaParser.ElementValueContext, i)

        def COMMA(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.COMMA)
            else:
                return self.getToken(JavaParser.COMMA, i)

        def getRuleIndex(self):
            return JavaParser.RULE_elementValueArrayInitializer

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterElementValueArrayInitializer"):
                listener.enterElementValueArrayInitializer(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitElementValueArrayInitializer"):
                listener.exitElementValueArrayInitializer(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitElementValueArrayInitializer"):
                return visitor.visitElementValueArrayInitializer(self)
            else:
                return visitor.visitChildren(self)

    def elementValueArrayInitializer(self):

        localctx = JavaParser.ElementValueArrayInitializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_elementValueArrayInitializer)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 745
            self.match(JavaParser.LBRACE)
            self.state = 754
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (
                ((_la) & ~0x3F) == 0
                and (
                    (1 << _la)
                    & (
                        (1 << JavaParser.BOOLEAN)
                        | (1 << JavaParser.BYTE)
                        | (1 << JavaParser.CHAR)
                        | (1 << JavaParser.DOUBLE)
                        | (1 << JavaParser.FLOAT)
                        | (1 << JavaParser.INT)
                        | (1 << JavaParser.LONG)
                        | (1 << JavaParser.NEW)
                        | (1 << JavaParser.SHORT)
                        | (1 << JavaParser.SUPER)
                        | (1 << JavaParser.THIS)
                        | (1 << JavaParser.VOID)
                        | (1 << JavaParser.DECIMAL_LITERAL)
                        | (1 << JavaParser.HEX_LITERAL)
                        | (1 << JavaParser.OCT_LITERAL)
                        | (1 << JavaParser.BINARY_LITERAL)
                        | (1 << JavaParser.FLOAT_LITERAL)
                        | (1 << JavaParser.HEX_FLOAT_LITERAL)
                        | (1 << JavaParser.BOOL_LITERAL)
                        | (1 << JavaParser.CHAR_LITERAL)
                        | (1 << JavaParser.STRING_LITERAL)
                        | (1 << JavaParser.NULL_LITERAL)
                        | (1 << JavaParser.LPAREN)
                        | (1 << JavaParser.LBRACE)
                    )
                )
                != 0
            ) or (
                (((_la - 72)) & ~0x3F) == 0
                and (
                    (1 << (_la - 72))
                    & (
                        (1 << (JavaParser.LT - 72))
                        | (1 << (JavaParser.BANG - 72))
                        | (1 << (JavaParser.TILDE - 72))
                        | (1 << (JavaParser.INC - 72))
                        | (1 << (JavaParser.DEC - 72))
                        | (1 << (JavaParser.ADD - 72))
                        | (1 << (JavaParser.SUB - 72))
                        | (1 << (JavaParser.AT - 72))
                        | (1 << (JavaParser.IDENTIFIER - 72))
                    )
                )
                != 0
            ):
                self.state = 746
                self.elementValue()
                self.state = 751
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 82, self._ctx)
                while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 747
                        self.match(JavaParser.COMMA)
                        self.state = 748
                        self.elementValue()
                    self.state = 753
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input, 82, self._ctx)

            self.state = 757
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == JavaParser.COMMA:
                self.state = 756
                self.match(JavaParser.COMMA)

            self.state = 759
            self.match(JavaParser.RBRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class AnnotationTypeDeclarationContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def AT(self):
            return self.getToken(JavaParser.AT, 0)

        def INTERFACE(self):
            return self.getToken(JavaParser.INTERFACE, 0)

        def IDENTIFIER(self):
            return self.getToken(JavaParser.IDENTIFIER, 0)

        def annotationTypeBody(self):
            return self.getTypedRuleContext(JavaParser.AnnotationTypeBodyContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_annotationTypeDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterAnnotationTypeDeclaration"):
                listener.enterAnnotationTypeDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitAnnotationTypeDeclaration"):
                listener.exitAnnotationTypeDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitAnnotationTypeDeclaration"):
                return visitor.visitAnnotationTypeDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def annotationTypeDeclaration(self):

        localctx = JavaParser.AnnotationTypeDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_annotationTypeDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 761
            self.match(JavaParser.AT)
            self.state = 762
            self.match(JavaParser.INTERFACE)
            self.state = 763
            self.match(JavaParser.IDENTIFIER)
            self.state = 764
            self.annotationTypeBody()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class AnnotationTypeBodyContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LBRACE(self):
            return self.getToken(JavaParser.LBRACE, 0)

        def RBRACE(self):
            return self.getToken(JavaParser.RBRACE, 0)

        def annotationTypeElementDeclaration(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.AnnotationTypeElementDeclarationContext)
            else:
                return self.getTypedRuleContext(JavaParser.AnnotationTypeElementDeclarationContext, i)

        def getRuleIndex(self):
            return JavaParser.RULE_annotationTypeBody

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterAnnotationTypeBody"):
                listener.enterAnnotationTypeBody(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitAnnotationTypeBody"):
                listener.exitAnnotationTypeBody(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitAnnotationTypeBody"):
                return visitor.visitAnnotationTypeBody(self)
            else:
                return visitor.visitChildren(self)

    def annotationTypeBody(self):

        localctx = JavaParser.AnnotationTypeBodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_annotationTypeBody)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 766
            self.match(JavaParser.LBRACE)
            self.state = 770
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (
                ((_la) & ~0x3F) == 0
                and (
                    (1 << _la)
                    & (
                        (1 << JavaParser.ABSTRACT)
                        | (1 << JavaParser.BOOLEAN)
                        | (1 << JavaParser.BYTE)
                        | (1 << JavaParser.CHAR)
                        | (1 << JavaParser.CLASS)
                        | (1 << JavaParser.DOUBLE)
                        | (1 << JavaParser.ENUM)
                        | (1 << JavaParser.FINAL)
                        | (1 << JavaParser.FLOAT)
                        | (1 << JavaParser.INT)
                        | (1 << JavaParser.INTERFACE)
                        | (1 << JavaParser.LONG)
                        | (1 << JavaParser.NATIVE)
                        | (1 << JavaParser.PRIVATE)
                        | (1 << JavaParser.PROTECTED)
                        | (1 << JavaParser.PUBLIC)
                        | (1 << JavaParser.SHORT)
                        | (1 << JavaParser.STATIC)
                        | (1 << JavaParser.STRICTFP)
                        | (1 << JavaParser.SYNCHRONIZED)
                        | (1 << JavaParser.TRANSIENT)
                        | (1 << JavaParser.VOLATILE)
                    )
                )
                != 0
            ) or (
                (((_la - 67)) & ~0x3F) == 0
                and (
                    (1 << (_la - 67))
                    & (
                        (1 << (JavaParser.SEMI - 67))
                        | (1 << (JavaParser.AT - 67))
                        | (1 << (JavaParser.IDENTIFIER - 67))
                    )
                )
                != 0
            ):
                self.state = 767
                self.annotationTypeElementDeclaration()
                self.state = 772
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 773
            self.match(JavaParser.RBRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class AnnotationTypeElementDeclarationContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def annotationTypeElementRest(self):
            return self.getTypedRuleContext(JavaParser.AnnotationTypeElementRestContext, 0)

        def modifier(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.ModifierContext)
            else:
                return self.getTypedRuleContext(JavaParser.ModifierContext, i)

        def SEMI(self):
            return self.getToken(JavaParser.SEMI, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_annotationTypeElementDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterAnnotationTypeElementDeclaration"):
                listener.enterAnnotationTypeElementDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitAnnotationTypeElementDeclaration"):
                listener.exitAnnotationTypeElementDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitAnnotationTypeElementDeclaration"):
                return visitor.visitAnnotationTypeElementDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def annotationTypeElementDeclaration(self):

        localctx = JavaParser.AnnotationTypeElementDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_annotationTypeElementDeclaration)
        try:
            self.state = 783
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [
                JavaParser.ABSTRACT,
                JavaParser.BOOLEAN,
                JavaParser.BYTE,
                JavaParser.CHAR,
                JavaParser.CLASS,
                JavaParser.DOUBLE,
                JavaParser.ENUM,
                JavaParser.FINAL,
                JavaParser.FLOAT,
                JavaParser.INT,
                JavaParser.INTERFACE,
                JavaParser.LONG,
                JavaParser.NATIVE,
                JavaParser.PRIVATE,
                JavaParser.PROTECTED,
                JavaParser.PUBLIC,
                JavaParser.SHORT,
                JavaParser.STATIC,
                JavaParser.STRICTFP,
                JavaParser.SYNCHRONIZED,
                JavaParser.TRANSIENT,
                JavaParser.VOLATILE,
                JavaParser.AT,
                JavaParser.IDENTIFIER,
            ]:
                self.enterOuterAlt(localctx, 1)
                self.state = 778
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 86, self._ctx)
                while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 775
                        self.modifier()
                    self.state = 780
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input, 86, self._ctx)

                self.state = 781
                self.annotationTypeElementRest()
                pass
            elif token in [JavaParser.SEMI]:
                self.enterOuterAlt(localctx, 2)
                self.state = 782
                self.match(JavaParser.SEMI)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class AnnotationTypeElementRestContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeType(self):
            return self.getTypedRuleContext(JavaParser.TypeTypeContext, 0)

        def annotationMethodOrConstantRest(self):
            return self.getTypedRuleContext(JavaParser.AnnotationMethodOrConstantRestContext, 0)

        def SEMI(self):
            return self.getToken(JavaParser.SEMI, 0)

        def classDeclaration(self):
            return self.getTypedRuleContext(JavaParser.ClassDeclarationContext, 0)

        def interfaceDeclaration(self):
            return self.getTypedRuleContext(JavaParser.InterfaceDeclarationContext, 0)

        def enumDeclaration(self):
            return self.getTypedRuleContext(JavaParser.EnumDeclarationContext, 0)

        def annotationTypeDeclaration(self):
            return self.getTypedRuleContext(JavaParser.AnnotationTypeDeclarationContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_annotationTypeElementRest

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterAnnotationTypeElementRest"):
                listener.enterAnnotationTypeElementRest(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitAnnotationTypeElementRest"):
                listener.exitAnnotationTypeElementRest(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitAnnotationTypeElementRest"):
                return visitor.visitAnnotationTypeElementRest(self)
            else:
                return visitor.visitChildren(self)

    def annotationTypeElementRest(self):

        localctx = JavaParser.AnnotationTypeElementRestContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_annotationTypeElementRest)
        try:
            self.state = 805
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 92, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 785
                self.typeType()
                self.state = 786
                self.annotationMethodOrConstantRest()
                self.state = 787
                self.match(JavaParser.SEMI)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 789
                self.classDeclaration()
                self.state = 791
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input, 88, self._ctx)
                if la_ == 1:
                    self.state = 790
                    self.match(JavaParser.SEMI)

                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 793
                self.interfaceDeclaration()
                self.state = 795
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input, 89, self._ctx)
                if la_ == 1:
                    self.state = 794
                    self.match(JavaParser.SEMI)

                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 797
                self.enumDeclaration()
                self.state = 799
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input, 90, self._ctx)
                if la_ == 1:
                    self.state = 798
                    self.match(JavaParser.SEMI)

                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 801
                self.annotationTypeDeclaration()
                self.state = 803
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input, 91, self._ctx)
                if la_ == 1:
                    self.state = 802
                    self.match(JavaParser.SEMI)

                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class AnnotationMethodOrConstantRestContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def annotationMethodRest(self):
            return self.getTypedRuleContext(JavaParser.AnnotationMethodRestContext, 0)

        def annotationConstantRest(self):
            return self.getTypedRuleContext(JavaParser.AnnotationConstantRestContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_annotationMethodOrConstantRest

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterAnnotationMethodOrConstantRest"):
                listener.enterAnnotationMethodOrConstantRest(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitAnnotationMethodOrConstantRest"):
                listener.exitAnnotationMethodOrConstantRest(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitAnnotationMethodOrConstantRest"):
                return visitor.visitAnnotationMethodOrConstantRest(self)
            else:
                return visitor.visitChildren(self)

    def annotationMethodOrConstantRest(self):

        localctx = JavaParser.AnnotationMethodOrConstantRestContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_annotationMethodOrConstantRest)
        try:
            self.state = 809
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 93, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 807
                self.annotationMethodRest()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 808
                self.annotationConstantRest()
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class AnnotationMethodRestContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def IDENTIFIER(self):
            return self.getToken(JavaParser.IDENTIFIER, 0)

        def LPAREN(self):
            return self.getToken(JavaParser.LPAREN, 0)

        def RPAREN(self):
            return self.getToken(JavaParser.RPAREN, 0)

        def defaultValue(self):
            return self.getTypedRuleContext(JavaParser.DefaultValueContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_annotationMethodRest

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterAnnotationMethodRest"):
                listener.enterAnnotationMethodRest(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitAnnotationMethodRest"):
                listener.exitAnnotationMethodRest(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitAnnotationMethodRest"):
                return visitor.visitAnnotationMethodRest(self)
            else:
                return visitor.visitChildren(self)

    def annotationMethodRest(self):

        localctx = JavaParser.AnnotationMethodRestContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_annotationMethodRest)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 811
            self.match(JavaParser.IDENTIFIER)
            self.state = 812
            self.match(JavaParser.LPAREN)
            self.state = 813
            self.match(JavaParser.RPAREN)
            self.state = 815
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == JavaParser.DEFAULT:
                self.state = 814
                self.defaultValue()

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class AnnotationConstantRestContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def variableDeclarators(self):
            return self.getTypedRuleContext(JavaParser.VariableDeclaratorsContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_annotationConstantRest

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterAnnotationConstantRest"):
                listener.enterAnnotationConstantRest(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitAnnotationConstantRest"):
                listener.exitAnnotationConstantRest(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitAnnotationConstantRest"):
                return visitor.visitAnnotationConstantRest(self)
            else:
                return visitor.visitChildren(self)

    def annotationConstantRest(self):

        localctx = JavaParser.AnnotationConstantRestContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_annotationConstantRest)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 817
            self.variableDeclarators()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class DefaultValueContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def DEFAULT(self):
            return self.getToken(JavaParser.DEFAULT, 0)

        def elementValue(self):
            return self.getTypedRuleContext(JavaParser.ElementValueContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_defaultValue

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterDefaultValue"):
                listener.enterDefaultValue(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitDefaultValue"):
                listener.exitDefaultValue(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitDefaultValue"):
                return visitor.visitDefaultValue(self)
            else:
                return visitor.visitChildren(self)

    def defaultValue(self):

        localctx = JavaParser.DefaultValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_defaultValue)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 819
            self.match(JavaParser.DEFAULT)
            self.state = 820
            self.elementValue()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class BlockContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LBRACE(self):
            return self.getToken(JavaParser.LBRACE, 0)

        def RBRACE(self):
            return self.getToken(JavaParser.RBRACE, 0)

        def blockStatement(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.BlockStatementContext)
            else:
                return self.getTypedRuleContext(JavaParser.BlockStatementContext, i)

        def getRuleIndex(self):
            return JavaParser.RULE_block

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterBlock"):
                listener.enterBlock(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitBlock"):
                listener.exitBlock(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitBlock"):
                return visitor.visitBlock(self)
            else:
                return visitor.visitChildren(self)

    def block(self):

        localctx = JavaParser.BlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_block)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 822
            self.match(JavaParser.LBRACE)
            self.state = 826
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (
                ((_la) & ~0x3F) == 0
                and (
                    (1 << _la)
                    & (
                        (1 << JavaParser.ABSTRACT)
                        | (1 << JavaParser.ASSERT)
                        | (1 << JavaParser.BOOLEAN)
                        | (1 << JavaParser.BREAK)
                        | (1 << JavaParser.BYTE)
                        | (1 << JavaParser.CHAR)
                        | (1 << JavaParser.CLASS)
                        | (1 << JavaParser.CONTINUE)
                        | (1 << JavaParser.DO)
                        | (1 << JavaParser.DOUBLE)
                        | (1 << JavaParser.FINAL)
                        | (1 << JavaParser.FLOAT)
                        | (1 << JavaParser.FOR)
                        | (1 << JavaParser.IF)
                        | (1 << JavaParser.INT)
                        | (1 << JavaParser.INTERFACE)
                        | (1 << JavaParser.LONG)
                        | (1 << JavaParser.NEW)
                        | (1 << JavaParser.PRIVATE)
                        | (1 << JavaParser.PROTECTED)
                        | (1 << JavaParser.PUBLIC)
                        | (1 << JavaParser.RETURN)
                        | (1 << JavaParser.SHORT)
                        | (1 << JavaParser.STATIC)
                        | (1 << JavaParser.STRICTFP)
                        | (1 << JavaParser.SUPER)
                        | (1 << JavaParser.SWITCH)
                        | (1 << JavaParser.SYNCHRONIZED)
                        | (1 << JavaParser.THIS)
                        | (1 << JavaParser.THROW)
                        | (1 << JavaParser.TRY)
                        | (1 << JavaParser.VOID)
                        | (1 << JavaParser.WHILE)
                        | (1 << JavaParser.DECIMAL_LITERAL)
                        | (1 << JavaParser.HEX_LITERAL)
                        | (1 << JavaParser.OCT_LITERAL)
                        | (1 << JavaParser.BINARY_LITERAL)
                        | (1 << JavaParser.FLOAT_LITERAL)
                        | (1 << JavaParser.HEX_FLOAT_LITERAL)
                        | (1 << JavaParser.BOOL_LITERAL)
                        | (1 << JavaParser.CHAR_LITERAL)
                        | (1 << JavaParser.STRING_LITERAL)
                        | (1 << JavaParser.NULL_LITERAL)
                        | (1 << JavaParser.LPAREN)
                        | (1 << JavaParser.LBRACE)
                    )
                )
                != 0
            ) or (
                (((_la - 67)) & ~0x3F) == 0
                and (
                    (1 << (_la - 67))
                    & (
                        (1 << (JavaParser.SEMI - 67))
                        | (1 << (JavaParser.LT - 67))
                        | (1 << (JavaParser.BANG - 67))
                        | (1 << (JavaParser.TILDE - 67))
                        | (1 << (JavaParser.INC - 67))
                        | (1 << (JavaParser.DEC - 67))
                        | (1 << (JavaParser.ADD - 67))
                        | (1 << (JavaParser.SUB - 67))
                        | (1 << (JavaParser.AT - 67))
                        | (1 << (JavaParser.IDENTIFIER - 67))
                    )
                )
                != 0
            ):
                self.state = 823
                self.blockStatement()
                self.state = 828
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 829
            self.match(JavaParser.RBRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class BlockStatementContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def localVariableDeclaration(self):
            return self.getTypedRuleContext(JavaParser.LocalVariableDeclarationContext, 0)

        def SEMI(self):
            return self.getToken(JavaParser.SEMI, 0)

        def statement(self):
            return self.getTypedRuleContext(JavaParser.StatementContext, 0)

        def localTypeDeclaration(self):
            return self.getTypedRuleContext(JavaParser.LocalTypeDeclarationContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_blockStatement

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterBlockStatement"):
                listener.enterBlockStatement(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitBlockStatement"):
                listener.exitBlockStatement(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitBlockStatement"):
                return visitor.visitBlockStatement(self)
            else:
                return visitor.visitChildren(self)

    def blockStatement(self):

        localctx = JavaParser.BlockStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_blockStatement)
        try:
            self.state = 836
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 96, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 831
                self.localVariableDeclaration()
                self.state = 832
                self.match(JavaParser.SEMI)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 834
                self.statement()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 835
                self.localTypeDeclaration()
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class LocalVariableDeclarationContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeType(self):
            return self.getTypedRuleContext(JavaParser.TypeTypeContext, 0)

        def variableDeclarators(self):
            return self.getTypedRuleContext(JavaParser.VariableDeclaratorsContext, 0)

        def variableModifier(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.VariableModifierContext)
            else:
                return self.getTypedRuleContext(JavaParser.VariableModifierContext, i)

        def getRuleIndex(self):
            return JavaParser.RULE_localVariableDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterLocalVariableDeclaration"):
                listener.enterLocalVariableDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitLocalVariableDeclaration"):
                listener.exitLocalVariableDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitLocalVariableDeclaration"):
                return visitor.visitLocalVariableDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def localVariableDeclaration(self):

        localctx = JavaParser.LocalVariableDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_localVariableDeclaration)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 841
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input, 97, self._ctx)
            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 838
                    self.variableModifier()
                self.state = 843
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 97, self._ctx)

            self.state = 844
            self.typeType()
            self.state = 845
            self.variableDeclarators()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class LocalTypeDeclarationContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def classDeclaration(self):
            return self.getTypedRuleContext(JavaParser.ClassDeclarationContext, 0)

        def interfaceDeclaration(self):
            return self.getTypedRuleContext(JavaParser.InterfaceDeclarationContext, 0)

        def classOrInterfaceModifier(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.ClassOrInterfaceModifierContext)
            else:
                return self.getTypedRuleContext(JavaParser.ClassOrInterfaceModifierContext, i)

        def SEMI(self):
            return self.getToken(JavaParser.SEMI, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_localTypeDeclaration

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterLocalTypeDeclaration"):
                listener.enterLocalTypeDeclaration(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitLocalTypeDeclaration"):
                listener.exitLocalTypeDeclaration(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitLocalTypeDeclaration"):
                return visitor.visitLocalTypeDeclaration(self)
            else:
                return visitor.visitChildren(self)

    def localTypeDeclaration(self):

        localctx = JavaParser.LocalTypeDeclarationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_localTypeDeclaration)
        self._la = 0  # Token type
        try:
            self.state = 858
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [
                JavaParser.ABSTRACT,
                JavaParser.CLASS,
                JavaParser.FINAL,
                JavaParser.INTERFACE,
                JavaParser.PRIVATE,
                JavaParser.PROTECTED,
                JavaParser.PUBLIC,
                JavaParser.STATIC,
                JavaParser.STRICTFP,
                JavaParser.AT,
                JavaParser.IDENTIFIER,
            ]:
                self.enterOuterAlt(localctx, 1)
                self.state = 850
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (
                    (
                        ((_la) & ~0x3F) == 0
                        and (
                            (1 << _la)
                            & (
                                (1 << JavaParser.ABSTRACT)
                                | (1 << JavaParser.FINAL)
                                | (1 << JavaParser.PRIVATE)
                                | (1 << JavaParser.PROTECTED)
                                | (1 << JavaParser.PUBLIC)
                                | (1 << JavaParser.STATIC)
                                | (1 << JavaParser.STRICTFP)
                            )
                        )
                        != 0
                    )
                    or _la == JavaParser.AT
                    or _la == JavaParser.IDENTIFIER
                ):
                    self.state = 847
                    self.classOrInterfaceModifier()
                    self.state = 852
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 855
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [JavaParser.CLASS]:
                    self.state = 853
                    self.classDeclaration()
                    pass
                elif token in [JavaParser.INTERFACE]:
                    self.state = 854
                    self.interfaceDeclaration()
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            elif token in [JavaParser.SEMI]:
                self.enterOuterAlt(localctx, 2)
                self.state = 857
                self.match(JavaParser.SEMI)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class StatementContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.blockLabel = None  # BlockContext
            self.statementExpression = None  # ExpressionContext
            self.identifierLabel = None  # Token

        def block(self):
            return self.getTypedRuleContext(JavaParser.BlockContext, 0)

        def ASSERT(self):
            return self.getToken(JavaParser.ASSERT, 0)

        def expression(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(JavaParser.ExpressionContext, i)

        def SEMI(self):
            return self.getToken(JavaParser.SEMI, 0)

        def COLON(self):
            return self.getToken(JavaParser.COLON, 0)

        def IF(self):
            return self.getToken(JavaParser.IF, 0)

        def parExpression(self):
            return self.getTypedRuleContext(JavaParser.ParExpressionContext, 0)

        def statement(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.StatementContext)
            else:
                return self.getTypedRuleContext(JavaParser.StatementContext, i)

        def ELSE(self):
            return self.getToken(JavaParser.ELSE, 0)

        def FOR(self):
            return self.getToken(JavaParser.FOR, 0)

        def LPAREN(self):
            return self.getToken(JavaParser.LPAREN, 0)

        def forControl(self):
            return self.getTypedRuleContext(JavaParser.ForControlContext, 0)

        def RPAREN(self):
            return self.getToken(JavaParser.RPAREN, 0)

        def WHILE(self):
            return self.getToken(JavaParser.WHILE, 0)

        def DO(self):
            return self.getToken(JavaParser.DO, 0)

        def TRY(self):
            return self.getToken(JavaParser.TRY, 0)

        def finallyBlock(self):
            return self.getTypedRuleContext(JavaParser.FinallyBlockContext, 0)

        def catchClause(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.CatchClauseContext)
            else:
                return self.getTypedRuleContext(JavaParser.CatchClauseContext, i)

        def resourceSpecification(self):
            return self.getTypedRuleContext(JavaParser.ResourceSpecificationContext, 0)

        def SWITCH(self):
            return self.getToken(JavaParser.SWITCH, 0)

        def LBRACE(self):
            return self.getToken(JavaParser.LBRACE, 0)

        def RBRACE(self):
            return self.getToken(JavaParser.RBRACE, 0)

        def switchBlockStatementGroup(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.SwitchBlockStatementGroupContext)
            else:
                return self.getTypedRuleContext(JavaParser.SwitchBlockStatementGroupContext, i)

        def switchLabel(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.SwitchLabelContext)
            else:
                return self.getTypedRuleContext(JavaParser.SwitchLabelContext, i)

        def SYNCHRONIZED(self):
            return self.getToken(JavaParser.SYNCHRONIZED, 0)

        def RETURN(self):
            return self.getToken(JavaParser.RETURN, 0)

        def THROW(self):
            return self.getToken(JavaParser.THROW, 0)

        def BREAK(self):
            return self.getToken(JavaParser.BREAK, 0)

        def IDENTIFIER(self):
            return self.getToken(JavaParser.IDENTIFIER, 0)

        def CONTINUE(self):
            return self.getToken(JavaParser.CONTINUE, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_statement

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterStatement"):
                listener.enterStatement(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitStatement"):
                listener.exitStatement(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitStatement"):
                return visitor.visitStatement(self)
            else:
                return visitor.visitChildren(self)

    def statement(self):

        localctx = JavaParser.StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_statement)
        self._la = 0  # Token type
        try:
            self.state = 964
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 113, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 860
                localctx.blockLabel = self.block()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 861
                self.match(JavaParser.ASSERT)
                self.state = 862
                self.expression(0)
                self.state = 865
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la == JavaParser.COLON:
                    self.state = 863
                    self.match(JavaParser.COLON)
                    self.state = 864
                    self.expression(0)

                self.state = 867
                self.match(JavaParser.SEMI)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 869
                self.match(JavaParser.IF)
                self.state = 870
                self.parExpression()
                self.state = 871
                self.statement()
                self.state = 874
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input, 102, self._ctx)
                if la_ == 1:
                    self.state = 872
                    self.match(JavaParser.ELSE)
                    self.state = 873
                    self.statement()

                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 876
                self.match(JavaParser.FOR)
                self.state = 877
                self.match(JavaParser.LPAREN)
                self.state = 878
                self.forControl()
                self.state = 879
                self.match(JavaParser.RPAREN)
                self.state = 880
                self.statement()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 882
                self.match(JavaParser.WHILE)
                self.state = 883
                self.parExpression()
                self.state = 884
                self.statement()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 886
                self.match(JavaParser.DO)
                self.state = 887
                self.statement()
                self.state = 888
                self.match(JavaParser.WHILE)
                self.state = 889
                self.parExpression()
                self.state = 890
                self.match(JavaParser.SEMI)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 892
                self.match(JavaParser.TRY)
                self.state = 893
                self.block()
                self.state = 903
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [JavaParser.CATCH]:
                    self.state = 895
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while True:
                        self.state = 894
                        self.catchClause()
                        self.state = 897
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if not (_la == JavaParser.CATCH):
                            break

                    self.state = 900
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la == JavaParser.FINALLY:
                        self.state = 899
                        self.finallyBlock()

                    pass
                elif token in [JavaParser.FINALLY]:
                    self.state = 902
                    self.finallyBlock()
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 905
                self.match(JavaParser.TRY)
                self.state = 906
                self.resourceSpecification()
                self.state = 907
                self.block()
                self.state = 911
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la == JavaParser.CATCH:
                    self.state = 908
                    self.catchClause()
                    self.state = 913
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 915
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la == JavaParser.FINALLY:
                    self.state = 914
                    self.finallyBlock()

                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 917
                self.match(JavaParser.SWITCH)
                self.state = 918
                self.parExpression()
                self.state = 919
                self.match(JavaParser.LBRACE)
                self.state = 923
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 108, self._ctx)
                while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 920
                        self.switchBlockStatementGroup()
                    self.state = 925
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input, 108, self._ctx)

                self.state = 929
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la == JavaParser.CASE or _la == JavaParser.DEFAULT:
                    self.state = 926
                    self.switchLabel()
                    self.state = 931
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 932
                self.match(JavaParser.RBRACE)
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 934
                self.match(JavaParser.SYNCHRONIZED)
                self.state = 935
                self.parExpression()
                self.state = 936
                self.block()
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 938
                self.match(JavaParser.RETURN)
                self.state = 940
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (
                    ((_la) & ~0x3F) == 0
                    and (
                        (1 << _la)
                        & (
                            (1 << JavaParser.BOOLEAN)
                            | (1 << JavaParser.BYTE)
                            | (1 << JavaParser.CHAR)
                            | (1 << JavaParser.DOUBLE)
                            | (1 << JavaParser.FLOAT)
                            | (1 << JavaParser.INT)
                            | (1 << JavaParser.LONG)
                            | (1 << JavaParser.NEW)
                            | (1 << JavaParser.SHORT)
                            | (1 << JavaParser.SUPER)
                            | (1 << JavaParser.THIS)
                            | (1 << JavaParser.VOID)
                            | (1 << JavaParser.DECIMAL_LITERAL)
                            | (1 << JavaParser.HEX_LITERAL)
                            | (1 << JavaParser.OCT_LITERAL)
                            | (1 << JavaParser.BINARY_LITERAL)
                            | (1 << JavaParser.FLOAT_LITERAL)
                            | (1 << JavaParser.HEX_FLOAT_LITERAL)
                            | (1 << JavaParser.BOOL_LITERAL)
                            | (1 << JavaParser.CHAR_LITERAL)
                            | (1 << JavaParser.STRING_LITERAL)
                            | (1 << JavaParser.NULL_LITERAL)
                            | (1 << JavaParser.LPAREN)
                        )
                    )
                    != 0
                ) or (
                    (((_la - 72)) & ~0x3F) == 0
                    and (
                        (1 << (_la - 72))
                        & (
                            (1 << (JavaParser.LT - 72))
                            | (1 << (JavaParser.BANG - 72))
                            | (1 << (JavaParser.TILDE - 72))
                            | (1 << (JavaParser.INC - 72))
                            | (1 << (JavaParser.DEC - 72))
                            | (1 << (JavaParser.ADD - 72))
                            | (1 << (JavaParser.SUB - 72))
                            | (1 << (JavaParser.AT - 72))
                            | (1 << (JavaParser.IDENTIFIER - 72))
                        )
                    )
                    != 0
                ):
                    self.state = 939
                    self.expression(0)

                self.state = 942
                self.match(JavaParser.SEMI)
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 943
                self.match(JavaParser.THROW)
                self.state = 944
                self.expression(0)
                self.state = 945
                self.match(JavaParser.SEMI)
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 947
                self.match(JavaParser.BREAK)
                self.state = 949
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la == JavaParser.IDENTIFIER:
                    self.state = 948
                    self.match(JavaParser.IDENTIFIER)

                self.state = 951
                self.match(JavaParser.SEMI)
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 952
                self.match(JavaParser.CONTINUE)
                self.state = 954
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la == JavaParser.IDENTIFIER:
                    self.state = 953
                    self.match(JavaParser.IDENTIFIER)

                self.state = 956
                self.match(JavaParser.SEMI)
                pass

            elif la_ == 15:
                self.enterOuterAlt(localctx, 15)
                self.state = 957
                self.match(JavaParser.SEMI)
                pass

            elif la_ == 16:
                self.enterOuterAlt(localctx, 16)
                self.state = 958
                localctx.statementExpression = self.expression(0)
                self.state = 959
                self.match(JavaParser.SEMI)
                pass

            elif la_ == 17:
                self.enterOuterAlt(localctx, 17)
                self.state = 961
                localctx.identifierLabel = self.match(JavaParser.IDENTIFIER)
                self.state = 962
                self.match(JavaParser.COLON)
                self.state = 963
                self.statement()
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class CatchClauseContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CATCH(self):
            return self.getToken(JavaParser.CATCH, 0)

        def LPAREN(self):
            return self.getToken(JavaParser.LPAREN, 0)

        def catchType(self):
            return self.getTypedRuleContext(JavaParser.CatchTypeContext, 0)

        def IDENTIFIER(self):
            return self.getToken(JavaParser.IDENTIFIER, 0)

        def RPAREN(self):
            return self.getToken(JavaParser.RPAREN, 0)

        def block(self):
            return self.getTypedRuleContext(JavaParser.BlockContext, 0)

        def variableModifier(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.VariableModifierContext)
            else:
                return self.getTypedRuleContext(JavaParser.VariableModifierContext, i)

        def getRuleIndex(self):
            return JavaParser.RULE_catchClause

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCatchClause"):
                listener.enterCatchClause(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCatchClause"):
                listener.exitCatchClause(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitCatchClause"):
                return visitor.visitCatchClause(self)
            else:
                return visitor.visitChildren(self)

    def catchClause(self):

        localctx = JavaParser.CatchClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_catchClause)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 966
            self.match(JavaParser.CATCH)
            self.state = 967
            self.match(JavaParser.LPAREN)
            self.state = 971
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input, 114, self._ctx)
            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 968
                    self.variableModifier()
                self.state = 973
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 114, self._ctx)

            self.state = 974
            self.catchType()
            self.state = 975
            self.match(JavaParser.IDENTIFIER)
            self.state = 976
            self.match(JavaParser.RPAREN)
            self.state = 977
            self.block()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class CatchTypeContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def qualifiedName(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.QualifiedNameContext)
            else:
                return self.getTypedRuleContext(JavaParser.QualifiedNameContext, i)

        def BITOR(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.BITOR)
            else:
                return self.getToken(JavaParser.BITOR, i)

        def getRuleIndex(self):
            return JavaParser.RULE_catchType

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCatchType"):
                listener.enterCatchType(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCatchType"):
                listener.exitCatchType(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitCatchType"):
                return visitor.visitCatchType(self)
            else:
                return visitor.visitChildren(self)

    def catchType(self):

        localctx = JavaParser.CatchTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_catchType)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 979
            self.qualifiedName()
            self.state = 984
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == JavaParser.BITOR:
                self.state = 980
                self.match(JavaParser.BITOR)
                self.state = 981
                self.qualifiedName()
                self.state = 986
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class FinallyBlockContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def FINALLY(self):
            return self.getToken(JavaParser.FINALLY, 0)

        def block(self):
            return self.getTypedRuleContext(JavaParser.BlockContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_finallyBlock

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterFinallyBlock"):
                listener.enterFinallyBlock(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitFinallyBlock"):
                listener.exitFinallyBlock(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitFinallyBlock"):
                return visitor.visitFinallyBlock(self)
            else:
                return visitor.visitChildren(self)

    def finallyBlock(self):

        localctx = JavaParser.FinallyBlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_finallyBlock)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 987
            self.match(JavaParser.FINALLY)
            self.state = 988
            self.block()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ResourceSpecificationContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LPAREN(self):
            return self.getToken(JavaParser.LPAREN, 0)

        def resources(self):
            return self.getTypedRuleContext(JavaParser.ResourcesContext, 0)

        def RPAREN(self):
            return self.getToken(JavaParser.RPAREN, 0)

        def SEMI(self):
            return self.getToken(JavaParser.SEMI, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_resourceSpecification

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterResourceSpecification"):
                listener.enterResourceSpecification(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitResourceSpecification"):
                listener.exitResourceSpecification(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitResourceSpecification"):
                return visitor.visitResourceSpecification(self)
            else:
                return visitor.visitChildren(self)

    def resourceSpecification(self):

        localctx = JavaParser.ResourceSpecificationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_resourceSpecification)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 990
            self.match(JavaParser.LPAREN)
            self.state = 991
            self.resources()
            self.state = 993
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == JavaParser.SEMI:
                self.state = 992
                self.match(JavaParser.SEMI)

            self.state = 995
            self.match(JavaParser.RPAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ResourcesContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def resource(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.ResourceContext)
            else:
                return self.getTypedRuleContext(JavaParser.ResourceContext, i)

        def SEMI(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.SEMI)
            else:
                return self.getToken(JavaParser.SEMI, i)

        def getRuleIndex(self):
            return JavaParser.RULE_resources

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterResources"):
                listener.enterResources(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitResources"):
                listener.exitResources(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitResources"):
                return visitor.visitResources(self)
            else:
                return visitor.visitChildren(self)

    def resources(self):

        localctx = JavaParser.ResourcesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_resources)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 997
            self.resource()
            self.state = 1002
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input, 117, self._ctx)
            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 998
                    self.match(JavaParser.SEMI)
                    self.state = 999
                    self.resource()
                self.state = 1004
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 117, self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ResourceContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def classOrInterfaceType(self):
            return self.getTypedRuleContext(JavaParser.ClassOrInterfaceTypeContext, 0)

        def variableDeclaratorId(self):
            return self.getTypedRuleContext(JavaParser.VariableDeclaratorIdContext, 0)

        def ASSIGN(self):
            return self.getToken(JavaParser.ASSIGN, 0)

        def expression(self):
            return self.getTypedRuleContext(JavaParser.ExpressionContext, 0)

        def variableModifier(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.VariableModifierContext)
            else:
                return self.getTypedRuleContext(JavaParser.VariableModifierContext, i)

        def getRuleIndex(self):
            return JavaParser.RULE_resource

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterResource"):
                listener.enterResource(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitResource"):
                listener.exitResource(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitResource"):
                return visitor.visitResource(self)
            else:
                return visitor.visitChildren(self)

    def resource(self):

        localctx = JavaParser.ResourceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_resource)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1008
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input, 118, self._ctx)
            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1005
                    self.variableModifier()
                self.state = 1010
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 118, self._ctx)

            self.state = 1011
            self.classOrInterfaceType()
            self.state = 1012
            self.variableDeclaratorId()
            self.state = 1013
            self.match(JavaParser.ASSIGN)
            self.state = 1014
            self.expression(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class SwitchBlockStatementGroupContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def switchLabel(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.SwitchLabelContext)
            else:
                return self.getTypedRuleContext(JavaParser.SwitchLabelContext, i)

        def blockStatement(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.BlockStatementContext)
            else:
                return self.getTypedRuleContext(JavaParser.BlockStatementContext, i)

        def getRuleIndex(self):
            return JavaParser.RULE_switchBlockStatementGroup

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterSwitchBlockStatementGroup"):
                listener.enterSwitchBlockStatementGroup(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitSwitchBlockStatementGroup"):
                listener.exitSwitchBlockStatementGroup(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitSwitchBlockStatementGroup"):
                return visitor.visitSwitchBlockStatementGroup(self)
            else:
                return visitor.visitChildren(self)

    def switchBlockStatementGroup(self):

        localctx = JavaParser.SwitchBlockStatementGroupContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_switchBlockStatementGroup)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1017
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1016
                self.switchLabel()
                self.state = 1019
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la == JavaParser.CASE or _la == JavaParser.DEFAULT):
                    break

            self.state = 1022
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 1021
                self.blockStatement()
                self.state = 1024
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (
                    (
                        ((_la) & ~0x3F) == 0
                        and (
                            (1 << _la)
                            & (
                                (1 << JavaParser.ABSTRACT)
                                | (1 << JavaParser.ASSERT)
                                | (1 << JavaParser.BOOLEAN)
                                | (1 << JavaParser.BREAK)
                                | (1 << JavaParser.BYTE)
                                | (1 << JavaParser.CHAR)
                                | (1 << JavaParser.CLASS)
                                | (1 << JavaParser.CONTINUE)
                                | (1 << JavaParser.DO)
                                | (1 << JavaParser.DOUBLE)
                                | (1 << JavaParser.FINAL)
                                | (1 << JavaParser.FLOAT)
                                | (1 << JavaParser.FOR)
                                | (1 << JavaParser.IF)
                                | (1 << JavaParser.INT)
                                | (1 << JavaParser.INTERFACE)
                                | (1 << JavaParser.LONG)
                                | (1 << JavaParser.NEW)
                                | (1 << JavaParser.PRIVATE)
                                | (1 << JavaParser.PROTECTED)
                                | (1 << JavaParser.PUBLIC)
                                | (1 << JavaParser.RETURN)
                                | (1 << JavaParser.SHORT)
                                | (1 << JavaParser.STATIC)
                                | (1 << JavaParser.STRICTFP)
                                | (1 << JavaParser.SUPER)
                                | (1 << JavaParser.SWITCH)
                                | (1 << JavaParser.SYNCHRONIZED)
                                | (1 << JavaParser.THIS)
                                | (1 << JavaParser.THROW)
                                | (1 << JavaParser.TRY)
                                | (1 << JavaParser.VOID)
                                | (1 << JavaParser.WHILE)
                                | (1 << JavaParser.DECIMAL_LITERAL)
                                | (1 << JavaParser.HEX_LITERAL)
                                | (1 << JavaParser.OCT_LITERAL)
                                | (1 << JavaParser.BINARY_LITERAL)
                                | (1 << JavaParser.FLOAT_LITERAL)
                                | (1 << JavaParser.HEX_FLOAT_LITERAL)
                                | (1 << JavaParser.BOOL_LITERAL)
                                | (1 << JavaParser.CHAR_LITERAL)
                                | (1 << JavaParser.STRING_LITERAL)
                                | (1 << JavaParser.NULL_LITERAL)
                                | (1 << JavaParser.LPAREN)
                                | (1 << JavaParser.LBRACE)
                            )
                        )
                        != 0
                    )
                    or (
                        (((_la - 67)) & ~0x3F) == 0
                        and (
                            (1 << (_la - 67))
                            & (
                                (1 << (JavaParser.SEMI - 67))
                                | (1 << (JavaParser.LT - 67))
                                | (1 << (JavaParser.BANG - 67))
                                | (1 << (JavaParser.TILDE - 67))
                                | (1 << (JavaParser.INC - 67))
                                | (1 << (JavaParser.DEC - 67))
                                | (1 << (JavaParser.ADD - 67))
                                | (1 << (JavaParser.SUB - 67))
                                | (1 << (JavaParser.AT - 67))
                                | (1 << (JavaParser.IDENTIFIER - 67))
                            )
                        )
                        != 0
                    )
                ):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class SwitchLabelContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.constantExpression = None  # ExpressionContext
            self.enumConstantName = None  # Token

        def CASE(self):
            return self.getToken(JavaParser.CASE, 0)

        def COLON(self):
            return self.getToken(JavaParser.COLON, 0)

        def expression(self):
            return self.getTypedRuleContext(JavaParser.ExpressionContext, 0)

        def IDENTIFIER(self):
            return self.getToken(JavaParser.IDENTIFIER, 0)

        def DEFAULT(self):
            return self.getToken(JavaParser.DEFAULT, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_switchLabel

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterSwitchLabel"):
                listener.enterSwitchLabel(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitSwitchLabel"):
                listener.exitSwitchLabel(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitSwitchLabel"):
                return visitor.visitSwitchLabel(self)
            else:
                return visitor.visitChildren(self)

    def switchLabel(self):

        localctx = JavaParser.SwitchLabelContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_switchLabel)
        try:
            self.state = 1034
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [JavaParser.CASE]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1026
                self.match(JavaParser.CASE)
                self.state = 1029
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input, 121, self._ctx)
                if la_ == 1:
                    self.state = 1027
                    localctx.constantExpression = self.expression(0)
                    pass

                elif la_ == 2:
                    self.state = 1028
                    localctx.enumConstantName = self.match(JavaParser.IDENTIFIER)
                    pass

                self.state = 1031
                self.match(JavaParser.COLON)
                pass
            elif token in [JavaParser.DEFAULT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1032
                self.match(JavaParser.DEFAULT)
                self.state = 1033
                self.match(JavaParser.COLON)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ForControlContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.forUpdate = None  # ExpressionListContext

        def enhancedForControl(self):
            return self.getTypedRuleContext(JavaParser.EnhancedForControlContext, 0)

        def SEMI(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.SEMI)
            else:
                return self.getToken(JavaParser.SEMI, i)

        def forInit(self):
            return self.getTypedRuleContext(JavaParser.ForInitContext, 0)

        def expression(self):
            return self.getTypedRuleContext(JavaParser.ExpressionContext, 0)

        def expressionList(self):
            return self.getTypedRuleContext(JavaParser.ExpressionListContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_forControl

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterForControl"):
                listener.enterForControl(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitForControl"):
                listener.exitForControl(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitForControl"):
                return visitor.visitForControl(self)
            else:
                return visitor.visitChildren(self)

    def forControl(self):

        localctx = JavaParser.ForControlContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_forControl)
        self._la = 0  # Token type
        try:
            self.state = 1048
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 126, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1036
                self.enhancedForControl()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1038
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (
                    ((_la) & ~0x3F) == 0
                    and (
                        (1 << _la)
                        & (
                            (1 << JavaParser.BOOLEAN)
                            | (1 << JavaParser.BYTE)
                            | (1 << JavaParser.CHAR)
                            | (1 << JavaParser.DOUBLE)
                            | (1 << JavaParser.FINAL)
                            | (1 << JavaParser.FLOAT)
                            | (1 << JavaParser.INT)
                            | (1 << JavaParser.LONG)
                            | (1 << JavaParser.NEW)
                            | (1 << JavaParser.SHORT)
                            | (1 << JavaParser.SUPER)
                            | (1 << JavaParser.THIS)
                            | (1 << JavaParser.VOID)
                            | (1 << JavaParser.DECIMAL_LITERAL)
                            | (1 << JavaParser.HEX_LITERAL)
                            | (1 << JavaParser.OCT_LITERAL)
                            | (1 << JavaParser.BINARY_LITERAL)
                            | (1 << JavaParser.FLOAT_LITERAL)
                            | (1 << JavaParser.HEX_FLOAT_LITERAL)
                            | (1 << JavaParser.BOOL_LITERAL)
                            | (1 << JavaParser.CHAR_LITERAL)
                            | (1 << JavaParser.STRING_LITERAL)
                            | (1 << JavaParser.NULL_LITERAL)
                            | (1 << JavaParser.LPAREN)
                        )
                    )
                    != 0
                ) or (
                    (((_la - 72)) & ~0x3F) == 0
                    and (
                        (1 << (_la - 72))
                        & (
                            (1 << (JavaParser.LT - 72))
                            | (1 << (JavaParser.BANG - 72))
                            | (1 << (JavaParser.TILDE - 72))
                            | (1 << (JavaParser.INC - 72))
                            | (1 << (JavaParser.DEC - 72))
                            | (1 << (JavaParser.ADD - 72))
                            | (1 << (JavaParser.SUB - 72))
                            | (1 << (JavaParser.AT - 72))
                            | (1 << (JavaParser.IDENTIFIER - 72))
                        )
                    )
                    != 0
                ):
                    self.state = 1037
                    self.forInit()

                self.state = 1040
                self.match(JavaParser.SEMI)
                self.state = 1042
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (
                    ((_la) & ~0x3F) == 0
                    and (
                        (1 << _la)
                        & (
                            (1 << JavaParser.BOOLEAN)
                            | (1 << JavaParser.BYTE)
                            | (1 << JavaParser.CHAR)
                            | (1 << JavaParser.DOUBLE)
                            | (1 << JavaParser.FLOAT)
                            | (1 << JavaParser.INT)
                            | (1 << JavaParser.LONG)
                            | (1 << JavaParser.NEW)
                            | (1 << JavaParser.SHORT)
                            | (1 << JavaParser.SUPER)
                            | (1 << JavaParser.THIS)
                            | (1 << JavaParser.VOID)
                            | (1 << JavaParser.DECIMAL_LITERAL)
                            | (1 << JavaParser.HEX_LITERAL)
                            | (1 << JavaParser.OCT_LITERAL)
                            | (1 << JavaParser.BINARY_LITERAL)
                            | (1 << JavaParser.FLOAT_LITERAL)
                            | (1 << JavaParser.HEX_FLOAT_LITERAL)
                            | (1 << JavaParser.BOOL_LITERAL)
                            | (1 << JavaParser.CHAR_LITERAL)
                            | (1 << JavaParser.STRING_LITERAL)
                            | (1 << JavaParser.NULL_LITERAL)
                            | (1 << JavaParser.LPAREN)
                        )
                    )
                    != 0
                ) or (
                    (((_la - 72)) & ~0x3F) == 0
                    and (
                        (1 << (_la - 72))
                        & (
                            (1 << (JavaParser.LT - 72))
                            | (1 << (JavaParser.BANG - 72))
                            | (1 << (JavaParser.TILDE - 72))
                            | (1 << (JavaParser.INC - 72))
                            | (1 << (JavaParser.DEC - 72))
                            | (1 << (JavaParser.ADD - 72))
                            | (1 << (JavaParser.SUB - 72))
                            | (1 << (JavaParser.AT - 72))
                            | (1 << (JavaParser.IDENTIFIER - 72))
                        )
                    )
                    != 0
                ):
                    self.state = 1041
                    self.expression(0)

                self.state = 1044
                self.match(JavaParser.SEMI)
                self.state = 1046
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (
                    ((_la) & ~0x3F) == 0
                    and (
                        (1 << _la)
                        & (
                            (1 << JavaParser.BOOLEAN)
                            | (1 << JavaParser.BYTE)
                            | (1 << JavaParser.CHAR)
                            | (1 << JavaParser.DOUBLE)
                            | (1 << JavaParser.FLOAT)
                            | (1 << JavaParser.INT)
                            | (1 << JavaParser.LONG)
                            | (1 << JavaParser.NEW)
                            | (1 << JavaParser.SHORT)
                            | (1 << JavaParser.SUPER)
                            | (1 << JavaParser.THIS)
                            | (1 << JavaParser.VOID)
                            | (1 << JavaParser.DECIMAL_LITERAL)
                            | (1 << JavaParser.HEX_LITERAL)
                            | (1 << JavaParser.OCT_LITERAL)
                            | (1 << JavaParser.BINARY_LITERAL)
                            | (1 << JavaParser.FLOAT_LITERAL)
                            | (1 << JavaParser.HEX_FLOAT_LITERAL)
                            | (1 << JavaParser.BOOL_LITERAL)
                            | (1 << JavaParser.CHAR_LITERAL)
                            | (1 << JavaParser.STRING_LITERAL)
                            | (1 << JavaParser.NULL_LITERAL)
                            | (1 << JavaParser.LPAREN)
                        )
                    )
                    != 0
                ) or (
                    (((_la - 72)) & ~0x3F) == 0
                    and (
                        (1 << (_la - 72))
                        & (
                            (1 << (JavaParser.LT - 72))
                            | (1 << (JavaParser.BANG - 72))
                            | (1 << (JavaParser.TILDE - 72))
                            | (1 << (JavaParser.INC - 72))
                            | (1 << (JavaParser.DEC - 72))
                            | (1 << (JavaParser.ADD - 72))
                            | (1 << (JavaParser.SUB - 72))
                            | (1 << (JavaParser.AT - 72))
                            | (1 << (JavaParser.IDENTIFIER - 72))
                        )
                    )
                    != 0
                ):
                    self.state = 1045
                    localctx.forUpdate = self.expressionList()

                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ForInitContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def localVariableDeclaration(self):
            return self.getTypedRuleContext(JavaParser.LocalVariableDeclarationContext, 0)

        def expressionList(self):
            return self.getTypedRuleContext(JavaParser.ExpressionListContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_forInit

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterForInit"):
                listener.enterForInit(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitForInit"):
                listener.exitForInit(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitForInit"):
                return visitor.visitForInit(self)
            else:
                return visitor.visitChildren(self)

    def forInit(self):

        localctx = JavaParser.ForInitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_forInit)
        try:
            self.state = 1052
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 127, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1050
                self.localVariableDeclaration()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1051
                self.expressionList()
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class EnhancedForControlContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeType(self):
            return self.getTypedRuleContext(JavaParser.TypeTypeContext, 0)

        def variableDeclaratorId(self):
            return self.getTypedRuleContext(JavaParser.VariableDeclaratorIdContext, 0)

        def COLON(self):
            return self.getToken(JavaParser.COLON, 0)

        def expression(self):
            return self.getTypedRuleContext(JavaParser.ExpressionContext, 0)

        def variableModifier(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.VariableModifierContext)
            else:
                return self.getTypedRuleContext(JavaParser.VariableModifierContext, i)

        def getRuleIndex(self):
            return JavaParser.RULE_enhancedForControl

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterEnhancedForControl"):
                listener.enterEnhancedForControl(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitEnhancedForControl"):
                listener.exitEnhancedForControl(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitEnhancedForControl"):
                return visitor.visitEnhancedForControl(self)
            else:
                return visitor.visitChildren(self)

    def enhancedForControl(self):

        localctx = JavaParser.EnhancedForControlContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_enhancedForControl)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1057
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input, 128, self._ctx)
            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1054
                    self.variableModifier()
                self.state = 1059
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 128, self._ctx)

            self.state = 1060
            self.typeType()
            self.state = 1061
            self.variableDeclaratorId()
            self.state = 1062
            self.match(JavaParser.COLON)
            self.state = 1063
            self.expression(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ParExpressionContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LPAREN(self):
            return self.getToken(JavaParser.LPAREN, 0)

        def expression(self):
            return self.getTypedRuleContext(JavaParser.ExpressionContext, 0)

        def RPAREN(self):
            return self.getToken(JavaParser.RPAREN, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_parExpression

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterParExpression"):
                listener.enterParExpression(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitParExpression"):
                listener.exitParExpression(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitParExpression"):
                return visitor.visitParExpression(self)
            else:
                return visitor.visitChildren(self)

    def parExpression(self):

        localctx = JavaParser.ParExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_parExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1065
            self.match(JavaParser.LPAREN)
            self.state = 1066
            self.expression(0)
            self.state = 1067
            self.match(JavaParser.RPAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ExpressionListContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(JavaParser.ExpressionContext, i)

        def COMMA(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.COMMA)
            else:
                return self.getToken(JavaParser.COMMA, i)

        def getRuleIndex(self):
            return JavaParser.RULE_expressionList

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterExpressionList"):
                listener.enterExpressionList(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitExpressionList"):
                listener.exitExpressionList(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitExpressionList"):
                return visitor.visitExpressionList(self)
            else:
                return visitor.visitChildren(self)

    def expressionList(self):

        localctx = JavaParser.ExpressionListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_expressionList)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1069
            self.expression(0)
            self.state = 1074
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == JavaParser.COMMA:
                self.state = 1070
                self.match(JavaParser.COMMA)
                self.state = 1071
                self.expression(0)
                self.state = 1076
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class MethodCallContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def IDENTIFIER(self):
            return self.getToken(JavaParser.IDENTIFIER, 0)

        def LPAREN(self):
            return self.getToken(JavaParser.LPAREN, 0)

        def RPAREN(self):
            return self.getToken(JavaParser.RPAREN, 0)

        def expressionList(self):
            return self.getTypedRuleContext(JavaParser.ExpressionListContext, 0)

        def THIS(self):
            return self.getToken(JavaParser.THIS, 0)

        def SUPER(self):
            return self.getToken(JavaParser.SUPER, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_methodCall

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterMethodCall"):
                listener.enterMethodCall(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitMethodCall"):
                listener.exitMethodCall(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitMethodCall"):
                return visitor.visitMethodCall(self)
            else:
                return visitor.visitChildren(self)

    def methodCall(self):

        localctx = JavaParser.MethodCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_methodCall)
        self._la = 0  # Token type
        try:
            self.state = 1095
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [JavaParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1077
                self.match(JavaParser.IDENTIFIER)
                self.state = 1078
                self.match(JavaParser.LPAREN)
                self.state = 1080
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (
                    ((_la) & ~0x3F) == 0
                    and (
                        (1 << _la)
                        & (
                            (1 << JavaParser.BOOLEAN)
                            | (1 << JavaParser.BYTE)
                            | (1 << JavaParser.CHAR)
                            | (1 << JavaParser.DOUBLE)
                            | (1 << JavaParser.FLOAT)
                            | (1 << JavaParser.INT)
                            | (1 << JavaParser.LONG)
                            | (1 << JavaParser.NEW)
                            | (1 << JavaParser.SHORT)
                            | (1 << JavaParser.SUPER)
                            | (1 << JavaParser.THIS)
                            | (1 << JavaParser.VOID)
                            | (1 << JavaParser.DECIMAL_LITERAL)
                            | (1 << JavaParser.HEX_LITERAL)
                            | (1 << JavaParser.OCT_LITERAL)
                            | (1 << JavaParser.BINARY_LITERAL)
                            | (1 << JavaParser.FLOAT_LITERAL)
                            | (1 << JavaParser.HEX_FLOAT_LITERAL)
                            | (1 << JavaParser.BOOL_LITERAL)
                            | (1 << JavaParser.CHAR_LITERAL)
                            | (1 << JavaParser.STRING_LITERAL)
                            | (1 << JavaParser.NULL_LITERAL)
                            | (1 << JavaParser.LPAREN)
                        )
                    )
                    != 0
                ) or (
                    (((_la - 72)) & ~0x3F) == 0
                    and (
                        (1 << (_la - 72))
                        & (
                            (1 << (JavaParser.LT - 72))
                            | (1 << (JavaParser.BANG - 72))
                            | (1 << (JavaParser.TILDE - 72))
                            | (1 << (JavaParser.INC - 72))
                            | (1 << (JavaParser.DEC - 72))
                            | (1 << (JavaParser.ADD - 72))
                            | (1 << (JavaParser.SUB - 72))
                            | (1 << (JavaParser.AT - 72))
                            | (1 << (JavaParser.IDENTIFIER - 72))
                        )
                    )
                    != 0
                ):
                    self.state = 1079
                    self.expressionList()

                self.state = 1082
                self.match(JavaParser.RPAREN)
                pass
            elif token in [JavaParser.THIS]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1083
                self.match(JavaParser.THIS)
                self.state = 1084
                self.match(JavaParser.LPAREN)
                self.state = 1086
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (
                    ((_la) & ~0x3F) == 0
                    and (
                        (1 << _la)
                        & (
                            (1 << JavaParser.BOOLEAN)
                            | (1 << JavaParser.BYTE)
                            | (1 << JavaParser.CHAR)
                            | (1 << JavaParser.DOUBLE)
                            | (1 << JavaParser.FLOAT)
                            | (1 << JavaParser.INT)
                            | (1 << JavaParser.LONG)
                            | (1 << JavaParser.NEW)
                            | (1 << JavaParser.SHORT)
                            | (1 << JavaParser.SUPER)
                            | (1 << JavaParser.THIS)
                            | (1 << JavaParser.VOID)
                            | (1 << JavaParser.DECIMAL_LITERAL)
                            | (1 << JavaParser.HEX_LITERAL)
                            | (1 << JavaParser.OCT_LITERAL)
                            | (1 << JavaParser.BINARY_LITERAL)
                            | (1 << JavaParser.FLOAT_LITERAL)
                            | (1 << JavaParser.HEX_FLOAT_LITERAL)
                            | (1 << JavaParser.BOOL_LITERAL)
                            | (1 << JavaParser.CHAR_LITERAL)
                            | (1 << JavaParser.STRING_LITERAL)
                            | (1 << JavaParser.NULL_LITERAL)
                            | (1 << JavaParser.LPAREN)
                        )
                    )
                    != 0
                ) or (
                    (((_la - 72)) & ~0x3F) == 0
                    and (
                        (1 << (_la - 72))
                        & (
                            (1 << (JavaParser.LT - 72))
                            | (1 << (JavaParser.BANG - 72))
                            | (1 << (JavaParser.TILDE - 72))
                            | (1 << (JavaParser.INC - 72))
                            | (1 << (JavaParser.DEC - 72))
                            | (1 << (JavaParser.ADD - 72))
                            | (1 << (JavaParser.SUB - 72))
                            | (1 << (JavaParser.AT - 72))
                            | (1 << (JavaParser.IDENTIFIER - 72))
                        )
                    )
                    != 0
                ):
                    self.state = 1085
                    self.expressionList()

                self.state = 1088
                self.match(JavaParser.RPAREN)
                pass
            elif token in [JavaParser.SUPER]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1089
                self.match(JavaParser.SUPER)
                self.state = 1090
                self.match(JavaParser.LPAREN)
                self.state = 1092
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (
                    ((_la) & ~0x3F) == 0
                    and (
                        (1 << _la)
                        & (
                            (1 << JavaParser.BOOLEAN)
                            | (1 << JavaParser.BYTE)
                            | (1 << JavaParser.CHAR)
                            | (1 << JavaParser.DOUBLE)
                            | (1 << JavaParser.FLOAT)
                            | (1 << JavaParser.INT)
                            | (1 << JavaParser.LONG)
                            | (1 << JavaParser.NEW)
                            | (1 << JavaParser.SHORT)
                            | (1 << JavaParser.SUPER)
                            | (1 << JavaParser.THIS)
                            | (1 << JavaParser.VOID)
                            | (1 << JavaParser.DECIMAL_LITERAL)
                            | (1 << JavaParser.HEX_LITERAL)
                            | (1 << JavaParser.OCT_LITERAL)
                            | (1 << JavaParser.BINARY_LITERAL)
                            | (1 << JavaParser.FLOAT_LITERAL)
                            | (1 << JavaParser.HEX_FLOAT_LITERAL)
                            | (1 << JavaParser.BOOL_LITERAL)
                            | (1 << JavaParser.CHAR_LITERAL)
                            | (1 << JavaParser.STRING_LITERAL)
                            | (1 << JavaParser.NULL_LITERAL)
                            | (1 << JavaParser.LPAREN)
                        )
                    )
                    != 0
                ) or (
                    (((_la - 72)) & ~0x3F) == 0
                    and (
                        (1 << (_la - 72))
                        & (
                            (1 << (JavaParser.LT - 72))
                            | (1 << (JavaParser.BANG - 72))
                            | (1 << (JavaParser.TILDE - 72))
                            | (1 << (JavaParser.INC - 72))
                            | (1 << (JavaParser.DEC - 72))
                            | (1 << (JavaParser.ADD - 72))
                            | (1 << (JavaParser.SUB - 72))
                            | (1 << (JavaParser.AT - 72))
                            | (1 << (JavaParser.IDENTIFIER - 72))
                        )
                    )
                    != 0
                ):
                    self.state = 1091
                    self.expressionList()

                self.state = 1094
                self.match(JavaParser.RPAREN)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ExpressionContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.prefix = None  # Token
            self.bop = None  # Token
            self.postfix = None  # Token

        def primary(self):
            return self.getTypedRuleContext(JavaParser.PrimaryContext, 0)

        def methodCall(self):
            return self.getTypedRuleContext(JavaParser.MethodCallContext, 0)

        def NEW(self):
            return self.getToken(JavaParser.NEW, 0)

        def creator(self):
            return self.getTypedRuleContext(JavaParser.CreatorContext, 0)

        def LPAREN(self):
            return self.getToken(JavaParser.LPAREN, 0)

        def typeType(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.TypeTypeContext)
            else:
                return self.getTypedRuleContext(JavaParser.TypeTypeContext, i)

        def RPAREN(self):
            return self.getToken(JavaParser.RPAREN, 0)

        def expression(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(JavaParser.ExpressionContext, i)

        def annotation(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.AnnotationContext)
            else:
                return self.getTypedRuleContext(JavaParser.AnnotationContext, i)

        def BITAND(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.BITAND)
            else:
                return self.getToken(JavaParser.BITAND, i)

        def ADD(self):
            return self.getToken(JavaParser.ADD, 0)

        def SUB(self):
            return self.getToken(JavaParser.SUB, 0)

        def INC(self):
            return self.getToken(JavaParser.INC, 0)

        def DEC(self):
            return self.getToken(JavaParser.DEC, 0)

        def TILDE(self):
            return self.getToken(JavaParser.TILDE, 0)

        def BANG(self):
            return self.getToken(JavaParser.BANG, 0)

        def lambdaExpression(self):
            return self.getTypedRuleContext(JavaParser.LambdaExpressionContext, 0)

        def COLONCOLON(self):
            return self.getToken(JavaParser.COLONCOLON, 0)

        def IDENTIFIER(self):
            return self.getToken(JavaParser.IDENTIFIER, 0)

        def typeArguments(self):
            return self.getTypedRuleContext(JavaParser.TypeArgumentsContext, 0)

        def classType(self):
            return self.getTypedRuleContext(JavaParser.ClassTypeContext, 0)

        def MUL(self):
            return self.getToken(JavaParser.MUL, 0)

        def DIV(self):
            return self.getToken(JavaParser.DIV, 0)

        def MOD(self):
            return self.getToken(JavaParser.MOD, 0)

        def LT(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.LT)
            else:
                return self.getToken(JavaParser.LT, i)

        def GT(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.GT)
            else:
                return self.getToken(JavaParser.GT, i)

        def LE(self):
            return self.getToken(JavaParser.LE, 0)

        def GE(self):
            return self.getToken(JavaParser.GE, 0)

        def EQUAL(self):
            return self.getToken(JavaParser.EQUAL, 0)

        def NOTEQUAL(self):
            return self.getToken(JavaParser.NOTEQUAL, 0)

        def CARET(self):
            return self.getToken(JavaParser.CARET, 0)

        def BITOR(self):
            return self.getToken(JavaParser.BITOR, 0)

        def AND(self):
            return self.getToken(JavaParser.AND, 0)

        def OR(self):
            return self.getToken(JavaParser.OR, 0)

        def COLON(self):
            return self.getToken(JavaParser.COLON, 0)

        def QUESTION(self):
            return self.getToken(JavaParser.QUESTION, 0)

        def ASSIGN(self):
            return self.getToken(JavaParser.ASSIGN, 0)

        def ADD_ASSIGN(self):
            return self.getToken(JavaParser.ADD_ASSIGN, 0)

        def SUB_ASSIGN(self):
            return self.getToken(JavaParser.SUB_ASSIGN, 0)

        def MUL_ASSIGN(self):
            return self.getToken(JavaParser.MUL_ASSIGN, 0)

        def DIV_ASSIGN(self):
            return self.getToken(JavaParser.DIV_ASSIGN, 0)

        def AND_ASSIGN(self):
            return self.getToken(JavaParser.AND_ASSIGN, 0)

        def OR_ASSIGN(self):
            return self.getToken(JavaParser.OR_ASSIGN, 0)

        def XOR_ASSIGN(self):
            return self.getToken(JavaParser.XOR_ASSIGN, 0)

        def RSHIFT_ASSIGN(self):
            return self.getToken(JavaParser.RSHIFT_ASSIGN, 0)

        def URSHIFT_ASSIGN(self):
            return self.getToken(JavaParser.URSHIFT_ASSIGN, 0)

        def LSHIFT_ASSIGN(self):
            return self.getToken(JavaParser.LSHIFT_ASSIGN, 0)

        def MOD_ASSIGN(self):
            return self.getToken(JavaParser.MOD_ASSIGN, 0)

        def DOT(self):
            return self.getToken(JavaParser.DOT, 0)

        def THIS(self):
            return self.getToken(JavaParser.THIS, 0)

        def innerCreator(self):
            return self.getTypedRuleContext(JavaParser.InnerCreatorContext, 0)

        def SUPER(self):
            return self.getToken(JavaParser.SUPER, 0)

        def superSuffix(self):
            return self.getTypedRuleContext(JavaParser.SuperSuffixContext, 0)

        def explicitGenericInvocation(self):
            return self.getTypedRuleContext(JavaParser.ExplicitGenericInvocationContext, 0)

        def nonWildcardTypeArguments(self):
            return self.getTypedRuleContext(JavaParser.NonWildcardTypeArgumentsContext, 0)

        def LBRACK(self):
            return self.getToken(JavaParser.LBRACK, 0)

        def RBRACK(self):
            return self.getToken(JavaParser.RBRACK, 0)

        def INSTANCEOF(self):
            return self.getToken(JavaParser.INSTANCEOF, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_expression

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterExpression"):
                listener.enterExpression(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitExpression"):
                listener.exitExpression(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitExpression"):
                return visitor.visitExpression(self)
            else:
                return visitor.visitChildren(self)

    def expression(self, _p: int = 0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = JavaParser.ExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 166
        self.enterRecursionRule(localctx, 166, self.RULE_expression, _p)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1141
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 139, self._ctx)
            if la_ == 1:
                self.state = 1098
                self.primary()
                pass

            elif la_ == 2:
                self.state = 1099
                self.methodCall()
                pass

            elif la_ == 3:
                self.state = 1100
                self.match(JavaParser.NEW)
                self.state = 1101
                self.creator()
                pass

            elif la_ == 4:
                self.state = 1102
                self.match(JavaParser.LPAREN)
                self.state = 1106
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 134, self._ctx)
                while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 1103
                        self.annotation()
                    self.state = 1108
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input, 134, self._ctx)

                self.state = 1109
                self.typeType()
                self.state = 1114
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la == JavaParser.BITAND:
                    self.state = 1110
                    self.match(JavaParser.BITAND)
                    self.state = 1111
                    self.typeType()
                    self.state = 1116
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1117
                self.match(JavaParser.RPAREN)
                self.state = 1118
                self.expression(21)
                pass

            elif la_ == 5:
                self.state = 1120
                localctx.prefix = self._input.LT(1)
                _la = self._input.LA(1)
                if not (
                    (
                        (((_la - 83)) & ~0x3F) == 0
                        and (
                            (1 << (_la - 83))
                            & (
                                (1 << (JavaParser.INC - 83))
                                | (1 << (JavaParser.DEC - 83))
                                | (1 << (JavaParser.ADD - 83))
                                | (1 << (JavaParser.SUB - 83))
                            )
                        )
                        != 0
                    )
                ):
                    localctx.prefix = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1121
                self.expression(19)
                pass

            elif la_ == 6:
                self.state = 1122
                localctx.prefix = self._input.LT(1)
                _la = self._input.LA(1)
                if not (_la == JavaParser.BANG or _la == JavaParser.TILDE):
                    localctx.prefix = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1123
                self.expression(18)
                pass

            elif la_ == 7:
                self.state = 1124
                self.lambdaExpression()
                pass

            elif la_ == 8:
                self.state = 1125
                self.typeType()
                self.state = 1126
                self.match(JavaParser.COLONCOLON)
                self.state = 1132
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [JavaParser.LT, JavaParser.IDENTIFIER]:
                    self.state = 1128
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la == JavaParser.LT:
                        self.state = 1127
                        self.typeArguments()

                    self.state = 1130
                    self.match(JavaParser.IDENTIFIER)
                    pass
                elif token in [JavaParser.NEW]:
                    self.state = 1131
                    self.match(JavaParser.NEW)
                    pass
                else:
                    raise NoViableAltException(self)

                pass

            elif la_ == 9:
                self.state = 1134
                self.classType()
                self.state = 1135
                self.match(JavaParser.COLONCOLON)
                self.state = 1137
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la == JavaParser.LT:
                    self.state = 1136
                    self.typeArguments()

                self.state = 1139
                self.match(JavaParser.NEW)
                pass

            self._ctx.stop = self._input.LT(-1)
            self.state = 1223
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input, 145, self._ctx)
            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    self.state = 1221
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input, 144, self._ctx)
                    if la_ == 1:
                        localctx = JavaParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1143
                        if not self.precpred(self._ctx, 17):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(self, "self.precpred(self._ctx, 17)")
                        self.state = 1144
                        localctx.bop = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not (
                            (
                                (((_la - 87)) & ~0x3F) == 0
                                and (
                                    (1 << (_la - 87))
                                    & (
                                        (1 << (JavaParser.MUL - 87))
                                        | (1 << (JavaParser.DIV - 87))
                                        | (1 << (JavaParser.MOD - 87))
                                    )
                                )
                                != 0
                            )
                        ):
                            localctx.bop = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1145
                        self.expression(18)
                        pass

                    elif la_ == 2:
                        localctx = JavaParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1146
                        if not self.precpred(self._ctx, 16):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(self, "self.precpred(self._ctx, 16)")
                        self.state = 1147
                        localctx.bop = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not (_la == JavaParser.ADD or _la == JavaParser.SUB):
                            localctx.bop = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1148
                        self.expression(17)
                        pass

                    elif la_ == 3:
                        localctx = JavaParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1149
                        if not self.precpred(self._ctx, 15):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(self, "self.precpred(self._ctx, 15)")
                        self.state = 1157
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input, 140, self._ctx)
                        if la_ == 1:
                            self.state = 1150
                            self.match(JavaParser.LT)
                            self.state = 1151
                            self.match(JavaParser.LT)
                            pass

                        elif la_ == 2:
                            self.state = 1152
                            self.match(JavaParser.GT)
                            self.state = 1153
                            self.match(JavaParser.GT)
                            self.state = 1154
                            self.match(JavaParser.GT)
                            pass

                        elif la_ == 3:
                            self.state = 1155
                            self.match(JavaParser.GT)
                            self.state = 1156
                            self.match(JavaParser.GT)
                            pass

                        self.state = 1159
                        self.expression(16)
                        pass

                    elif la_ == 4:
                        localctx = JavaParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1160
                        if not self.precpred(self._ctx, 14):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(self, "self.precpred(self._ctx, 14)")
                        self.state = 1161
                        localctx.bop = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not (
                            (
                                (((_la - 71)) & ~0x3F) == 0
                                and (
                                    (1 << (_la - 71))
                                    & (
                                        (1 << (JavaParser.GT - 71))
                                        | (1 << (JavaParser.LT - 71))
                                        | (1 << (JavaParser.LE - 71))
                                        | (1 << (JavaParser.GE - 71))
                                    )
                                )
                                != 0
                            )
                        ):
                            localctx.bop = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1162
                        self.expression(15)
                        pass

                    elif la_ == 5:
                        localctx = JavaParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1163
                        if not self.precpred(self._ctx, 12):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(self, "self.precpred(self._ctx, 12)")
                        self.state = 1164
                        localctx.bop = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not (_la == JavaParser.EQUAL or _la == JavaParser.NOTEQUAL):
                            localctx.bop = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1165
                        self.expression(13)
                        pass

                    elif la_ == 6:
                        localctx = JavaParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1166
                        if not self.precpred(self._ctx, 11):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(self, "self.precpred(self._ctx, 11)")
                        self.state = 1167
                        localctx.bop = self.match(JavaParser.BITAND)
                        self.state = 1168
                        self.expression(12)
                        pass

                    elif la_ == 7:
                        localctx = JavaParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1169
                        if not self.precpred(self._ctx, 10):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(self, "self.precpred(self._ctx, 10)")
                        self.state = 1170
                        localctx.bop = self.match(JavaParser.CARET)
                        self.state = 1171
                        self.expression(11)
                        pass

                    elif la_ == 8:
                        localctx = JavaParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1172
                        if not self.precpred(self._ctx, 9):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(self, "self.precpred(self._ctx, 9)")
                        self.state = 1173
                        localctx.bop = self.match(JavaParser.BITOR)
                        self.state = 1174
                        self.expression(10)
                        pass

                    elif la_ == 9:
                        localctx = JavaParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1175
                        if not self.precpred(self._ctx, 8):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
                        self.state = 1176
                        localctx.bop = self.match(JavaParser.AND)
                        self.state = 1177
                        self.expression(9)
                        pass

                    elif la_ == 10:
                        localctx = JavaParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1178
                        if not self.precpred(self._ctx, 7):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(self, "self.precpred(self._ctx, 7)")
                        self.state = 1179
                        localctx.bop = self.match(JavaParser.OR)
                        self.state = 1180
                        self.expression(8)
                        pass

                    elif la_ == 11:
                        localctx = JavaParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1181
                        if not self.precpred(self._ctx, 6):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
                        self.state = 1182
                        localctx.bop = self.match(JavaParser.QUESTION)
                        self.state = 1183
                        self.expression(0)
                        self.state = 1184
                        self.match(JavaParser.COLON)
                        self.state = 1185
                        self.expression(6)
                        pass

                    elif la_ == 12:
                        localctx = JavaParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1187
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 1188
                        localctx.bop = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not (
                            (
                                (((_la - 70)) & ~0x3F) == 0
                                and (
                                    (1 << (_la - 70))
                                    & (
                                        (1 << (JavaParser.ASSIGN - 70))
                                        | (1 << (JavaParser.ADD_ASSIGN - 70))
                                        | (1 << (JavaParser.SUB_ASSIGN - 70))
                                        | (1 << (JavaParser.MUL_ASSIGN - 70))
                                        | (1 << (JavaParser.DIV_ASSIGN - 70))
                                        | (1 << (JavaParser.AND_ASSIGN - 70))
                                        | (1 << (JavaParser.OR_ASSIGN - 70))
                                        | (1 << (JavaParser.XOR_ASSIGN - 70))
                                        | (1 << (JavaParser.MOD_ASSIGN - 70))
                                        | (1 << (JavaParser.LSHIFT_ASSIGN - 70))
                                        | (1 << (JavaParser.RSHIFT_ASSIGN - 70))
                                        | (1 << (JavaParser.URSHIFT_ASSIGN - 70))
                                    )
                                )
                                != 0
                            )
                        ):
                            localctx.bop = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 1189
                        self.expression(5)
                        pass

                    elif la_ == 13:
                        localctx = JavaParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1190
                        if not self.precpred(self._ctx, 25):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(self, "self.precpred(self._ctx, 25)")
                        self.state = 1191
                        localctx.bop = self.match(JavaParser.DOT)
                        self.state = 1203
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input, 142, self._ctx)
                        if la_ == 1:
                            self.state = 1192
                            self.match(JavaParser.IDENTIFIER)
                            pass

                        elif la_ == 2:
                            self.state = 1193
                            self.methodCall()
                            pass

                        elif la_ == 3:
                            self.state = 1194
                            self.match(JavaParser.THIS)
                            pass

                        elif la_ == 4:
                            self.state = 1195
                            self.match(JavaParser.NEW)
                            self.state = 1197
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)
                            if _la == JavaParser.LT:
                                self.state = 1196
                                self.nonWildcardTypeArguments()

                            self.state = 1199
                            self.innerCreator()
                            pass

                        elif la_ == 5:
                            self.state = 1200
                            self.match(JavaParser.SUPER)
                            self.state = 1201
                            self.superSuffix()
                            pass

                        elif la_ == 6:
                            self.state = 1202
                            self.explicitGenericInvocation()
                            pass

                        pass

                    elif la_ == 14:
                        localctx = JavaParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1205
                        if not self.precpred(self._ctx, 24):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(self, "self.precpred(self._ctx, 24)")
                        self.state = 1206
                        self.match(JavaParser.LBRACK)
                        self.state = 1207
                        self.expression(0)
                        self.state = 1208
                        self.match(JavaParser.RBRACK)
                        pass

                    elif la_ == 15:
                        localctx = JavaParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1210
                        if not self.precpred(self._ctx, 20):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(self, "self.precpred(self._ctx, 20)")
                        self.state = 1211
                        localctx.postfix = self._input.LT(1)
                        _la = self._input.LA(1)
                        if not (_la == JavaParser.INC or _la == JavaParser.DEC):
                            localctx.postfix = self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        pass

                    elif la_ == 16:
                        localctx = JavaParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1212
                        if not self.precpred(self._ctx, 13):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(self, "self.precpred(self._ctx, 13)")
                        self.state = 1213
                        localctx.bop = self.match(JavaParser.INSTANCEOF)
                        self.state = 1214
                        self.typeType()
                        pass

                    elif la_ == 17:
                        localctx = JavaParser.ExpressionContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                        self.state = 1215
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException

                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 1216
                        self.match(JavaParser.COLONCOLON)
                        self.state = 1218
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la == JavaParser.LT:
                            self.state = 1217
                            self.typeArguments()

                        self.state = 1220
                        self.match(JavaParser.IDENTIFIER)
                        pass

                self.state = 1225
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 145, self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.unrollRecursionContexts(_parentctx)
        return localctx

    class LambdaExpressionContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def lambdaParameters(self):
            return self.getTypedRuleContext(JavaParser.LambdaParametersContext, 0)

        def ARROW(self):
            return self.getToken(JavaParser.ARROW, 0)

        def lambdaBody(self):
            return self.getTypedRuleContext(JavaParser.LambdaBodyContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_lambdaExpression

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterLambdaExpression"):
                listener.enterLambdaExpression(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitLambdaExpression"):
                listener.exitLambdaExpression(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitLambdaExpression"):
                return visitor.visitLambdaExpression(self)
            else:
                return visitor.visitChildren(self)

    def lambdaExpression(self):

        localctx = JavaParser.LambdaExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_lambdaExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1226
            self.lambdaParameters()
            self.state = 1227
            self.match(JavaParser.ARROW)
            self.state = 1228
            self.lambdaBody()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class LambdaParametersContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def IDENTIFIER(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.IDENTIFIER)
            else:
                return self.getToken(JavaParser.IDENTIFIER, i)

        def LPAREN(self):
            return self.getToken(JavaParser.LPAREN, 0)

        def RPAREN(self):
            return self.getToken(JavaParser.RPAREN, 0)

        def formalParameterList(self):
            return self.getTypedRuleContext(JavaParser.FormalParameterListContext, 0)

        def COMMA(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.COMMA)
            else:
                return self.getToken(JavaParser.COMMA, i)

        def getRuleIndex(self):
            return JavaParser.RULE_lambdaParameters

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterLambdaParameters"):
                listener.enterLambdaParameters(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitLambdaParameters"):
                listener.exitLambdaParameters(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitLambdaParameters"):
                return visitor.visitLambdaParameters(self)
            else:
                return visitor.visitChildren(self)

    def lambdaParameters(self):

        localctx = JavaParser.LambdaParametersContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_lambdaParameters)
        self._la = 0  # Token type
        try:
            self.state = 1246
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 148, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1230
                self.match(JavaParser.IDENTIFIER)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1231
                self.match(JavaParser.LPAREN)
                self.state = 1233
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (
                    (
                        ((_la) & ~0x3F) == 0
                        and (
                            (1 << _la)
                            & (
                                (1 << JavaParser.BOOLEAN)
                                | (1 << JavaParser.BYTE)
                                | (1 << JavaParser.CHAR)
                                | (1 << JavaParser.DOUBLE)
                                | (1 << JavaParser.FINAL)
                                | (1 << JavaParser.FLOAT)
                                | (1 << JavaParser.INT)
                                | (1 << JavaParser.LONG)
                                | (1 << JavaParser.SHORT)
                            )
                        )
                        != 0
                    )
                    or _la == JavaParser.AT
                    or _la == JavaParser.IDENTIFIER
                ):
                    self.state = 1232
                    self.formalParameterList()

                self.state = 1235
                self.match(JavaParser.RPAREN)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1236
                self.match(JavaParser.LPAREN)
                self.state = 1237
                self.match(JavaParser.IDENTIFIER)
                self.state = 1242
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la == JavaParser.COMMA:
                    self.state = 1238
                    self.match(JavaParser.COMMA)
                    self.state = 1239
                    self.match(JavaParser.IDENTIFIER)
                    self.state = 1244
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1245
                self.match(JavaParser.RPAREN)
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class LambdaBodyContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def expression(self):
            return self.getTypedRuleContext(JavaParser.ExpressionContext, 0)

        def block(self):
            return self.getTypedRuleContext(JavaParser.BlockContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_lambdaBody

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterLambdaBody"):
                listener.enterLambdaBody(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitLambdaBody"):
                listener.exitLambdaBody(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitLambdaBody"):
                return visitor.visitLambdaBody(self)
            else:
                return visitor.visitChildren(self)

    def lambdaBody(self):

        localctx = JavaParser.LambdaBodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_lambdaBody)
        try:
            self.state = 1250
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [
                JavaParser.BOOLEAN,
                JavaParser.BYTE,
                JavaParser.CHAR,
                JavaParser.DOUBLE,
                JavaParser.FLOAT,
                JavaParser.INT,
                JavaParser.LONG,
                JavaParser.NEW,
                JavaParser.SHORT,
                JavaParser.SUPER,
                JavaParser.THIS,
                JavaParser.VOID,
                JavaParser.DECIMAL_LITERAL,
                JavaParser.HEX_LITERAL,
                JavaParser.OCT_LITERAL,
                JavaParser.BINARY_LITERAL,
                JavaParser.FLOAT_LITERAL,
                JavaParser.HEX_FLOAT_LITERAL,
                JavaParser.BOOL_LITERAL,
                JavaParser.CHAR_LITERAL,
                JavaParser.STRING_LITERAL,
                JavaParser.NULL_LITERAL,
                JavaParser.LPAREN,
                JavaParser.LT,
                JavaParser.BANG,
                JavaParser.TILDE,
                JavaParser.INC,
                JavaParser.DEC,
                JavaParser.ADD,
                JavaParser.SUB,
                JavaParser.AT,
                JavaParser.IDENTIFIER,
            ]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1248
                self.expression(0)
                pass
            elif token in [JavaParser.LBRACE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1249
                self.block()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class PrimaryContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LPAREN(self):
            return self.getToken(JavaParser.LPAREN, 0)

        def expression(self):
            return self.getTypedRuleContext(JavaParser.ExpressionContext, 0)

        def RPAREN(self):
            return self.getToken(JavaParser.RPAREN, 0)

        def THIS(self):
            return self.getToken(JavaParser.THIS, 0)

        def SUPER(self):
            return self.getToken(JavaParser.SUPER, 0)

        def literal(self):
            return self.getTypedRuleContext(JavaParser.LiteralContext, 0)

        def IDENTIFIER(self):
            return self.getToken(JavaParser.IDENTIFIER, 0)

        def typeTypeOrVoid(self):
            return self.getTypedRuleContext(JavaParser.TypeTypeOrVoidContext, 0)

        def DOT(self):
            return self.getToken(JavaParser.DOT, 0)

        def CLASS(self):
            return self.getToken(JavaParser.CLASS, 0)

        def nonWildcardTypeArguments(self):
            return self.getTypedRuleContext(JavaParser.NonWildcardTypeArgumentsContext, 0)

        def explicitGenericInvocationSuffix(self):
            return self.getTypedRuleContext(JavaParser.ExplicitGenericInvocationSuffixContext, 0)

        def arguments(self):
            return self.getTypedRuleContext(JavaParser.ArgumentsContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_primary

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterPrimary"):
                listener.enterPrimary(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitPrimary"):
                listener.exitPrimary(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitPrimary"):
                return visitor.visitPrimary(self)
            else:
                return visitor.visitChildren(self)

    def primary(self):

        localctx = JavaParser.PrimaryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_primary)
        try:
            self.state = 1270
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 151, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1252
                self.match(JavaParser.LPAREN)
                self.state = 1253
                self.expression(0)
                self.state = 1254
                self.match(JavaParser.RPAREN)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1256
                self.match(JavaParser.THIS)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1257
                self.match(JavaParser.SUPER)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1258
                self.literal()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1259
                self.match(JavaParser.IDENTIFIER)
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1260
                self.typeTypeOrVoid()
                self.state = 1261
                self.match(JavaParser.DOT)
                self.state = 1262
                self.match(JavaParser.CLASS)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1264
                self.nonWildcardTypeArguments()
                self.state = 1268
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [JavaParser.SUPER, JavaParser.IDENTIFIER]:
                    self.state = 1265
                    self.explicitGenericInvocationSuffix()
                    pass
                elif token in [JavaParser.THIS]:
                    self.state = 1266
                    self.match(JavaParser.THIS)
                    self.state = 1267
                    self.arguments()
                    pass
                else:
                    raise NoViableAltException(self)

                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ClassTypeContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def IDENTIFIER(self):
            return self.getToken(JavaParser.IDENTIFIER, 0)

        def classOrInterfaceType(self):
            return self.getTypedRuleContext(JavaParser.ClassOrInterfaceTypeContext, 0)

        def DOT(self):
            return self.getToken(JavaParser.DOT, 0)

        def annotation(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.AnnotationContext)
            else:
                return self.getTypedRuleContext(JavaParser.AnnotationContext, i)

        def typeArguments(self):
            return self.getTypedRuleContext(JavaParser.TypeArgumentsContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_classType

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterClassType"):
                listener.enterClassType(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitClassType"):
                listener.exitClassType(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitClassType"):
                return visitor.visitClassType(self)
            else:
                return visitor.visitChildren(self)

    def classType(self):

        localctx = JavaParser.ClassTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_classType)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1275
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 152, self._ctx)
            if la_ == 1:
                self.state = 1272
                self.classOrInterfaceType()
                self.state = 1273
                self.match(JavaParser.DOT)

            self.state = 1280
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input, 153, self._ctx)
            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1277
                    self.annotation()
                self.state = 1282
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 153, self._ctx)

            self.state = 1283
            self.match(JavaParser.IDENTIFIER)
            self.state = 1285
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == JavaParser.LT:
                self.state = 1284
                self.typeArguments()

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class CreatorContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def nonWildcardTypeArguments(self):
            return self.getTypedRuleContext(JavaParser.NonWildcardTypeArgumentsContext, 0)

        def createdName(self):
            return self.getTypedRuleContext(JavaParser.CreatedNameContext, 0)

        def classCreatorRest(self):
            return self.getTypedRuleContext(JavaParser.ClassCreatorRestContext, 0)

        def arrayCreatorRest(self):
            return self.getTypedRuleContext(JavaParser.ArrayCreatorRestContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_creator

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCreator"):
                listener.enterCreator(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCreator"):
                listener.exitCreator(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitCreator"):
                return visitor.visitCreator(self)
            else:
                return visitor.visitChildren(self)

    def creator(self):

        localctx = JavaParser.CreatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 178, self.RULE_creator)
        try:
            self.state = 1296
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [JavaParser.LT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1287
                self.nonWildcardTypeArguments()
                self.state = 1288
                self.createdName()
                self.state = 1289
                self.classCreatorRest()
                pass
            elif token in [
                JavaParser.BOOLEAN,
                JavaParser.BYTE,
                JavaParser.CHAR,
                JavaParser.DOUBLE,
                JavaParser.FLOAT,
                JavaParser.INT,
                JavaParser.LONG,
                JavaParser.SHORT,
                JavaParser.IDENTIFIER,
            ]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1291
                self.createdName()
                self.state = 1294
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [JavaParser.LBRACK]:
                    self.state = 1292
                    self.arrayCreatorRest()
                    pass
                elif token in [JavaParser.LPAREN]:
                    self.state = 1293
                    self.classCreatorRest()
                    pass
                else:
                    raise NoViableAltException(self)

                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class CreatedNameContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def IDENTIFIER(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.IDENTIFIER)
            else:
                return self.getToken(JavaParser.IDENTIFIER, i)

        def typeArgumentsOrDiamond(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.TypeArgumentsOrDiamondContext)
            else:
                return self.getTypedRuleContext(JavaParser.TypeArgumentsOrDiamondContext, i)

        def DOT(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.DOT)
            else:
                return self.getToken(JavaParser.DOT, i)

        def primitiveType(self):
            return self.getTypedRuleContext(JavaParser.PrimitiveTypeContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_createdName

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterCreatedName"):
                listener.enterCreatedName(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitCreatedName"):
                listener.exitCreatedName(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitCreatedName"):
                return visitor.visitCreatedName(self)
            else:
                return visitor.visitChildren(self)

    def createdName(self):

        localctx = JavaParser.CreatedNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 180, self.RULE_createdName)
        self._la = 0  # Token type
        try:
            self.state = 1313
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [JavaParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1298
                self.match(JavaParser.IDENTIFIER)
                self.state = 1300
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la == JavaParser.LT:
                    self.state = 1299
                    self.typeArgumentsOrDiamond()

                self.state = 1309
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la == JavaParser.DOT:
                    self.state = 1302
                    self.match(JavaParser.DOT)
                    self.state = 1303
                    self.match(JavaParser.IDENTIFIER)
                    self.state = 1305
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la == JavaParser.LT:
                        self.state = 1304
                        self.typeArgumentsOrDiamond()

                    self.state = 1311
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [
                JavaParser.BOOLEAN,
                JavaParser.BYTE,
                JavaParser.CHAR,
                JavaParser.DOUBLE,
                JavaParser.FLOAT,
                JavaParser.INT,
                JavaParser.LONG,
                JavaParser.SHORT,
            ]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1312
                self.primitiveType()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class InnerCreatorContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def IDENTIFIER(self):
            return self.getToken(JavaParser.IDENTIFIER, 0)

        def classCreatorRest(self):
            return self.getTypedRuleContext(JavaParser.ClassCreatorRestContext, 0)

        def nonWildcardTypeArgumentsOrDiamond(self):
            return self.getTypedRuleContext(JavaParser.NonWildcardTypeArgumentsOrDiamondContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_innerCreator

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterInnerCreator"):
                listener.enterInnerCreator(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitInnerCreator"):
                listener.exitInnerCreator(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitInnerCreator"):
                return visitor.visitInnerCreator(self)
            else:
                return visitor.visitChildren(self)

    def innerCreator(self):

        localctx = JavaParser.InnerCreatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 182, self.RULE_innerCreator)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1315
            self.match(JavaParser.IDENTIFIER)
            self.state = 1317
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la == JavaParser.LT:
                self.state = 1316
                self.nonWildcardTypeArgumentsOrDiamond()

            self.state = 1319
            self.classCreatorRest()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ArrayCreatorRestContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LBRACK(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.LBRACK)
            else:
                return self.getToken(JavaParser.LBRACK, i)

        def RBRACK(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.RBRACK)
            else:
                return self.getToken(JavaParser.RBRACK, i)

        def arrayInitializer(self):
            return self.getTypedRuleContext(JavaParser.ArrayInitializerContext, 0)

        def expression(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(JavaParser.ExpressionContext, i)

        def getRuleIndex(self):
            return JavaParser.RULE_arrayCreatorRest

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterArrayCreatorRest"):
                listener.enterArrayCreatorRest(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitArrayCreatorRest"):
                listener.exitArrayCreatorRest(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitArrayCreatorRest"):
                return visitor.visitArrayCreatorRest(self)
            else:
                return visitor.visitChildren(self)

    def arrayCreatorRest(self):

        localctx = JavaParser.ArrayCreatorRestContext(self, self._ctx, self.state)
        self.enterRule(localctx, 184, self.RULE_arrayCreatorRest)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1321
            self.match(JavaParser.LBRACK)
            self.state = 1349
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [JavaParser.RBRACK]:
                self.state = 1322
                self.match(JavaParser.RBRACK)
                self.state = 1327
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la == JavaParser.LBRACK:
                    self.state = 1323
                    self.match(JavaParser.LBRACK)
                    self.state = 1324
                    self.match(JavaParser.RBRACK)
                    self.state = 1329
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 1330
                self.arrayInitializer()
                pass
            elif token in [
                JavaParser.BOOLEAN,
                JavaParser.BYTE,
                JavaParser.CHAR,
                JavaParser.DOUBLE,
                JavaParser.FLOAT,
                JavaParser.INT,
                JavaParser.LONG,
                JavaParser.NEW,
                JavaParser.SHORT,
                JavaParser.SUPER,
                JavaParser.THIS,
                JavaParser.VOID,
                JavaParser.DECIMAL_LITERAL,
                JavaParser.HEX_LITERAL,
                JavaParser.OCT_LITERAL,
                JavaParser.BINARY_LITERAL,
                JavaParser.FLOAT_LITERAL,
                JavaParser.HEX_FLOAT_LITERAL,
                JavaParser.BOOL_LITERAL,
                JavaParser.CHAR_LITERAL,
                JavaParser.STRING_LITERAL,
                JavaParser.NULL_LITERAL,
                JavaParser.LPAREN,
                JavaParser.LT,
                JavaParser.BANG,
                JavaParser.TILDE,
                JavaParser.INC,
                JavaParser.DEC,
                JavaParser.ADD,
                JavaParser.SUB,
                JavaParser.AT,
                JavaParser.IDENTIFIER,
            ]:
                self.state = 1331
                self.expression(0)
                self.state = 1332
                self.match(JavaParser.RBRACK)
                self.state = 1339
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 163, self._ctx)
                while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 1333
                        self.match(JavaParser.LBRACK)
                        self.state = 1334
                        self.expression(0)
                        self.state = 1335
                        self.match(JavaParser.RBRACK)
                    self.state = 1341
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input, 163, self._ctx)

                self.state = 1346
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 164, self._ctx)
                while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 1342
                        self.match(JavaParser.LBRACK)
                        self.state = 1343
                        self.match(JavaParser.RBRACK)
                    self.state = 1348
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input, 164, self._ctx)

                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ClassCreatorRestContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def arguments(self):
            return self.getTypedRuleContext(JavaParser.ArgumentsContext, 0)

        def classBody(self):
            return self.getTypedRuleContext(JavaParser.ClassBodyContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_classCreatorRest

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterClassCreatorRest"):
                listener.enterClassCreatorRest(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitClassCreatorRest"):
                listener.exitClassCreatorRest(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitClassCreatorRest"):
                return visitor.visitClassCreatorRest(self)
            else:
                return visitor.visitChildren(self)

    def classCreatorRest(self):

        localctx = JavaParser.ClassCreatorRestContext(self, self._ctx, self.state)
        self.enterRule(localctx, 186, self.RULE_classCreatorRest)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1351
            self.arguments()
            self.state = 1353
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 166, self._ctx)
            if la_ == 1:
                self.state = 1352
                self.classBody()

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ExplicitGenericInvocationContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def nonWildcardTypeArguments(self):
            return self.getTypedRuleContext(JavaParser.NonWildcardTypeArgumentsContext, 0)

        def explicitGenericInvocationSuffix(self):
            return self.getTypedRuleContext(JavaParser.ExplicitGenericInvocationSuffixContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_explicitGenericInvocation

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterExplicitGenericInvocation"):
                listener.enterExplicitGenericInvocation(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitExplicitGenericInvocation"):
                listener.exitExplicitGenericInvocation(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitExplicitGenericInvocation"):
                return visitor.visitExplicitGenericInvocation(self)
            else:
                return visitor.visitChildren(self)

    def explicitGenericInvocation(self):

        localctx = JavaParser.ExplicitGenericInvocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 188, self.RULE_explicitGenericInvocation)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1355
            self.nonWildcardTypeArguments()
            self.state = 1356
            self.explicitGenericInvocationSuffix()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class TypeArgumentsOrDiamondContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LT(self):
            return self.getToken(JavaParser.LT, 0)

        def GT(self):
            return self.getToken(JavaParser.GT, 0)

        def typeArguments(self):
            return self.getTypedRuleContext(JavaParser.TypeArgumentsContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_typeArgumentsOrDiamond

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterTypeArgumentsOrDiamond"):
                listener.enterTypeArgumentsOrDiamond(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitTypeArgumentsOrDiamond"):
                listener.exitTypeArgumentsOrDiamond(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitTypeArgumentsOrDiamond"):
                return visitor.visitTypeArgumentsOrDiamond(self)
            else:
                return visitor.visitChildren(self)

    def typeArgumentsOrDiamond(self):

        localctx = JavaParser.TypeArgumentsOrDiamondContext(self, self._ctx, self.state)
        self.enterRule(localctx, 190, self.RULE_typeArgumentsOrDiamond)
        try:
            self.state = 1361
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 167, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1358
                self.match(JavaParser.LT)
                self.state = 1359
                self.match(JavaParser.GT)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1360
                self.typeArguments()
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class NonWildcardTypeArgumentsOrDiamondContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LT(self):
            return self.getToken(JavaParser.LT, 0)

        def GT(self):
            return self.getToken(JavaParser.GT, 0)

        def nonWildcardTypeArguments(self):
            return self.getTypedRuleContext(JavaParser.NonWildcardTypeArgumentsContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_nonWildcardTypeArgumentsOrDiamond

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterNonWildcardTypeArgumentsOrDiamond"):
                listener.enterNonWildcardTypeArgumentsOrDiamond(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitNonWildcardTypeArgumentsOrDiamond"):
                listener.exitNonWildcardTypeArgumentsOrDiamond(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitNonWildcardTypeArgumentsOrDiamond"):
                return visitor.visitNonWildcardTypeArgumentsOrDiamond(self)
            else:
                return visitor.visitChildren(self)

    def nonWildcardTypeArgumentsOrDiamond(self):

        localctx = JavaParser.NonWildcardTypeArgumentsOrDiamondContext(self, self._ctx, self.state)
        self.enterRule(localctx, 192, self.RULE_nonWildcardTypeArgumentsOrDiamond)
        try:
            self.state = 1366
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input, 168, self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1363
                self.match(JavaParser.LT)
                self.state = 1364
                self.match(JavaParser.GT)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1365
                self.nonWildcardTypeArguments()
                pass

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class NonWildcardTypeArgumentsContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LT(self):
            return self.getToken(JavaParser.LT, 0)

        def typeList(self):
            return self.getTypedRuleContext(JavaParser.TypeListContext, 0)

        def GT(self):
            return self.getToken(JavaParser.GT, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_nonWildcardTypeArguments

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterNonWildcardTypeArguments"):
                listener.enterNonWildcardTypeArguments(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitNonWildcardTypeArguments"):
                listener.exitNonWildcardTypeArguments(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitNonWildcardTypeArguments"):
                return visitor.visitNonWildcardTypeArguments(self)
            else:
                return visitor.visitChildren(self)

    def nonWildcardTypeArguments(self):

        localctx = JavaParser.NonWildcardTypeArgumentsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 194, self.RULE_nonWildcardTypeArguments)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1368
            self.match(JavaParser.LT)
            self.state = 1369
            self.typeList()
            self.state = 1370
            self.match(JavaParser.GT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class TypeListContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def typeType(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.TypeTypeContext)
            else:
                return self.getTypedRuleContext(JavaParser.TypeTypeContext, i)

        def COMMA(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.COMMA)
            else:
                return self.getToken(JavaParser.COMMA, i)

        def getRuleIndex(self):
            return JavaParser.RULE_typeList

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterTypeList"):
                listener.enterTypeList(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitTypeList"):
                listener.exitTypeList(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitTypeList"):
                return visitor.visitTypeList(self)
            else:
                return visitor.visitChildren(self)

    def typeList(self):

        localctx = JavaParser.TypeListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 196, self.RULE_typeList)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1372
            self.typeType()
            self.state = 1377
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == JavaParser.COMMA:
                self.state = 1373
                self.match(JavaParser.COMMA)
                self.state = 1374
                self.typeType()
                self.state = 1379
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class TypeTypeContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def classOrInterfaceType(self):
            return self.getTypedRuleContext(JavaParser.ClassOrInterfaceTypeContext, 0)

        def primitiveType(self):
            return self.getTypedRuleContext(JavaParser.PrimitiveTypeContext, 0)

        def annotation(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.AnnotationContext)
            else:
                return self.getTypedRuleContext(JavaParser.AnnotationContext, i)

        def LBRACK(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.LBRACK)
            else:
                return self.getToken(JavaParser.LBRACK, i)

        def RBRACK(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.RBRACK)
            else:
                return self.getToken(JavaParser.RBRACK, i)

        def getRuleIndex(self):
            return JavaParser.RULE_typeType

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterTypeType"):
                listener.enterTypeType(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitTypeType"):
                listener.exitTypeType(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitTypeType"):
                return visitor.visitTypeType(self)
            else:
                return visitor.visitChildren(self)

    def typeType(self):

        localctx = JavaParser.TypeTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 198, self.RULE_typeType)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1383
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input, 170, self._ctx)
            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1380
                    self.annotation()
                self.state = 1385
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 170, self._ctx)

            self.state = 1388
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [JavaParser.IDENTIFIER]:
                self.state = 1386
                self.classOrInterfaceType()
                pass
            elif token in [
                JavaParser.BOOLEAN,
                JavaParser.BYTE,
                JavaParser.CHAR,
                JavaParser.DOUBLE,
                JavaParser.FLOAT,
                JavaParser.INT,
                JavaParser.LONG,
                JavaParser.SHORT,
            ]:
                self.state = 1387
                self.primitiveType()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 1400
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input, 173, self._ctx)
            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1393
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la == JavaParser.AT or _la == JavaParser.IDENTIFIER:
                        self.state = 1390
                        self.annotation()
                        self.state = 1395
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 1396
                    self.match(JavaParser.LBRACK)
                    self.state = 1397
                    self.match(JavaParser.RBRACK)
                self.state = 1402
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input, 173, self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class PrimitiveTypeContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def BOOLEAN(self):
            return self.getToken(JavaParser.BOOLEAN, 0)

        def CHAR(self):
            return self.getToken(JavaParser.CHAR, 0)

        def BYTE(self):
            return self.getToken(JavaParser.BYTE, 0)

        def SHORT(self):
            return self.getToken(JavaParser.SHORT, 0)

        def INT(self):
            return self.getToken(JavaParser.INT, 0)

        def LONG(self):
            return self.getToken(JavaParser.LONG, 0)

        def FLOAT(self):
            return self.getToken(JavaParser.FLOAT, 0)

        def DOUBLE(self):
            return self.getToken(JavaParser.DOUBLE, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_primitiveType

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterPrimitiveType"):
                listener.enterPrimitiveType(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitPrimitiveType"):
                listener.exitPrimitiveType(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitPrimitiveType"):
                return visitor.visitPrimitiveType(self)
            else:
                return visitor.visitChildren(self)

    def primitiveType(self):

        localctx = JavaParser.PrimitiveTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 200, self.RULE_primitiveType)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1403
            _la = self._input.LA(1)
            if not (
                (
                    ((_la) & ~0x3F) == 0
                    and (
                        (1 << _la)
                        & (
                            (1 << JavaParser.BOOLEAN)
                            | (1 << JavaParser.BYTE)
                            | (1 << JavaParser.CHAR)
                            | (1 << JavaParser.DOUBLE)
                            | (1 << JavaParser.FLOAT)
                            | (1 << JavaParser.INT)
                            | (1 << JavaParser.LONG)
                            | (1 << JavaParser.SHORT)
                        )
                    )
                    != 0
                )
            ):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class TypeArgumentsContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LT(self):
            return self.getToken(JavaParser.LT, 0)

        def typeArgument(self, i: int = None):
            if i is None:
                return self.getTypedRuleContexts(JavaParser.TypeArgumentContext)
            else:
                return self.getTypedRuleContext(JavaParser.TypeArgumentContext, i)

        def GT(self):
            return self.getToken(JavaParser.GT, 0)

        def COMMA(self, i: int = None):
            if i is None:
                return self.getTokens(JavaParser.COMMA)
            else:
                return self.getToken(JavaParser.COMMA, i)

        def getRuleIndex(self):
            return JavaParser.RULE_typeArguments

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterTypeArguments"):
                listener.enterTypeArguments(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitTypeArguments"):
                listener.exitTypeArguments(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitTypeArguments"):
                return visitor.visitTypeArguments(self)
            else:
                return visitor.visitChildren(self)

    def typeArguments(self):

        localctx = JavaParser.TypeArgumentsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 202, self.RULE_typeArguments)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1405
            self.match(JavaParser.LT)
            self.state = 1406
            self.typeArgument()
            self.state = 1411
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la == JavaParser.COMMA:
                self.state = 1407
                self.match(JavaParser.COMMA)
                self.state = 1408
                self.typeArgument()
                self.state = 1413
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1414
            self.match(JavaParser.GT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class SuperSuffixContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def arguments(self):
            return self.getTypedRuleContext(JavaParser.ArgumentsContext, 0)

        def DOT(self):
            return self.getToken(JavaParser.DOT, 0)

        def IDENTIFIER(self):
            return self.getToken(JavaParser.IDENTIFIER, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_superSuffix

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterSuperSuffix"):
                listener.enterSuperSuffix(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitSuperSuffix"):
                listener.exitSuperSuffix(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitSuperSuffix"):
                return visitor.visitSuperSuffix(self)
            else:
                return visitor.visitChildren(self)

    def superSuffix(self):

        localctx = JavaParser.SuperSuffixContext(self, self._ctx, self.state)
        self.enterRule(localctx, 204, self.RULE_superSuffix)
        try:
            self.state = 1422
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [JavaParser.LPAREN]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1416
                self.arguments()
                pass
            elif token in [JavaParser.DOT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1417
                self.match(JavaParser.DOT)
                self.state = 1418
                self.match(JavaParser.IDENTIFIER)
                self.state = 1420
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input, 175, self._ctx)
                if la_ == 1:
                    self.state = 1419
                    self.arguments()

                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ExplicitGenericInvocationSuffixContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def SUPER(self):
            return self.getToken(JavaParser.SUPER, 0)

        def superSuffix(self):
            return self.getTypedRuleContext(JavaParser.SuperSuffixContext, 0)

        def IDENTIFIER(self):
            return self.getToken(JavaParser.IDENTIFIER, 0)

        def arguments(self):
            return self.getTypedRuleContext(JavaParser.ArgumentsContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_explicitGenericInvocationSuffix

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterExplicitGenericInvocationSuffix"):
                listener.enterExplicitGenericInvocationSuffix(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitExplicitGenericInvocationSuffix"):
                listener.exitExplicitGenericInvocationSuffix(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitExplicitGenericInvocationSuffix"):
                return visitor.visitExplicitGenericInvocationSuffix(self)
            else:
                return visitor.visitChildren(self)

    def explicitGenericInvocationSuffix(self):

        localctx = JavaParser.ExplicitGenericInvocationSuffixContext(self, self._ctx, self.state)
        self.enterRule(localctx, 206, self.RULE_explicitGenericInvocationSuffix)
        try:
            self.state = 1428
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [JavaParser.SUPER]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1424
                self.match(JavaParser.SUPER)
                self.state = 1425
                self.superSuffix()
                pass
            elif token in [JavaParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1426
                self.match(JavaParser.IDENTIFIER)
                self.state = 1427
                self.arguments()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ArgumentsContext(ParserRuleContext):
        def __init__(self, parser, parent: ParserRuleContext = None, invokingState: int = -1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LPAREN(self):
            return self.getToken(JavaParser.LPAREN, 0)

        def RPAREN(self):
            return self.getToken(JavaParser.RPAREN, 0)

        def expressionList(self):
            return self.getTypedRuleContext(JavaParser.ExpressionListContext, 0)

        def getRuleIndex(self):
            return JavaParser.RULE_arguments

        def enterRule(self, listener: ParseTreeListener):
            if hasattr(listener, "enterArguments"):
                listener.enterArguments(self)

        def exitRule(self, listener: ParseTreeListener):
            if hasattr(listener, "exitArguments"):
                listener.exitArguments(self)

        def accept(self, visitor: ParseTreeVisitor):
            if hasattr(visitor, "visitArguments"):
                return visitor.visitArguments(self)
            else:
                return visitor.visitChildren(self)

    def arguments(self):

        localctx = JavaParser.ArgumentsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 208, self.RULE_arguments)
        self._la = 0  # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1430
            self.match(JavaParser.LPAREN)
            self.state = 1432
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (
                ((_la) & ~0x3F) == 0
                and (
                    (1 << _la)
                    & (
                        (1 << JavaParser.BOOLEAN)
                        | (1 << JavaParser.BYTE)
                        | (1 << JavaParser.CHAR)
                        | (1 << JavaParser.DOUBLE)
                        | (1 << JavaParser.FLOAT)
                        | (1 << JavaParser.INT)
                        | (1 << JavaParser.LONG)
                        | (1 << JavaParser.NEW)
                        | (1 << JavaParser.SHORT)
                        | (1 << JavaParser.SUPER)
                        | (1 << JavaParser.THIS)
                        | (1 << JavaParser.VOID)
                        | (1 << JavaParser.DECIMAL_LITERAL)
                        | (1 << JavaParser.HEX_LITERAL)
                        | (1 << JavaParser.OCT_LITERAL)
                        | (1 << JavaParser.BINARY_LITERAL)
                        | (1 << JavaParser.FLOAT_LITERAL)
                        | (1 << JavaParser.HEX_FLOAT_LITERAL)
                        | (1 << JavaParser.BOOL_LITERAL)
                        | (1 << JavaParser.CHAR_LITERAL)
                        | (1 << JavaParser.STRING_LITERAL)
                        | (1 << JavaParser.NULL_LITERAL)
                        | (1 << JavaParser.LPAREN)
                    )
                )
                != 0
            ) or (
                (((_la - 72)) & ~0x3F) == 0
                and (
                    (1 << (_la - 72))
                    & (
                        (1 << (JavaParser.LT - 72))
                        | (1 << (JavaParser.BANG - 72))
                        | (1 << (JavaParser.TILDE - 72))
                        | (1 << (JavaParser.INC - 72))
                        | (1 << (JavaParser.DEC - 72))
                        | (1 << (JavaParser.ADD - 72))
                        | (1 << (JavaParser.SUB - 72))
                        | (1 << (JavaParser.AT - 72))
                        | (1 << (JavaParser.IDENTIFIER - 72))
                    )
                )
                != 0
            ):
                self.state = 1431
                self.expressionList()

            self.state = 1434
            self.match(JavaParser.RPAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    def sempred(self, localctx: RuleContext, ruleIndex: int, predIndex: int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[83] = self.expression_sempred
        pred = self._predicates.get(ruleIndex, None)
        if pred is None:
            raise Exception("No predicate with index:" + str(ruleIndex))
        else:
            return pred(localctx, predIndex)

    def expression_sempred(self, localctx: ExpressionContext, predIndex: int):
        if predIndex == 0:
            return self.precpred(self._ctx, 17)

        if predIndex == 1:
            return self.precpred(self._ctx, 16)

        if predIndex == 2:
            return self.precpred(self._ctx, 15)

        if predIndex == 3:
            return self.precpred(self._ctx, 14)

        if predIndex == 4:
            return self.precpred(self._ctx, 12)

        if predIndex == 5:
            return self.precpred(self._ctx, 11)

        if predIndex == 6:
            return self.precpred(self._ctx, 10)

        if predIndex == 7:
            return self.precpred(self._ctx, 9)

        if predIndex == 8:
            return self.precpred(self._ctx, 8)

        if predIndex == 9:
            return self.precpred(self._ctx, 7)

        if predIndex == 10:
            return self.precpred(self._ctx, 6)

        if predIndex == 11:
            return self.precpred(self._ctx, 5)

        if predIndex == 12:
            return self.precpred(self._ctx, 25)

        if predIndex == 13:
            return self.precpred(self._ctx, 24)

        if predIndex == 14:
            return self.precpred(self._ctx, 20)

        if predIndex == 15:
            return self.precpred(self._ctx, 13)

        if predIndex == 16:
            return self.precpred(self._ctx, 3)
