View Javadoc
1   // Generated from io/earcam/instrumental/module/jpms/parser/Java9.g4 by ANTLR 4.7.1
2   package io.earcam.instrumental.module.jpms.parser;
3   import org.antlr.v4.runtime.atn.*;
4   import org.antlr.v4.runtime.dfa.DFA;
5   import org.antlr.v4.runtime.*;
6   import org.antlr.v4.runtime.misc.*;
7   import org.antlr.v4.runtime.tree.*;
8   import java.util.List;
9   import java.util.Iterator;
10  import java.util.ArrayList;
11  
12  @SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
13  class Java9Parser extends Parser {
14  	static { RuntimeMetaData.checkVersion("4.7.1", RuntimeMetaData.VERSION); }
15  
16  	protected static final DFA[] _decisionToDFA;
17  	protected static final PredictionContextCache _sharedContextCache =
18  		new PredictionContextCache();
19  	public static final int
20  		T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9, 
21  		T__9=10, ABSTRACT=11, ASSERT=12, BOOLEAN=13, BREAK=14, BYTE=15, CASE=16, 
22  		CATCH=17, CHAR=18, CLASS=19, CONST=20, CONTINUE=21, DEFAULT=22, DO=23, 
23  		DOUBLE=24, ELSE=25, ENUM=26, EXTENDS=27, FINAL=28, FINALLY=29, FLOAT=30, 
24  		FOR=31, IF=32, GOTO=33, IMPLEMENTS=34, IMPORT=35, INSTANCEOF=36, INT=37, 
25  		INTERFACE=38, LONG=39, NATIVE=40, NEW=41, PACKAGE=42, PRIVATE=43, PROTECTED=44, 
26  		PUBLIC=45, RETURN=46, SHORT=47, STATIC=48, STRICTFP=49, SUPER=50, SWITCH=51, 
27  		SYNCHRONIZED=52, THIS=53, THROW=54, THROWS=55, TRANSIENT=56, TRY=57, VOID=58, 
28  		VOLATILE=59, WHILE=60, UNDER_SCORE=61, IntegerLiteral=62, FloatingPointLiteral=63, 
29  		BooleanLiteral=64, CharacterLiteral=65, StringLiteral=66, NullLiteral=67, 
30  		LPAREN=68, RPAREN=69, LBRACE=70, RBRACE=71, LBRACK=72, RBRACK=73, SEMI=74, 
31  		COMMA=75, DOT=76, ELLIPSIS=77, AT=78, COLONCOLON=79, ASSIGN=80, GT=81, 
32  		LT=82, BANG=83, TILDE=84, QUESTION=85, COLON=86, ARROW=87, EQUAL=88, LE=89, 
33  		GE=90, NOTEQUAL=91, AND=92, OR=93, INC=94, DEC=95, ADD=96, SUB=97, MUL=98, 
34  		DIV=99, BITAND=100, BITOR=101, CARET=102, MOD=103, ADD_ASSIGN=104, SUB_ASSIGN=105, 
35  		MUL_ASSIGN=106, DIV_ASSIGN=107, AND_ASSIGN=108, OR_ASSIGN=109, XOR_ASSIGN=110, 
36  		MOD_ASSIGN=111, LSHIFT_ASSIGN=112, RSHIFT_ASSIGN=113, URSHIFT_ASSIGN=114, 
37  		Identifier=115, WS=116, COMMENT=117, LINE_COMMENT=118;
38  	public static final int
39  		RULE_literal = 0, RULE_primitiveType = 1, RULE_numericType = 2, RULE_integralType = 3, 
40  		RULE_floatingPointType = 4, RULE_referenceType = 5, RULE_classOrInterfaceType = 6, 
41  		RULE_classType = 7, RULE_classType_lf_classOrInterfaceType = 8, RULE_classType_lfno_classOrInterfaceType = 9, 
42  		RULE_interfaceType = 10, RULE_interfaceType_lf_classOrInterfaceType = 11, 
43  		RULE_interfaceType_lfno_classOrInterfaceType = 12, RULE_typeVariable = 13, 
44  		RULE_arrayType = 14, RULE_dims = 15, RULE_typeParameter = 16, RULE_typeParameterModifier = 17, 
45  		RULE_typeBound = 18, RULE_additionalBound = 19, RULE_typeArguments = 20, 
46  		RULE_typeArgumentList = 21, RULE_typeArgument = 22, RULE_wildcard = 23, 
47  		RULE_wildcardBounds = 24, RULE_moduleName = 25, RULE_packageName = 26, 
48  		RULE_typeName = 27, RULE_packageOrTypeName = 28, RULE_expressionName = 29, 
49  		RULE_methodName = 30, RULE_ambiguousName = 31, RULE_compilationUnit = 32, 
50  		RULE_ordinaryCompilation = 33, RULE_modularCompilation = 34, RULE_packageDeclaration = 35, 
51  		RULE_packageModifier = 36, RULE_importDeclaration = 37, RULE_singleTypeImportDeclaration = 38, 
52  		RULE_typeImportOnDemandDeclaration = 39, RULE_singleStaticImportDeclaration = 40, 
53  		RULE_staticImportOnDemandDeclaration = 41, RULE_typeDeclaration = 42, 
54  		RULE_moduleDeclaration = 43, RULE_moduleDirective = 44, RULE_requiresDirective = 45, 
55  		RULE_exportsDirective = 46, RULE_opensDirective = 47, RULE_usesDirective = 48, 
56  		RULE_providesDirective = 49, RULE_requiresModifier = 50, RULE_classDeclaration = 51, 
57  		RULE_normalClassDeclaration = 52, RULE_classModifier = 53, RULE_typeParameters = 54, 
58  		RULE_typeParameterList = 55, RULE_superclass = 56, RULE_superinterfaces = 57, 
59  		RULE_interfaceTypeList = 58, RULE_classBody = 59, RULE_classBodyDeclaration = 60, 
60  		RULE_classMemberDeclaration = 61, RULE_fieldDeclaration = 62, RULE_fieldModifier = 63, 
61  		RULE_variableDeclaratorList = 64, RULE_variableDeclarator = 65, RULE_variableDeclaratorId = 66, 
62  		RULE_variableInitializer = 67, RULE_unannType = 68, RULE_unannPrimitiveType = 69, 
63  		RULE_unannReferenceType = 70, RULE_unannClassOrInterfaceType = 71, RULE_unannClassType = 72, 
64  		RULE_unannClassType_lf_unannClassOrInterfaceType = 73, RULE_unannClassType_lfno_unannClassOrInterfaceType = 74, 
65  		RULE_unannInterfaceType = 75, RULE_unannInterfaceType_lf_unannClassOrInterfaceType = 76, 
66  		RULE_unannInterfaceType_lfno_unannClassOrInterfaceType = 77, RULE_unannTypeVariable = 78, 
67  		RULE_unannArrayType = 79, RULE_methodDeclaration = 80, RULE_methodModifier = 81, 
68  		RULE_methodHeader = 82, RULE_result = 83, RULE_methodDeclarator = 84, 
69  		RULE_formalParameterList = 85, RULE_formalParameters = 86, RULE_formalParameter = 87, 
70  		RULE_variableModifier = 88, RULE_lastFormalParameter = 89, RULE_receiverParameter = 90, 
71  		RULE_throws_ = 91, RULE_exceptionTypeList = 92, RULE_exceptionType = 93, 
72  		RULE_methodBody = 94, RULE_instanceInitializer = 95, RULE_staticInitializer = 96, 
73  		RULE_constructorDeclaration = 97, RULE_constructorModifier = 98, RULE_constructorDeclarator = 99, 
74  		RULE_simpleTypeName = 100, RULE_constructorBody = 101, RULE_explicitConstructorInvocation = 102, 
75  		RULE_enumDeclaration = 103, RULE_enumBody = 104, RULE_enumConstantList = 105, 
76  		RULE_enumConstant = 106, RULE_enumConstantModifier = 107, RULE_enumBodyDeclarations = 108, 
77  		RULE_interfaceDeclaration = 109, RULE_normalInterfaceDeclaration = 110, 
78  		RULE_interfaceModifier = 111, RULE_extendsInterfaces = 112, RULE_interfaceBody = 113, 
79  		RULE_interfaceMemberDeclaration = 114, RULE_constantDeclaration = 115, 
80  		RULE_constantModifier = 116, RULE_interfaceMethodDeclaration = 117, RULE_interfaceMethodModifier = 118, 
81  		RULE_annotationTypeDeclaration = 119, RULE_annotationTypeBody = 120, RULE_annotationTypeMemberDeclaration = 121, 
82  		RULE_annotationTypeElementDeclaration = 122, RULE_annotationTypeElementModifier = 123, 
83  		RULE_defaultValue = 124, RULE_annotation = 125, RULE_normalAnnotation = 126, 
84  		RULE_elementValuePairList = 127, RULE_elementValuePair = 128, RULE_elementValue = 129, 
85  		RULE_elementValueArrayInitializer = 130, RULE_elementValueList = 131, 
86  		RULE_markerAnnotation = 132, RULE_singleElementAnnotation = 133, RULE_arrayInitializer = 134, 
87  		RULE_variableInitializerList = 135, RULE_block = 136, RULE_blockStatements = 137, 
88  		RULE_blockStatement = 138, RULE_localVariableDeclarationStatement = 139, 
89  		RULE_localVariableDeclaration = 140, RULE_statement = 141, RULE_statementNoShortIf = 142, 
90  		RULE_statementWithoutTrailingSubstatement = 143, RULE_emptyStatement = 144, 
91  		RULE_labeledStatement = 145, RULE_labeledStatementNoShortIf = 146, RULE_expressionStatement = 147, 
92  		RULE_statementExpression = 148, RULE_ifThenStatement = 149, RULE_ifThenElseStatement = 150, 
93  		RULE_ifThenElseStatementNoShortIf = 151, RULE_assertStatement = 152, RULE_switchStatement = 153, 
94  		RULE_switchBlock = 154, RULE_switchBlockStatementGroup = 155, RULE_switchLabels = 156, 
95  		RULE_switchLabel = 157, RULE_enumConstantName = 158, RULE_whileStatement = 159, 
96  		RULE_whileStatementNoShortIf = 160, RULE_doStatement = 161, RULE_forStatement = 162, 
97  		RULE_forStatementNoShortIf = 163, RULE_basicForStatement = 164, RULE_basicForStatementNoShortIf = 165, 
98  		RULE_forInit = 166, RULE_forUpdate = 167, RULE_statementExpressionList = 168, 
99  		RULE_enhancedForStatement = 169, RULE_enhancedForStatementNoShortIf = 170, 
100 		RULE_breakStatement = 171, RULE_continueStatement = 172, RULE_returnStatement = 173, 
101 		RULE_throwStatement = 174, RULE_synchronizedStatement = 175, RULE_tryStatement = 176, 
102 		RULE_catches = 177, RULE_catchClause = 178, RULE_catchFormalParameter = 179, 
103 		RULE_catchType = 180, RULE_finally_ = 181, RULE_tryWithResourcesStatement = 182, 
104 		RULE_resourceSpecification = 183, RULE_resourceList = 184, RULE_resource = 185, 
105 		RULE_variableAccess = 186, RULE_primary = 187, RULE_primaryNoNewArray = 188, 
106 		RULE_primaryNoNewArray_lf_arrayAccess = 189, RULE_primaryNoNewArray_lfno_arrayAccess = 190, 
107 		RULE_primaryNoNewArray_lf_primary = 191, RULE_primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary = 192, 
108 		RULE_primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary = 193, RULE_primaryNoNewArray_lfno_primary = 194, 
109 		RULE_primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary = 195, 
110 		RULE_primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary = 196, 
111 		RULE_classLiteral = 197, RULE_classInstanceCreationExpression = 198, RULE_classInstanceCreationExpression_lf_primary = 199, 
112 		RULE_classInstanceCreationExpression_lfno_primary = 200, RULE_typeArgumentsOrDiamond = 201, 
113 		RULE_fieldAccess = 202, RULE_fieldAccess_lf_primary = 203, RULE_fieldAccess_lfno_primary = 204, 
114 		RULE_arrayAccess = 205, RULE_arrayAccess_lf_primary = 206, RULE_arrayAccess_lfno_primary = 207, 
115 		RULE_methodInvocation = 208, RULE_methodInvocation_lf_primary = 209, RULE_methodInvocation_lfno_primary = 210, 
116 		RULE_argumentList = 211, RULE_methodReference = 212, RULE_methodReference_lf_primary = 213, 
117 		RULE_methodReference_lfno_primary = 214, RULE_arrayCreationExpression = 215, 
118 		RULE_dimExprs = 216, RULE_dimExpr = 217, RULE_constantExpression = 218, 
119 		RULE_expression = 219, RULE_lambdaExpression = 220, RULE_lambdaParameters = 221, 
120 		RULE_inferredFormalParameterList = 222, RULE_lambdaBody = 223, RULE_assignmentExpression = 224, 
121 		RULE_assignment = 225, RULE_leftHandSide = 226, RULE_assignmentOperator = 227, 
122 		RULE_conditionalExpression = 228, RULE_conditionalOrExpression = 229, 
123 		RULE_conditionalAndExpression = 230, RULE_inclusiveOrExpression = 231, 
124 		RULE_exclusiveOrExpression = 232, RULE_andExpression = 233, RULE_equalityExpression = 234, 
125 		RULE_relationalExpression = 235, RULE_shiftExpression = 236, RULE_additiveExpression = 237, 
126 		RULE_multiplicativeExpression = 238, RULE_unaryExpression = 239, RULE_preIncrementExpression = 240, 
127 		RULE_preDecrementExpression = 241, RULE_unaryExpressionNotPlusMinus = 242, 
128 		RULE_postfixExpression = 243, RULE_postIncrementExpression = 244, RULE_postIncrementExpression_lf_postfixExpression = 245, 
129 		RULE_postDecrementExpression = 246, RULE_postDecrementExpression_lf_postfixExpression = 247, 
130 		RULE_castExpression = 248, RULE_identifier = 249;
131 	public static final String[] ruleNames = {
132 		"literal", "primitiveType", "numericType", "integralType", "floatingPointType", 
133 		"referenceType", "classOrInterfaceType", "classType", "classType_lf_classOrInterfaceType", 
134 		"classType_lfno_classOrInterfaceType", "interfaceType", "interfaceType_lf_classOrInterfaceType", 
135 		"interfaceType_lfno_classOrInterfaceType", "typeVariable", "arrayType", 
136 		"dims", "typeParameter", "typeParameterModifier", "typeBound", "additionalBound", 
137 		"typeArguments", "typeArgumentList", "typeArgument", "wildcard", "wildcardBounds", 
138 		"moduleName", "packageName", "typeName", "packageOrTypeName", "expressionName", 
139 		"methodName", "ambiguousName", "compilationUnit", "ordinaryCompilation", 
140 		"modularCompilation", "packageDeclaration", "packageModifier", "importDeclaration", 
141 		"singleTypeImportDeclaration", "typeImportOnDemandDeclaration", "singleStaticImportDeclaration", 
142 		"staticImportOnDemandDeclaration", "typeDeclaration", "moduleDeclaration", 
143 		"moduleDirective", "requiresDirective", "exportsDirective", "opensDirective", 
144 		"usesDirective", "providesDirective", "requiresModifier", "classDeclaration", 
145 		"normalClassDeclaration", "classModifier", "typeParameters", "typeParameterList", 
146 		"superclass", "superinterfaces", "interfaceTypeList", "classBody", "classBodyDeclaration", 
147 		"classMemberDeclaration", "fieldDeclaration", "fieldModifier", "variableDeclaratorList", 
148 		"variableDeclarator", "variableDeclaratorId", "variableInitializer", "unannType", 
149 		"unannPrimitiveType", "unannReferenceType", "unannClassOrInterfaceType", 
150 		"unannClassType", "unannClassType_lf_unannClassOrInterfaceType", "unannClassType_lfno_unannClassOrInterfaceType", 
151 		"unannInterfaceType", "unannInterfaceType_lf_unannClassOrInterfaceType", 
152 		"unannInterfaceType_lfno_unannClassOrInterfaceType", "unannTypeVariable", 
153 		"unannArrayType", "methodDeclaration", "methodModifier", "methodHeader", 
154 		"result", "methodDeclarator", "formalParameterList", "formalParameters", 
155 		"formalParameter", "variableModifier", "lastFormalParameter", "receiverParameter", 
156 		"throws_", "exceptionTypeList", "exceptionType", "methodBody", "instanceInitializer", 
157 		"staticInitializer", "constructorDeclaration", "constructorModifier", 
158 		"constructorDeclarator", "simpleTypeName", "constructorBody", "explicitConstructorInvocation", 
159 		"enumDeclaration", "enumBody", "enumConstantList", "enumConstant", "enumConstantModifier", 
160 		"enumBodyDeclarations", "interfaceDeclaration", "normalInterfaceDeclaration", 
161 		"interfaceModifier", "extendsInterfaces", "interfaceBody", "interfaceMemberDeclaration", 
162 		"constantDeclaration", "constantModifier", "interfaceMethodDeclaration", 
163 		"interfaceMethodModifier", "annotationTypeDeclaration", "annotationTypeBody", 
164 		"annotationTypeMemberDeclaration", "annotationTypeElementDeclaration", 
165 		"annotationTypeElementModifier", "defaultValue", "annotation", "normalAnnotation", 
166 		"elementValuePairList", "elementValuePair", "elementValue", "elementValueArrayInitializer", 
167 		"elementValueList", "markerAnnotation", "singleElementAnnotation", "arrayInitializer", 
168 		"variableInitializerList", "block", "blockStatements", "blockStatement", 
169 		"localVariableDeclarationStatement", "localVariableDeclaration", "statement", 
170 		"statementNoShortIf", "statementWithoutTrailingSubstatement", "emptyStatement", 
171 		"labeledStatement", "labeledStatementNoShortIf", "expressionStatement", 
172 		"statementExpression", "ifThenStatement", "ifThenElseStatement", "ifThenElseStatementNoShortIf", 
173 		"assertStatement", "switchStatement", "switchBlock", "switchBlockStatementGroup", 
174 		"switchLabels", "switchLabel", "enumConstantName", "whileStatement", "whileStatementNoShortIf", 
175 		"doStatement", "forStatement", "forStatementNoShortIf", "basicForStatement", 
176 		"basicForStatementNoShortIf", "forInit", "forUpdate", "statementExpressionList", 
177 		"enhancedForStatement", "enhancedForStatementNoShortIf", "breakStatement", 
178 		"continueStatement", "returnStatement", "throwStatement", "synchronizedStatement", 
179 		"tryStatement", "catches", "catchClause", "catchFormalParameter", "catchType", 
180 		"finally_", "tryWithResourcesStatement", "resourceSpecification", "resourceList", 
181 		"resource", "variableAccess", "primary", "primaryNoNewArray", "primaryNoNewArray_lf_arrayAccess", 
182 		"primaryNoNewArray_lfno_arrayAccess", "primaryNoNewArray_lf_primary", 
183 		"primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary", "primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary", 
184 		"primaryNoNewArray_lfno_primary", "primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary", 
185 		"primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary", "classLiteral", 
186 		"classInstanceCreationExpression", "classInstanceCreationExpression_lf_primary", 
187 		"classInstanceCreationExpression_lfno_primary", "typeArgumentsOrDiamond", 
188 		"fieldAccess", "fieldAccess_lf_primary", "fieldAccess_lfno_primary", "arrayAccess", 
189 		"arrayAccess_lf_primary", "arrayAccess_lfno_primary", "methodInvocation", 
190 		"methodInvocation_lf_primary", "methodInvocation_lfno_primary", "argumentList", 
191 		"methodReference", "methodReference_lf_primary", "methodReference_lfno_primary", 
192 		"arrayCreationExpression", "dimExprs", "dimExpr", "constantExpression", 
193 		"expression", "lambdaExpression", "lambdaParameters", "inferredFormalParameterList", 
194 		"lambdaBody", "assignmentExpression", "assignment", "leftHandSide", "assignmentOperator", 
195 		"conditionalExpression", "conditionalOrExpression", "conditionalAndExpression", 
196 		"inclusiveOrExpression", "exclusiveOrExpression", "andExpression", "equalityExpression", 
197 		"relationalExpression", "shiftExpression", "additiveExpression", "multiplicativeExpression", 
198 		"unaryExpression", "preIncrementExpression", "preDecrementExpression", 
199 		"unaryExpressionNotPlusMinus", "postfixExpression", "postIncrementExpression", 
200 		"postIncrementExpression_lf_postfixExpression", "postDecrementExpression", 
201 		"postDecrementExpression_lf_postfixExpression", "castExpression", "identifier"
202 	};
203 
204 	private static final String[] _LITERAL_NAMES = {
205 		null, "'open'", "'module'", "'requires'", "'exports'", "'to'", "'opens'", 
206 		"'uses'", "'provides'", "'with'", "'transitive'", "'abstract'", "'assert'", 
207 		"'boolean'", "'break'", "'byte'", "'case'", "'catch'", "'char'", "'class'", 
208 		"'const'", "'continue'", "'default'", "'do'", "'double'", "'else'", "'enum'", 
209 		"'extends'", "'final'", "'finally'", "'float'", "'for'", "'if'", "'goto'", 
210 		"'implements'", "'import'", "'instanceof'", "'int'", "'interface'", "'long'", 
211 		"'native'", "'new'", "'package'", "'private'", "'protected'", "'public'", 
212 		"'return'", "'short'", "'static'", "'strictfp'", "'super'", "'switch'", 
213 		"'synchronized'", "'this'", "'throw'", "'throws'", "'transient'", "'try'", 
214 		"'void'", "'volatile'", "'while'", "'_'", null, null, null, null, null, 
215 		"'null'", "'('", "')'", "'{'", "'}'", "'['", "']'", "';'", "','", "'.'", 
216 		"'...'", "'@'", "'::'", "'='", "'>'", "'<'", "'!'", "'~'", "'?'", "':'", 
217 		"'->'", "'=='", "'<='", "'>='", "'!='", "'&&'", "'||'", "'++'", "'--'", 
218 		"'+'", "'-'", "'*'", "'/'", "'&'", "'|'", "'^'", "'%'", "'+='", "'-='", 
219 		"'*='", "'/='", "'&='", "'|='", "'^='", "'%='", "'<<='", "'>>='", "'>>>='"
220 	};
221 	private static final String[] _SYMBOLIC_NAMES = {
222 		null, null, null, null, null, null, null, null, null, null, null, "ABSTRACT", 
223 		"ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", "CHAR", "CLASS", 
224 		"CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", "ENUM", "EXTENDS", 
225 		"FINAL", "FINALLY", "FLOAT", "FOR", "IF", "GOTO", "IMPLEMENTS", "IMPORT", 
226 		"INSTANCEOF", "INT", "INTERFACE", "LONG", "NATIVE", "NEW", "PACKAGE", 
227 		"PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", "STATIC", "STRICTFP", 
228 		"SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", "THROWS", "TRANSIENT", 
229 		"TRY", "VOID", "VOLATILE", "WHILE", "UNDER_SCORE", "IntegerLiteral", "FloatingPointLiteral", 
230 		"BooleanLiteral", "CharacterLiteral", "StringLiteral", "NullLiteral", 
231 		"LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", "SEMI", "COMMA", 
232 		"DOT", "ELLIPSIS", "AT", "COLONCOLON", "ASSIGN", "GT", "LT", "BANG", "TILDE", 
233 		"QUESTION", "COLON", "ARROW", "EQUAL", "LE", "GE", "NOTEQUAL", "AND", 
234 		"OR", "INC", "DEC", "ADD", "SUB", "MUL", "DIV", "BITAND", "BITOR", "CARET", 
235 		"MOD", "ADD_ASSIGN", "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN", 
236 		"OR_ASSIGN", "XOR_ASSIGN", "MOD_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN", 
237 		"URSHIFT_ASSIGN", "Identifier", "WS", "COMMENT", "LINE_COMMENT"
238 	};
239 	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
240 
241 	/**
242 	 * @deprecated Use {@link #VOCABULARY} instead.
243 	 */
244 	@Deprecated
245 	public static final String[] tokenNames;
246 	static {
247 		tokenNames = new String[_SYMBOLIC_NAMES.length];
248 		for (int i = 0; i < tokenNames.length; i++) {
249 			tokenNames[i] = VOCABULARY.getLiteralName(i);
250 			if (tokenNames[i] == null) {
251 				tokenNames[i] = VOCABULARY.getSymbolicName(i);
252 			}
253 
254 			if (tokenNames[i] == null) {
255 				tokenNames[i] = "<INVALID>";
256 			}
257 		}
258 	}
259 
260 	@Override
261 	@Deprecated
262 	public String[] getTokenNames() {
263 		return tokenNames;
264 	}
265 
266 	@Override
267 
268 	public Vocabulary getVocabulary() {
269 		return VOCABULARY;
270 	}
271 
272 	@Override
273 	public String getGrammarFileName() { return "Java9.g4"; }
274 
275 	@Override
276 	public String[] getRuleNames() { return ruleNames; }
277 
278 	@Override
279 	public String getSerializedATN() { return _serializedATN; }
280 
281 	@Override
282 	public ATN getATN() { return _ATN; }
283 
284 	public Java9Parser(TokenStream input) {
285 		super(input);
286 		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
287 	}
288 	public static class LiteralContext extends ParserRuleContext {
289 		public TerminalNode IntegerLiteral() { return getToken(Java9Parser.IntegerLiteral, 0); }
290 		public TerminalNode FloatingPointLiteral() { return getToken(Java9Parser.FloatingPointLiteral, 0); }
291 		public TerminalNode BooleanLiteral() { return getToken(Java9Parser.BooleanLiteral, 0); }
292 		public TerminalNode CharacterLiteral() { return getToken(Java9Parser.CharacterLiteral, 0); }
293 		public TerminalNode StringLiteral() { return getToken(Java9Parser.StringLiteral, 0); }
294 		public TerminalNode NullLiteral() { return getToken(Java9Parser.NullLiteral, 0); }
295 		public LiteralContext(ParserRuleContext parent, int invokingState) {
296 			super(parent, invokingState);
297 		}
298 		@Override public int getRuleIndex() { return RULE_literal; }
299 		@Override
300 		public void enterRule(ParseTreeListener listener) {
301 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterLiteral(this);
302 		}
303 		@Override
304 		public void exitRule(ParseTreeListener listener) {
305 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitLiteral(this);
306 		}
307 	}
308 
309 	public final LiteralContext literal() throws RecognitionException {
310 		LiteralContext _localctx = new LiteralContext(_ctx, getState());
311 		enterRule(_localctx, 0, RULE_literal);
312 		int _la;
313 		try {
314 			enterOuterAlt(_localctx, 1);
315 			{
316 			setState(500);
317 			_la = _input.LA(1);
318 			if ( !(((((_la - 62)) & ~0x3f) == 0 && ((1L << (_la - 62)) & ((1L << (IntegerLiteral - 62)) | (1L << (FloatingPointLiteral - 62)) | (1L << (BooleanLiteral - 62)) | (1L << (CharacterLiteral - 62)) | (1L << (StringLiteral - 62)) | (1L << (NullLiteral - 62)))) != 0)) ) {
319 			_errHandler.recoverInline(this);
320 			}
321 			else {
322 				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
323 				_errHandler.reportMatch(this);
324 				consume();
325 			}
326 			}
327 		}
328 		catch (RecognitionException re) {
329 			_localctx.exception = re;
330 			_errHandler.reportError(this, re);
331 			_errHandler.recover(this, re);
332 		}
333 		finally {
334 			exitRule();
335 		}
336 		return _localctx;
337 	}
338 
339 	public static class PrimitiveTypeContext extends ParserRuleContext {
340 		public NumericTypeContext numericType() {
341 			return getRuleContext(NumericTypeContext.class,0);
342 		}
343 		public List<AnnotationContext> annotation() {
344 			return getRuleContexts(AnnotationContext.class);
345 		}
346 		public AnnotationContext annotation(int i) {
347 			return getRuleContext(AnnotationContext.class,i);
348 		}
349 		public PrimitiveTypeContext(ParserRuleContext parent, int invokingState) {
350 			super(parent, invokingState);
351 		}
352 		@Override public int getRuleIndex() { return RULE_primitiveType; }
353 		@Override
354 		public void enterRule(ParseTreeListener listener) {
355 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPrimitiveType(this);
356 		}
357 		@Override
358 		public void exitRule(ParseTreeListener listener) {
359 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPrimitiveType(this);
360 		}
361 	}
362 
363 	public final PrimitiveTypeContext primitiveType() throws RecognitionException {
364 		PrimitiveTypeContext _localctx = new PrimitiveTypeContext(_ctx, getState());
365 		enterRule(_localctx, 2, RULE_primitiveType);
366 		int _la;
367 		try {
368 			setState(516);
369 			_errHandler.sync(this);
370 			switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
371 			case 1:
372 				enterOuterAlt(_localctx, 1);
373 				{
374 				setState(505);
375 				_errHandler.sync(this);
376 				_la = _input.LA(1);
377 				while (_la==AT) {
378 					{
379 					{
380 					setState(502);
381 					annotation();
382 					}
383 					}
384 					setState(507);
385 					_errHandler.sync(this);
386 					_la = _input.LA(1);
387 				}
388 				setState(508);
389 				numericType();
390 				}
391 				break;
392 			case 2:
393 				enterOuterAlt(_localctx, 2);
394 				{
395 				setState(512);
396 				_errHandler.sync(this);
397 				_la = _input.LA(1);
398 				while (_la==AT) {
399 					{
400 					{
401 					setState(509);
402 					annotation();
403 					}
404 					}
405 					setState(514);
406 					_errHandler.sync(this);
407 					_la = _input.LA(1);
408 				}
409 				setState(515);
410 				match(BOOLEAN);
411 				}
412 				break;
413 			}
414 		}
415 		catch (RecognitionException re) {
416 			_localctx.exception = re;
417 			_errHandler.reportError(this, re);
418 			_errHandler.recover(this, re);
419 		}
420 		finally {
421 			exitRule();
422 		}
423 		return _localctx;
424 	}
425 
426 	public static class NumericTypeContext extends ParserRuleContext {
427 		public IntegralTypeContext integralType() {
428 			return getRuleContext(IntegralTypeContext.class,0);
429 		}
430 		public FloatingPointTypeContext floatingPointType() {
431 			return getRuleContext(FloatingPointTypeContext.class,0);
432 		}
433 		public NumericTypeContext(ParserRuleContext parent, int invokingState) {
434 			super(parent, invokingState);
435 		}
436 		@Override public int getRuleIndex() { return RULE_numericType; }
437 		@Override
438 		public void enterRule(ParseTreeListener listener) {
439 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterNumericType(this);
440 		}
441 		@Override
442 		public void exitRule(ParseTreeListener listener) {
443 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitNumericType(this);
444 		}
445 	}
446 
447 	public final NumericTypeContext numericType() throws RecognitionException {
448 		NumericTypeContext _localctx = new NumericTypeContext(_ctx, getState());
449 		enterRule(_localctx, 4, RULE_numericType);
450 		try {
451 			setState(520);
452 			_errHandler.sync(this);
453 			switch (_input.LA(1)) {
454 			case BYTE:
455 			case CHAR:
456 			case INT:
457 			case LONG:
458 			case SHORT:
459 				enterOuterAlt(_localctx, 1);
460 				{
461 				setState(518);
462 				integralType();
463 				}
464 				break;
465 			case DOUBLE:
466 			case FLOAT:
467 				enterOuterAlt(_localctx, 2);
468 				{
469 				setState(519);
470 				floatingPointType();
471 				}
472 				break;
473 			default:
474 				throw new NoViableAltException(this);
475 			}
476 		}
477 		catch (RecognitionException re) {
478 			_localctx.exception = re;
479 			_errHandler.reportError(this, re);
480 			_errHandler.recover(this, re);
481 		}
482 		finally {
483 			exitRule();
484 		}
485 		return _localctx;
486 	}
487 
488 	public static class IntegralTypeContext extends ParserRuleContext {
489 		public IntegralTypeContext(ParserRuleContext parent, int invokingState) {
490 			super(parent, invokingState);
491 		}
492 		@Override public int getRuleIndex() { return RULE_integralType; }
493 		@Override
494 		public void enterRule(ParseTreeListener listener) {
495 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterIntegralType(this);
496 		}
497 		@Override
498 		public void exitRule(ParseTreeListener listener) {
499 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitIntegralType(this);
500 		}
501 	}
502 
503 	public final IntegralTypeContext integralType() throws RecognitionException {
504 		IntegralTypeContext _localctx = new IntegralTypeContext(_ctx, getState());
505 		enterRule(_localctx, 6, RULE_integralType);
506 		int _la;
507 		try {
508 			enterOuterAlt(_localctx, 1);
509 			{
510 			setState(522);
511 			_la = _input.LA(1);
512 			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BYTE) | (1L << CHAR) | (1L << INT) | (1L << LONG) | (1L << SHORT))) != 0)) ) {
513 			_errHandler.recoverInline(this);
514 			}
515 			else {
516 				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
517 				_errHandler.reportMatch(this);
518 				consume();
519 			}
520 			}
521 		}
522 		catch (RecognitionException re) {
523 			_localctx.exception = re;
524 			_errHandler.reportError(this, re);
525 			_errHandler.recover(this, re);
526 		}
527 		finally {
528 			exitRule();
529 		}
530 		return _localctx;
531 	}
532 
533 	public static class FloatingPointTypeContext extends ParserRuleContext {
534 		public FloatingPointTypeContext(ParserRuleContext parent, int invokingState) {
535 			super(parent, invokingState);
536 		}
537 		@Override public int getRuleIndex() { return RULE_floatingPointType; }
538 		@Override
539 		public void enterRule(ParseTreeListener listener) {
540 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterFloatingPointType(this);
541 		}
542 		@Override
543 		public void exitRule(ParseTreeListener listener) {
544 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitFloatingPointType(this);
545 		}
546 	}
547 
548 	public final FloatingPointTypeContext floatingPointType() throws RecognitionException {
549 		FloatingPointTypeContext _localctx = new FloatingPointTypeContext(_ctx, getState());
550 		enterRule(_localctx, 8, RULE_floatingPointType);
551 		int _la;
552 		try {
553 			enterOuterAlt(_localctx, 1);
554 			{
555 			setState(524);
556 			_la = _input.LA(1);
557 			if ( !(_la==DOUBLE || _la==FLOAT) ) {
558 			_errHandler.recoverInline(this);
559 			}
560 			else {
561 				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
562 				_errHandler.reportMatch(this);
563 				consume();
564 			}
565 			}
566 		}
567 		catch (RecognitionException re) {
568 			_localctx.exception = re;
569 			_errHandler.reportError(this, re);
570 			_errHandler.recover(this, re);
571 		}
572 		finally {
573 			exitRule();
574 		}
575 		return _localctx;
576 	}
577 
578 	public static class ReferenceTypeContext extends ParserRuleContext {
579 		public ClassOrInterfaceTypeContext classOrInterfaceType() {
580 			return getRuleContext(ClassOrInterfaceTypeContext.class,0);
581 		}
582 		public TypeVariableContext typeVariable() {
583 			return getRuleContext(TypeVariableContext.class,0);
584 		}
585 		public ArrayTypeContext arrayType() {
586 			return getRuleContext(ArrayTypeContext.class,0);
587 		}
588 		public ReferenceTypeContext(ParserRuleContext parent, int invokingState) {
589 			super(parent, invokingState);
590 		}
591 		@Override public int getRuleIndex() { return RULE_referenceType; }
592 		@Override
593 		public void enterRule(ParseTreeListener listener) {
594 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterReferenceType(this);
595 		}
596 		@Override
597 		public void exitRule(ParseTreeListener listener) {
598 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitReferenceType(this);
599 		}
600 	}
601 
602 	public final ReferenceTypeContext referenceType() throws RecognitionException {
603 		ReferenceTypeContext _localctx = new ReferenceTypeContext(_ctx, getState());
604 		enterRule(_localctx, 10, RULE_referenceType);
605 		try {
606 			setState(529);
607 			_errHandler.sync(this);
608 			switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
609 			case 1:
610 				enterOuterAlt(_localctx, 1);
611 				{
612 				setState(526);
613 				classOrInterfaceType();
614 				}
615 				break;
616 			case 2:
617 				enterOuterAlt(_localctx, 2);
618 				{
619 				setState(527);
620 				typeVariable();
621 				}
622 				break;
623 			case 3:
624 				enterOuterAlt(_localctx, 3);
625 				{
626 				setState(528);
627 				arrayType();
628 				}
629 				break;
630 			}
631 		}
632 		catch (RecognitionException re) {
633 			_localctx.exception = re;
634 			_errHandler.reportError(this, re);
635 			_errHandler.recover(this, re);
636 		}
637 		finally {
638 			exitRule();
639 		}
640 		return _localctx;
641 	}
642 
643 	public static class ClassOrInterfaceTypeContext extends ParserRuleContext {
644 		public ClassType_lfno_classOrInterfaceTypeContext classType_lfno_classOrInterfaceType() {
645 			return getRuleContext(ClassType_lfno_classOrInterfaceTypeContext.class,0);
646 		}
647 		public InterfaceType_lfno_classOrInterfaceTypeContext interfaceType_lfno_classOrInterfaceType() {
648 			return getRuleContext(InterfaceType_lfno_classOrInterfaceTypeContext.class,0);
649 		}
650 		public List<ClassType_lf_classOrInterfaceTypeContext> classType_lf_classOrInterfaceType() {
651 			return getRuleContexts(ClassType_lf_classOrInterfaceTypeContext.class);
652 		}
653 		public ClassType_lf_classOrInterfaceTypeContext classType_lf_classOrInterfaceType(int i) {
654 			return getRuleContext(ClassType_lf_classOrInterfaceTypeContext.class,i);
655 		}
656 		public List<InterfaceType_lf_classOrInterfaceTypeContext> interfaceType_lf_classOrInterfaceType() {
657 			return getRuleContexts(InterfaceType_lf_classOrInterfaceTypeContext.class);
658 		}
659 		public InterfaceType_lf_classOrInterfaceTypeContext interfaceType_lf_classOrInterfaceType(int i) {
660 			return getRuleContext(InterfaceType_lf_classOrInterfaceTypeContext.class,i);
661 		}
662 		public ClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
663 			super(parent, invokingState);
664 		}
665 		@Override public int getRuleIndex() { return RULE_classOrInterfaceType; }
666 		@Override
667 		public void enterRule(ParseTreeListener listener) {
668 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterClassOrInterfaceType(this);
669 		}
670 		@Override
671 		public void exitRule(ParseTreeListener listener) {
672 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitClassOrInterfaceType(this);
673 		}
674 	}
675 
676 	public final ClassOrInterfaceTypeContext classOrInterfaceType() throws RecognitionException {
677 		ClassOrInterfaceTypeContext _localctx = new ClassOrInterfaceTypeContext(_ctx, getState());
678 		enterRule(_localctx, 12, RULE_classOrInterfaceType);
679 		try {
680 			int _alt;
681 			enterOuterAlt(_localctx, 1);
682 			{
683 			setState(533);
684 			_errHandler.sync(this);
685 			switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
686 			case 1:
687 				{
688 				setState(531);
689 				classType_lfno_classOrInterfaceType();
690 				}
691 				break;
692 			case 2:
693 				{
694 				setState(532);
695 				interfaceType_lfno_classOrInterfaceType();
696 				}
697 				break;
698 			}
699 			setState(539);
700 			_errHandler.sync(this);
701 			_alt = getInterpreter().adaptivePredict(_input,7,_ctx);
702 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
703 				if ( _alt==1 ) {
704 					{
705 					setState(537);
706 					_errHandler.sync(this);
707 					switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
708 					case 1:
709 						{
710 						setState(535);
711 						classType_lf_classOrInterfaceType();
712 						}
713 						break;
714 					case 2:
715 						{
716 						setState(536);
717 						interfaceType_lf_classOrInterfaceType();
718 						}
719 						break;
720 					}
721 					} 
722 				}
723 				setState(541);
724 				_errHandler.sync(this);
725 				_alt = getInterpreter().adaptivePredict(_input,7,_ctx);
726 			}
727 			}
728 		}
729 		catch (RecognitionException re) {
730 			_localctx.exception = re;
731 			_errHandler.reportError(this, re);
732 			_errHandler.recover(this, re);
733 		}
734 		finally {
735 			exitRule();
736 		}
737 		return _localctx;
738 	}
739 
740 	public static class ClassTypeContext extends ParserRuleContext {
741 		public IdentifierContext identifier() {
742 			return getRuleContext(IdentifierContext.class,0);
743 		}
744 		public List<AnnotationContext> annotation() {
745 			return getRuleContexts(AnnotationContext.class);
746 		}
747 		public AnnotationContext annotation(int i) {
748 			return getRuleContext(AnnotationContext.class,i);
749 		}
750 		public TypeArgumentsContext typeArguments() {
751 			return getRuleContext(TypeArgumentsContext.class,0);
752 		}
753 		public ClassOrInterfaceTypeContext classOrInterfaceType() {
754 			return getRuleContext(ClassOrInterfaceTypeContext.class,0);
755 		}
756 		public ClassTypeContext(ParserRuleContext parent, int invokingState) {
757 			super(parent, invokingState);
758 		}
759 		@Override public int getRuleIndex() { return RULE_classType; }
760 		@Override
761 		public void enterRule(ParseTreeListener listener) {
762 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterClassType(this);
763 		}
764 		@Override
765 		public void exitRule(ParseTreeListener listener) {
766 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitClassType(this);
767 		}
768 	}
769 
770 	public final ClassTypeContext classType() throws RecognitionException {
771 		ClassTypeContext _localctx = new ClassTypeContext(_ctx, getState());
772 		enterRule(_localctx, 14, RULE_classType);
773 		int _la;
774 		try {
775 			setState(564);
776 			_errHandler.sync(this);
777 			switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
778 			case 1:
779 				enterOuterAlt(_localctx, 1);
780 				{
781 				setState(545);
782 				_errHandler.sync(this);
783 				_la = _input.LA(1);
784 				while (_la==AT) {
785 					{
786 					{
787 					setState(542);
788 					annotation();
789 					}
790 					}
791 					setState(547);
792 					_errHandler.sync(this);
793 					_la = _input.LA(1);
794 				}
795 				setState(548);
796 				identifier();
797 				setState(550);
798 				_errHandler.sync(this);
799 				_la = _input.LA(1);
800 				if (_la==LT) {
801 					{
802 					setState(549);
803 					typeArguments();
804 					}
805 				}
806 
807 				}
808 				break;
809 			case 2:
810 				enterOuterAlt(_localctx, 2);
811 				{
812 				setState(552);
813 				classOrInterfaceType();
814 				setState(553);
815 				match(DOT);
816 				setState(557);
817 				_errHandler.sync(this);
818 				_la = _input.LA(1);
819 				while (_la==AT) {
820 					{
821 					{
822 					setState(554);
823 					annotation();
824 					}
825 					}
826 					setState(559);
827 					_errHandler.sync(this);
828 					_la = _input.LA(1);
829 				}
830 				setState(560);
831 				identifier();
832 				setState(562);
833 				_errHandler.sync(this);
834 				_la = _input.LA(1);
835 				if (_la==LT) {
836 					{
837 					setState(561);
838 					typeArguments();
839 					}
840 				}
841 
842 				}
843 				break;
844 			}
845 		}
846 		catch (RecognitionException re) {
847 			_localctx.exception = re;
848 			_errHandler.reportError(this, re);
849 			_errHandler.recover(this, re);
850 		}
851 		finally {
852 			exitRule();
853 		}
854 		return _localctx;
855 	}
856 
857 	public static class ClassType_lf_classOrInterfaceTypeContext extends ParserRuleContext {
858 		public IdentifierContext identifier() {
859 			return getRuleContext(IdentifierContext.class,0);
860 		}
861 		public List<AnnotationContext> annotation() {
862 			return getRuleContexts(AnnotationContext.class);
863 		}
864 		public AnnotationContext annotation(int i) {
865 			return getRuleContext(AnnotationContext.class,i);
866 		}
867 		public TypeArgumentsContext typeArguments() {
868 			return getRuleContext(TypeArgumentsContext.class,0);
869 		}
870 		public ClassType_lf_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
871 			super(parent, invokingState);
872 		}
873 		@Override public int getRuleIndex() { return RULE_classType_lf_classOrInterfaceType; }
874 		@Override
875 		public void enterRule(ParseTreeListener listener) {
876 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterClassType_lf_classOrInterfaceType(this);
877 		}
878 		@Override
879 		public void exitRule(ParseTreeListener listener) {
880 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitClassType_lf_classOrInterfaceType(this);
881 		}
882 	}
883 
884 	public final ClassType_lf_classOrInterfaceTypeContext classType_lf_classOrInterfaceType() throws RecognitionException {
885 		ClassType_lf_classOrInterfaceTypeContext _localctx = new ClassType_lf_classOrInterfaceTypeContext(_ctx, getState());
886 		enterRule(_localctx, 16, RULE_classType_lf_classOrInterfaceType);
887 		int _la;
888 		try {
889 			enterOuterAlt(_localctx, 1);
890 			{
891 			setState(566);
892 			match(DOT);
893 			setState(570);
894 			_errHandler.sync(this);
895 			_la = _input.LA(1);
896 			while (_la==AT) {
897 				{
898 				{
899 				setState(567);
900 				annotation();
901 				}
902 				}
903 				setState(572);
904 				_errHandler.sync(this);
905 				_la = _input.LA(1);
906 			}
907 			setState(573);
908 			identifier();
909 			setState(575);
910 			_errHandler.sync(this);
911 			switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
912 			case 1:
913 				{
914 				setState(574);
915 				typeArguments();
916 				}
917 				break;
918 			}
919 			}
920 		}
921 		catch (RecognitionException re) {
922 			_localctx.exception = re;
923 			_errHandler.reportError(this, re);
924 			_errHandler.recover(this, re);
925 		}
926 		finally {
927 			exitRule();
928 		}
929 		return _localctx;
930 	}
931 
932 	public static class ClassType_lfno_classOrInterfaceTypeContext extends ParserRuleContext {
933 		public IdentifierContext identifier() {
934 			return getRuleContext(IdentifierContext.class,0);
935 		}
936 		public List<AnnotationContext> annotation() {
937 			return getRuleContexts(AnnotationContext.class);
938 		}
939 		public AnnotationContext annotation(int i) {
940 			return getRuleContext(AnnotationContext.class,i);
941 		}
942 		public TypeArgumentsContext typeArguments() {
943 			return getRuleContext(TypeArgumentsContext.class,0);
944 		}
945 		public ClassType_lfno_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
946 			super(parent, invokingState);
947 		}
948 		@Override public int getRuleIndex() { return RULE_classType_lfno_classOrInterfaceType; }
949 		@Override
950 		public void enterRule(ParseTreeListener listener) {
951 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterClassType_lfno_classOrInterfaceType(this);
952 		}
953 		@Override
954 		public void exitRule(ParseTreeListener listener) {
955 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitClassType_lfno_classOrInterfaceType(this);
956 		}
957 	}
958 
959 	public final ClassType_lfno_classOrInterfaceTypeContext classType_lfno_classOrInterfaceType() throws RecognitionException {
960 		ClassType_lfno_classOrInterfaceTypeContext _localctx = new ClassType_lfno_classOrInterfaceTypeContext(_ctx, getState());
961 		enterRule(_localctx, 18, RULE_classType_lfno_classOrInterfaceType);
962 		int _la;
963 		try {
964 			enterOuterAlt(_localctx, 1);
965 			{
966 			setState(580);
967 			_errHandler.sync(this);
968 			_la = _input.LA(1);
969 			while (_la==AT) {
970 				{
971 				{
972 				setState(577);
973 				annotation();
974 				}
975 				}
976 				setState(582);
977 				_errHandler.sync(this);
978 				_la = _input.LA(1);
979 			}
980 			setState(583);
981 			identifier();
982 			setState(585);
983 			_errHandler.sync(this);
984 			switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) {
985 			case 1:
986 				{
987 				setState(584);
988 				typeArguments();
989 				}
990 				break;
991 			}
992 			}
993 		}
994 		catch (RecognitionException re) {
995 			_localctx.exception = re;
996 			_errHandler.reportError(this, re);
997 			_errHandler.recover(this, re);
998 		}
999 		finally {
1000 			exitRule();
1001 		}
1002 		return _localctx;
1003 	}
1004 
1005 	public static class InterfaceTypeContext extends ParserRuleContext {
1006 		public ClassTypeContext classType() {
1007 			return getRuleContext(ClassTypeContext.class,0);
1008 		}
1009 		public InterfaceTypeContext(ParserRuleContext parent, int invokingState) {
1010 			super(parent, invokingState);
1011 		}
1012 		@Override public int getRuleIndex() { return RULE_interfaceType; }
1013 		@Override
1014 		public void enterRule(ParseTreeListener listener) {
1015 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInterfaceType(this);
1016 		}
1017 		@Override
1018 		public void exitRule(ParseTreeListener listener) {
1019 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInterfaceType(this);
1020 		}
1021 	}
1022 
1023 	public final InterfaceTypeContext interfaceType() throws RecognitionException {
1024 		InterfaceTypeContext _localctx = new InterfaceTypeContext(_ctx, getState());
1025 		enterRule(_localctx, 20, RULE_interfaceType);
1026 		try {
1027 			enterOuterAlt(_localctx, 1);
1028 			{
1029 			setState(587);
1030 			classType();
1031 			}
1032 		}
1033 		catch (RecognitionException re) {
1034 			_localctx.exception = re;
1035 			_errHandler.reportError(this, re);
1036 			_errHandler.recover(this, re);
1037 		}
1038 		finally {
1039 			exitRule();
1040 		}
1041 		return _localctx;
1042 	}
1043 
1044 	public static class InterfaceType_lf_classOrInterfaceTypeContext extends ParserRuleContext {
1045 		public ClassType_lf_classOrInterfaceTypeContext classType_lf_classOrInterfaceType() {
1046 			return getRuleContext(ClassType_lf_classOrInterfaceTypeContext.class,0);
1047 		}
1048 		public InterfaceType_lf_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
1049 			super(parent, invokingState);
1050 		}
1051 		@Override public int getRuleIndex() { return RULE_interfaceType_lf_classOrInterfaceType; }
1052 		@Override
1053 		public void enterRule(ParseTreeListener listener) {
1054 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInterfaceType_lf_classOrInterfaceType(this);
1055 		}
1056 		@Override
1057 		public void exitRule(ParseTreeListener listener) {
1058 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInterfaceType_lf_classOrInterfaceType(this);
1059 		}
1060 	}
1061 
1062 	public final InterfaceType_lf_classOrInterfaceTypeContext interfaceType_lf_classOrInterfaceType() throws RecognitionException {
1063 		InterfaceType_lf_classOrInterfaceTypeContext _localctx = new InterfaceType_lf_classOrInterfaceTypeContext(_ctx, getState());
1064 		enterRule(_localctx, 22, RULE_interfaceType_lf_classOrInterfaceType);
1065 		try {
1066 			enterOuterAlt(_localctx, 1);
1067 			{
1068 			setState(589);
1069 			classType_lf_classOrInterfaceType();
1070 			}
1071 		}
1072 		catch (RecognitionException re) {
1073 			_localctx.exception = re;
1074 			_errHandler.reportError(this, re);
1075 			_errHandler.recover(this, re);
1076 		}
1077 		finally {
1078 			exitRule();
1079 		}
1080 		return _localctx;
1081 	}
1082 
1083 	public static class InterfaceType_lfno_classOrInterfaceTypeContext extends ParserRuleContext {
1084 		public ClassType_lfno_classOrInterfaceTypeContext classType_lfno_classOrInterfaceType() {
1085 			return getRuleContext(ClassType_lfno_classOrInterfaceTypeContext.class,0);
1086 		}
1087 		public InterfaceType_lfno_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
1088 			super(parent, invokingState);
1089 		}
1090 		@Override public int getRuleIndex() { return RULE_interfaceType_lfno_classOrInterfaceType; }
1091 		@Override
1092 		public void enterRule(ParseTreeListener listener) {
1093 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInterfaceType_lfno_classOrInterfaceType(this);
1094 		}
1095 		@Override
1096 		public void exitRule(ParseTreeListener listener) {
1097 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInterfaceType_lfno_classOrInterfaceType(this);
1098 		}
1099 	}
1100 
1101 	public final InterfaceType_lfno_classOrInterfaceTypeContext interfaceType_lfno_classOrInterfaceType() throws RecognitionException {
1102 		InterfaceType_lfno_classOrInterfaceTypeContext _localctx = new InterfaceType_lfno_classOrInterfaceTypeContext(_ctx, getState());
1103 		enterRule(_localctx, 24, RULE_interfaceType_lfno_classOrInterfaceType);
1104 		try {
1105 			enterOuterAlt(_localctx, 1);
1106 			{
1107 			setState(591);
1108 			classType_lfno_classOrInterfaceType();
1109 			}
1110 		}
1111 		catch (RecognitionException re) {
1112 			_localctx.exception = re;
1113 			_errHandler.reportError(this, re);
1114 			_errHandler.recover(this, re);
1115 		}
1116 		finally {
1117 			exitRule();
1118 		}
1119 		return _localctx;
1120 	}
1121 
1122 	public static class TypeVariableContext extends ParserRuleContext {
1123 		public IdentifierContext identifier() {
1124 			return getRuleContext(IdentifierContext.class,0);
1125 		}
1126 		public List<AnnotationContext> annotation() {
1127 			return getRuleContexts(AnnotationContext.class);
1128 		}
1129 		public AnnotationContext annotation(int i) {
1130 			return getRuleContext(AnnotationContext.class,i);
1131 		}
1132 		public TypeVariableContext(ParserRuleContext parent, int invokingState) {
1133 			super(parent, invokingState);
1134 		}
1135 		@Override public int getRuleIndex() { return RULE_typeVariable; }
1136 		@Override
1137 		public void enterRule(ParseTreeListener listener) {
1138 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeVariable(this);
1139 		}
1140 		@Override
1141 		public void exitRule(ParseTreeListener listener) {
1142 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeVariable(this);
1143 		}
1144 	}
1145 
1146 	public final TypeVariableContext typeVariable() throws RecognitionException {
1147 		TypeVariableContext _localctx = new TypeVariableContext(_ctx, getState());
1148 		enterRule(_localctx, 26, RULE_typeVariable);
1149 		int _la;
1150 		try {
1151 			enterOuterAlt(_localctx, 1);
1152 			{
1153 			setState(596);
1154 			_errHandler.sync(this);
1155 			_la = _input.LA(1);
1156 			while (_la==AT) {
1157 				{
1158 				{
1159 				setState(593);
1160 				annotation();
1161 				}
1162 				}
1163 				setState(598);
1164 				_errHandler.sync(this);
1165 				_la = _input.LA(1);
1166 			}
1167 			setState(599);
1168 			identifier();
1169 			}
1170 		}
1171 		catch (RecognitionException re) {
1172 			_localctx.exception = re;
1173 			_errHandler.reportError(this, re);
1174 			_errHandler.recover(this, re);
1175 		}
1176 		finally {
1177 			exitRule();
1178 		}
1179 		return _localctx;
1180 	}
1181 
1182 	public static class ArrayTypeContext extends ParserRuleContext {
1183 		public PrimitiveTypeContext primitiveType() {
1184 			return getRuleContext(PrimitiveTypeContext.class,0);
1185 		}
1186 		public DimsContext dims() {
1187 			return getRuleContext(DimsContext.class,0);
1188 		}
1189 		public ClassOrInterfaceTypeContext classOrInterfaceType() {
1190 			return getRuleContext(ClassOrInterfaceTypeContext.class,0);
1191 		}
1192 		public TypeVariableContext typeVariable() {
1193 			return getRuleContext(TypeVariableContext.class,0);
1194 		}
1195 		public ArrayTypeContext(ParserRuleContext parent, int invokingState) {
1196 			super(parent, invokingState);
1197 		}
1198 		@Override public int getRuleIndex() { return RULE_arrayType; }
1199 		@Override
1200 		public void enterRule(ParseTreeListener listener) {
1201 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterArrayType(this);
1202 		}
1203 		@Override
1204 		public void exitRule(ParseTreeListener listener) {
1205 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitArrayType(this);
1206 		}
1207 	}
1208 
1209 	public final ArrayTypeContext arrayType() throws RecognitionException {
1210 		ArrayTypeContext _localctx = new ArrayTypeContext(_ctx, getState());
1211 		enterRule(_localctx, 28, RULE_arrayType);
1212 		try {
1213 			setState(610);
1214 			_errHandler.sync(this);
1215 			switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
1216 			case 1:
1217 				enterOuterAlt(_localctx, 1);
1218 				{
1219 				setState(601);
1220 				primitiveType();
1221 				setState(602);
1222 				dims();
1223 				}
1224 				break;
1225 			case 2:
1226 				enterOuterAlt(_localctx, 2);
1227 				{
1228 				setState(604);
1229 				classOrInterfaceType();
1230 				setState(605);
1231 				dims();
1232 				}
1233 				break;
1234 			case 3:
1235 				enterOuterAlt(_localctx, 3);
1236 				{
1237 				setState(607);
1238 				typeVariable();
1239 				setState(608);
1240 				dims();
1241 				}
1242 				break;
1243 			}
1244 		}
1245 		catch (RecognitionException re) {
1246 			_localctx.exception = re;
1247 			_errHandler.reportError(this, re);
1248 			_errHandler.recover(this, re);
1249 		}
1250 		finally {
1251 			exitRule();
1252 		}
1253 		return _localctx;
1254 	}
1255 
1256 	public static class DimsContext extends ParserRuleContext {
1257 		public List<AnnotationContext> annotation() {
1258 			return getRuleContexts(AnnotationContext.class);
1259 		}
1260 		public AnnotationContext annotation(int i) {
1261 			return getRuleContext(AnnotationContext.class,i);
1262 		}
1263 		public DimsContext(ParserRuleContext parent, int invokingState) {
1264 			super(parent, invokingState);
1265 		}
1266 		@Override public int getRuleIndex() { return RULE_dims; }
1267 		@Override
1268 		public void enterRule(ParseTreeListener listener) {
1269 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterDims(this);
1270 		}
1271 		@Override
1272 		public void exitRule(ParseTreeListener listener) {
1273 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitDims(this);
1274 		}
1275 	}
1276 
1277 	public final DimsContext dims() throws RecognitionException {
1278 		DimsContext _localctx = new DimsContext(_ctx, getState());
1279 		enterRule(_localctx, 30, RULE_dims);
1280 		int _la;
1281 		try {
1282 			int _alt;
1283 			enterOuterAlt(_localctx, 1);
1284 			{
1285 			setState(615);
1286 			_errHandler.sync(this);
1287 			_la = _input.LA(1);
1288 			while (_la==AT) {
1289 				{
1290 				{
1291 				setState(612);
1292 				annotation();
1293 				}
1294 				}
1295 				setState(617);
1296 				_errHandler.sync(this);
1297 				_la = _input.LA(1);
1298 			}
1299 			setState(618);
1300 			match(LBRACK);
1301 			setState(619);
1302 			match(RBRACK);
1303 			setState(630);
1304 			_errHandler.sync(this);
1305 			_alt = getInterpreter().adaptivePredict(_input,21,_ctx);
1306 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1307 				if ( _alt==1 ) {
1308 					{
1309 					{
1310 					setState(623);
1311 					_errHandler.sync(this);
1312 					_la = _input.LA(1);
1313 					while (_la==AT) {
1314 						{
1315 						{
1316 						setState(620);
1317 						annotation();
1318 						}
1319 						}
1320 						setState(625);
1321 						_errHandler.sync(this);
1322 						_la = _input.LA(1);
1323 					}
1324 					setState(626);
1325 					match(LBRACK);
1326 					setState(627);
1327 					match(RBRACK);
1328 					}
1329 					} 
1330 				}
1331 				setState(632);
1332 				_errHandler.sync(this);
1333 				_alt = getInterpreter().adaptivePredict(_input,21,_ctx);
1334 			}
1335 			}
1336 		}
1337 		catch (RecognitionException re) {
1338 			_localctx.exception = re;
1339 			_errHandler.reportError(this, re);
1340 			_errHandler.recover(this, re);
1341 		}
1342 		finally {
1343 			exitRule();
1344 		}
1345 		return _localctx;
1346 	}
1347 
1348 	public static class TypeParameterContext extends ParserRuleContext {
1349 		public IdentifierContext identifier() {
1350 			return getRuleContext(IdentifierContext.class,0);
1351 		}
1352 		public List<TypeParameterModifierContext> typeParameterModifier() {
1353 			return getRuleContexts(TypeParameterModifierContext.class);
1354 		}
1355 		public TypeParameterModifierContext typeParameterModifier(int i) {
1356 			return getRuleContext(TypeParameterModifierContext.class,i);
1357 		}
1358 		public TypeBoundContext typeBound() {
1359 			return getRuleContext(TypeBoundContext.class,0);
1360 		}
1361 		public TypeParameterContext(ParserRuleContext parent, int invokingState) {
1362 			super(parent, invokingState);
1363 		}
1364 		@Override public int getRuleIndex() { return RULE_typeParameter; }
1365 		@Override
1366 		public void enterRule(ParseTreeListener listener) {
1367 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeParameter(this);
1368 		}
1369 		@Override
1370 		public void exitRule(ParseTreeListener listener) {
1371 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeParameter(this);
1372 		}
1373 	}
1374 
1375 	public final TypeParameterContext typeParameter() throws RecognitionException {
1376 		TypeParameterContext _localctx = new TypeParameterContext(_ctx, getState());
1377 		enterRule(_localctx, 32, RULE_typeParameter);
1378 		int _la;
1379 		try {
1380 			enterOuterAlt(_localctx, 1);
1381 			{
1382 			setState(636);
1383 			_errHandler.sync(this);
1384 			_la = _input.LA(1);
1385 			while (_la==AT) {
1386 				{
1387 				{
1388 				setState(633);
1389 				typeParameterModifier();
1390 				}
1391 				}
1392 				setState(638);
1393 				_errHandler.sync(this);
1394 				_la = _input.LA(1);
1395 			}
1396 			setState(639);
1397 			identifier();
1398 			setState(641);
1399 			_errHandler.sync(this);
1400 			_la = _input.LA(1);
1401 			if (_la==EXTENDS) {
1402 				{
1403 				setState(640);
1404 				typeBound();
1405 				}
1406 			}
1407 
1408 			}
1409 		}
1410 		catch (RecognitionException re) {
1411 			_localctx.exception = re;
1412 			_errHandler.reportError(this, re);
1413 			_errHandler.recover(this, re);
1414 		}
1415 		finally {
1416 			exitRule();
1417 		}
1418 		return _localctx;
1419 	}
1420 
1421 	public static class TypeParameterModifierContext extends ParserRuleContext {
1422 		public AnnotationContext annotation() {
1423 			return getRuleContext(AnnotationContext.class,0);
1424 		}
1425 		public TypeParameterModifierContext(ParserRuleContext parent, int invokingState) {
1426 			super(parent, invokingState);
1427 		}
1428 		@Override public int getRuleIndex() { return RULE_typeParameterModifier; }
1429 		@Override
1430 		public void enterRule(ParseTreeListener listener) {
1431 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeParameterModifier(this);
1432 		}
1433 		@Override
1434 		public void exitRule(ParseTreeListener listener) {
1435 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeParameterModifier(this);
1436 		}
1437 	}
1438 
1439 	public final TypeParameterModifierContext typeParameterModifier() throws RecognitionException {
1440 		TypeParameterModifierContext _localctx = new TypeParameterModifierContext(_ctx, getState());
1441 		enterRule(_localctx, 34, RULE_typeParameterModifier);
1442 		try {
1443 			enterOuterAlt(_localctx, 1);
1444 			{
1445 			setState(643);
1446 			annotation();
1447 			}
1448 		}
1449 		catch (RecognitionException re) {
1450 			_localctx.exception = re;
1451 			_errHandler.reportError(this, re);
1452 			_errHandler.recover(this, re);
1453 		}
1454 		finally {
1455 			exitRule();
1456 		}
1457 		return _localctx;
1458 	}
1459 
1460 	public static class TypeBoundContext extends ParserRuleContext {
1461 		public TypeVariableContext typeVariable() {
1462 			return getRuleContext(TypeVariableContext.class,0);
1463 		}
1464 		public ClassOrInterfaceTypeContext classOrInterfaceType() {
1465 			return getRuleContext(ClassOrInterfaceTypeContext.class,0);
1466 		}
1467 		public List<AdditionalBoundContext> additionalBound() {
1468 			return getRuleContexts(AdditionalBoundContext.class);
1469 		}
1470 		public AdditionalBoundContext additionalBound(int i) {
1471 			return getRuleContext(AdditionalBoundContext.class,i);
1472 		}
1473 		public TypeBoundContext(ParserRuleContext parent, int invokingState) {
1474 			super(parent, invokingState);
1475 		}
1476 		@Override public int getRuleIndex() { return RULE_typeBound; }
1477 		@Override
1478 		public void enterRule(ParseTreeListener listener) {
1479 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeBound(this);
1480 		}
1481 		@Override
1482 		public void exitRule(ParseTreeListener listener) {
1483 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeBound(this);
1484 		}
1485 	}
1486 
1487 	public final TypeBoundContext typeBound() throws RecognitionException {
1488 		TypeBoundContext _localctx = new TypeBoundContext(_ctx, getState());
1489 		enterRule(_localctx, 36, RULE_typeBound);
1490 		int _la;
1491 		try {
1492 			setState(655);
1493 			_errHandler.sync(this);
1494 			switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
1495 			case 1:
1496 				enterOuterAlt(_localctx, 1);
1497 				{
1498 				setState(645);
1499 				match(EXTENDS);
1500 				setState(646);
1501 				typeVariable();
1502 				}
1503 				break;
1504 			case 2:
1505 				enterOuterAlt(_localctx, 2);
1506 				{
1507 				setState(647);
1508 				match(EXTENDS);
1509 				setState(648);
1510 				classOrInterfaceType();
1511 				setState(652);
1512 				_errHandler.sync(this);
1513 				_la = _input.LA(1);
1514 				while (_la==BITAND) {
1515 					{
1516 					{
1517 					setState(649);
1518 					additionalBound();
1519 					}
1520 					}
1521 					setState(654);
1522 					_errHandler.sync(this);
1523 					_la = _input.LA(1);
1524 				}
1525 				}
1526 				break;
1527 			}
1528 		}
1529 		catch (RecognitionException re) {
1530 			_localctx.exception = re;
1531 			_errHandler.reportError(this, re);
1532 			_errHandler.recover(this, re);
1533 		}
1534 		finally {
1535 			exitRule();
1536 		}
1537 		return _localctx;
1538 	}
1539 
1540 	public static class AdditionalBoundContext extends ParserRuleContext {
1541 		public InterfaceTypeContext interfaceType() {
1542 			return getRuleContext(InterfaceTypeContext.class,0);
1543 		}
1544 		public AdditionalBoundContext(ParserRuleContext parent, int invokingState) {
1545 			super(parent, invokingState);
1546 		}
1547 		@Override public int getRuleIndex() { return RULE_additionalBound; }
1548 		@Override
1549 		public void enterRule(ParseTreeListener listener) {
1550 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterAdditionalBound(this);
1551 		}
1552 		@Override
1553 		public void exitRule(ParseTreeListener listener) {
1554 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitAdditionalBound(this);
1555 		}
1556 	}
1557 
1558 	public final AdditionalBoundContext additionalBound() throws RecognitionException {
1559 		AdditionalBoundContext _localctx = new AdditionalBoundContext(_ctx, getState());
1560 		enterRule(_localctx, 38, RULE_additionalBound);
1561 		try {
1562 			enterOuterAlt(_localctx, 1);
1563 			{
1564 			setState(657);
1565 			match(BITAND);
1566 			setState(658);
1567 			interfaceType();
1568 			}
1569 		}
1570 		catch (RecognitionException re) {
1571 			_localctx.exception = re;
1572 			_errHandler.reportError(this, re);
1573 			_errHandler.recover(this, re);
1574 		}
1575 		finally {
1576 			exitRule();
1577 		}
1578 		return _localctx;
1579 	}
1580 
1581 	public static class TypeArgumentsContext extends ParserRuleContext {
1582 		public TypeArgumentListContext typeArgumentList() {
1583 			return getRuleContext(TypeArgumentListContext.class,0);
1584 		}
1585 		public TypeArgumentsContext(ParserRuleContext parent, int invokingState) {
1586 			super(parent, invokingState);
1587 		}
1588 		@Override public int getRuleIndex() { return RULE_typeArguments; }
1589 		@Override
1590 		public void enterRule(ParseTreeListener listener) {
1591 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeArguments(this);
1592 		}
1593 		@Override
1594 		public void exitRule(ParseTreeListener listener) {
1595 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeArguments(this);
1596 		}
1597 	}
1598 
1599 	public final TypeArgumentsContext typeArguments() throws RecognitionException {
1600 		TypeArgumentsContext _localctx = new TypeArgumentsContext(_ctx, getState());
1601 		enterRule(_localctx, 40, RULE_typeArguments);
1602 		try {
1603 			enterOuterAlt(_localctx, 1);
1604 			{
1605 			setState(660);
1606 			match(LT);
1607 			setState(661);
1608 			typeArgumentList();
1609 			setState(662);
1610 			match(GT);
1611 			}
1612 		}
1613 		catch (RecognitionException re) {
1614 			_localctx.exception = re;
1615 			_errHandler.reportError(this, re);
1616 			_errHandler.recover(this, re);
1617 		}
1618 		finally {
1619 			exitRule();
1620 		}
1621 		return _localctx;
1622 	}
1623 
1624 	public static class TypeArgumentListContext extends ParserRuleContext {
1625 		public List<TypeArgumentContext> typeArgument() {
1626 			return getRuleContexts(TypeArgumentContext.class);
1627 		}
1628 		public TypeArgumentContext typeArgument(int i) {
1629 			return getRuleContext(TypeArgumentContext.class,i);
1630 		}
1631 		public TypeArgumentListContext(ParserRuleContext parent, int invokingState) {
1632 			super(parent, invokingState);
1633 		}
1634 		@Override public int getRuleIndex() { return RULE_typeArgumentList; }
1635 		@Override
1636 		public void enterRule(ParseTreeListener listener) {
1637 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeArgumentList(this);
1638 		}
1639 		@Override
1640 		public void exitRule(ParseTreeListener listener) {
1641 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeArgumentList(this);
1642 		}
1643 	}
1644 
1645 	public final TypeArgumentListContext typeArgumentList() throws RecognitionException {
1646 		TypeArgumentListContext _localctx = new TypeArgumentListContext(_ctx, getState());
1647 		enterRule(_localctx, 42, RULE_typeArgumentList);
1648 		int _la;
1649 		try {
1650 			enterOuterAlt(_localctx, 1);
1651 			{
1652 			setState(664);
1653 			typeArgument();
1654 			setState(669);
1655 			_errHandler.sync(this);
1656 			_la = _input.LA(1);
1657 			while (_la==COMMA) {
1658 				{
1659 				{
1660 				setState(665);
1661 				match(COMMA);
1662 				setState(666);
1663 				typeArgument();
1664 				}
1665 				}
1666 				setState(671);
1667 				_errHandler.sync(this);
1668 				_la = _input.LA(1);
1669 			}
1670 			}
1671 		}
1672 		catch (RecognitionException re) {
1673 			_localctx.exception = re;
1674 			_errHandler.reportError(this, re);
1675 			_errHandler.recover(this, re);
1676 		}
1677 		finally {
1678 			exitRule();
1679 		}
1680 		return _localctx;
1681 	}
1682 
1683 	public static class TypeArgumentContext extends ParserRuleContext {
1684 		public ReferenceTypeContext referenceType() {
1685 			return getRuleContext(ReferenceTypeContext.class,0);
1686 		}
1687 		public WildcardContext wildcard() {
1688 			return getRuleContext(WildcardContext.class,0);
1689 		}
1690 		public TypeArgumentContext(ParserRuleContext parent, int invokingState) {
1691 			super(parent, invokingState);
1692 		}
1693 		@Override public int getRuleIndex() { return RULE_typeArgument; }
1694 		@Override
1695 		public void enterRule(ParseTreeListener listener) {
1696 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeArgument(this);
1697 		}
1698 		@Override
1699 		public void exitRule(ParseTreeListener listener) {
1700 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeArgument(this);
1701 		}
1702 	}
1703 
1704 	public final TypeArgumentContext typeArgument() throws RecognitionException {
1705 		TypeArgumentContext _localctx = new TypeArgumentContext(_ctx, getState());
1706 		enterRule(_localctx, 44, RULE_typeArgument);
1707 		try {
1708 			setState(674);
1709 			_errHandler.sync(this);
1710 			switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
1711 			case 1:
1712 				enterOuterAlt(_localctx, 1);
1713 				{
1714 				setState(672);
1715 				referenceType();
1716 				}
1717 				break;
1718 			case 2:
1719 				enterOuterAlt(_localctx, 2);
1720 				{
1721 				setState(673);
1722 				wildcard();
1723 				}
1724 				break;
1725 			}
1726 		}
1727 		catch (RecognitionException re) {
1728 			_localctx.exception = re;
1729 			_errHandler.reportError(this, re);
1730 			_errHandler.recover(this, re);
1731 		}
1732 		finally {
1733 			exitRule();
1734 		}
1735 		return _localctx;
1736 	}
1737 
1738 	public static class WildcardContext extends ParserRuleContext {
1739 		public List<AnnotationContext> annotation() {
1740 			return getRuleContexts(AnnotationContext.class);
1741 		}
1742 		public AnnotationContext annotation(int i) {
1743 			return getRuleContext(AnnotationContext.class,i);
1744 		}
1745 		public WildcardBoundsContext wildcardBounds() {
1746 			return getRuleContext(WildcardBoundsContext.class,0);
1747 		}
1748 		public WildcardContext(ParserRuleContext parent, int invokingState) {
1749 			super(parent, invokingState);
1750 		}
1751 		@Override public int getRuleIndex() { return RULE_wildcard; }
1752 		@Override
1753 		public void enterRule(ParseTreeListener listener) {
1754 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterWildcard(this);
1755 		}
1756 		@Override
1757 		public void exitRule(ParseTreeListener listener) {
1758 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitWildcard(this);
1759 		}
1760 	}
1761 
1762 	public final WildcardContext wildcard() throws RecognitionException {
1763 		WildcardContext _localctx = new WildcardContext(_ctx, getState());
1764 		enterRule(_localctx, 46, RULE_wildcard);
1765 		int _la;
1766 		try {
1767 			enterOuterAlt(_localctx, 1);
1768 			{
1769 			setState(679);
1770 			_errHandler.sync(this);
1771 			_la = _input.LA(1);
1772 			while (_la==AT) {
1773 				{
1774 				{
1775 				setState(676);
1776 				annotation();
1777 				}
1778 				}
1779 				setState(681);
1780 				_errHandler.sync(this);
1781 				_la = _input.LA(1);
1782 			}
1783 			setState(682);
1784 			match(QUESTION);
1785 			setState(684);
1786 			_errHandler.sync(this);
1787 			_la = _input.LA(1);
1788 			if (_la==EXTENDS || _la==SUPER) {
1789 				{
1790 				setState(683);
1791 				wildcardBounds();
1792 				}
1793 			}
1794 
1795 			}
1796 		}
1797 		catch (RecognitionException re) {
1798 			_localctx.exception = re;
1799 			_errHandler.reportError(this, re);
1800 			_errHandler.recover(this, re);
1801 		}
1802 		finally {
1803 			exitRule();
1804 		}
1805 		return _localctx;
1806 	}
1807 
1808 	public static class WildcardBoundsContext extends ParserRuleContext {
1809 		public ReferenceTypeContext referenceType() {
1810 			return getRuleContext(ReferenceTypeContext.class,0);
1811 		}
1812 		public WildcardBoundsContext(ParserRuleContext parent, int invokingState) {
1813 			super(parent, invokingState);
1814 		}
1815 		@Override public int getRuleIndex() { return RULE_wildcardBounds; }
1816 		@Override
1817 		public void enterRule(ParseTreeListener listener) {
1818 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterWildcardBounds(this);
1819 		}
1820 		@Override
1821 		public void exitRule(ParseTreeListener listener) {
1822 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitWildcardBounds(this);
1823 		}
1824 	}
1825 
1826 	public final WildcardBoundsContext wildcardBounds() throws RecognitionException {
1827 		WildcardBoundsContext _localctx = new WildcardBoundsContext(_ctx, getState());
1828 		enterRule(_localctx, 48, RULE_wildcardBounds);
1829 		try {
1830 			setState(690);
1831 			_errHandler.sync(this);
1832 			switch (_input.LA(1)) {
1833 			case EXTENDS:
1834 				enterOuterAlt(_localctx, 1);
1835 				{
1836 				setState(686);
1837 				match(EXTENDS);
1838 				setState(687);
1839 				referenceType();
1840 				}
1841 				break;
1842 			case SUPER:
1843 				enterOuterAlt(_localctx, 2);
1844 				{
1845 				setState(688);
1846 				match(SUPER);
1847 				setState(689);
1848 				referenceType();
1849 				}
1850 				break;
1851 			default:
1852 				throw new NoViableAltException(this);
1853 			}
1854 		}
1855 		catch (RecognitionException re) {
1856 			_localctx.exception = re;
1857 			_errHandler.reportError(this, re);
1858 			_errHandler.recover(this, re);
1859 		}
1860 		finally {
1861 			exitRule();
1862 		}
1863 		return _localctx;
1864 	}
1865 
1866 	public static class ModuleNameContext extends ParserRuleContext {
1867 		public IdentifierContext identifier() {
1868 			return getRuleContext(IdentifierContext.class,0);
1869 		}
1870 		public ModuleNameContext moduleName() {
1871 			return getRuleContext(ModuleNameContext.class,0);
1872 		}
1873 		public ModuleNameContext(ParserRuleContext parent, int invokingState) {
1874 			super(parent, invokingState);
1875 		}
1876 		@Override public int getRuleIndex() { return RULE_moduleName; }
1877 		@Override
1878 		public void enterRule(ParseTreeListener listener) {
1879 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterModuleName(this);
1880 		}
1881 		@Override
1882 		public void exitRule(ParseTreeListener listener) {
1883 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitModuleName(this);
1884 		}
1885 	}
1886 
1887 	public final ModuleNameContext moduleName() throws RecognitionException {
1888 		return moduleName(0);
1889 	}
1890 
1891 	private ModuleNameContext moduleName(int _p) throws RecognitionException {
1892 		ParserRuleContext _parentctx = _ctx;
1893 		int _parentState = getState();
1894 		ModuleNameContext _localctx = new ModuleNameContext(_ctx, _parentState);
1895 		ModuleNameContext _prevctx = _localctx;
1896 		int _startState = 50;
1897 		enterRecursionRule(_localctx, 50, RULE_moduleName, _p);
1898 		try {
1899 			int _alt;
1900 			enterOuterAlt(_localctx, 1);
1901 			{
1902 			{
1903 			setState(693);
1904 			identifier();
1905 			}
1906 			_ctx.stop = _input.LT(-1);
1907 			setState(700);
1908 			_errHandler.sync(this);
1909 			_alt = getInterpreter().adaptivePredict(_input,31,_ctx);
1910 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1911 				if ( _alt==1 ) {
1912 					if ( _parseListeners!=null ) triggerExitRuleEvent();
1913 					_prevctx = _localctx;
1914 					{
1915 					{
1916 					_localctx = new ModuleNameContext(_parentctx, _parentState);
1917 					pushNewRecursionContext(_localctx, _startState, RULE_moduleName);
1918 					setState(695);
1919 					if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
1920 					setState(696);
1921 					match(DOT);
1922 					setState(697);
1923 					identifier();
1924 					}
1925 					} 
1926 				}
1927 				setState(702);
1928 				_errHandler.sync(this);
1929 				_alt = getInterpreter().adaptivePredict(_input,31,_ctx);
1930 			}
1931 			}
1932 		}
1933 		catch (RecognitionException re) {
1934 			_localctx.exception = re;
1935 			_errHandler.reportError(this, re);
1936 			_errHandler.recover(this, re);
1937 		}
1938 		finally {
1939 			unrollRecursionContexts(_parentctx);
1940 		}
1941 		return _localctx;
1942 	}
1943 
1944 	public static class PackageNameContext extends ParserRuleContext {
1945 		public IdentifierContext identifier() {
1946 			return getRuleContext(IdentifierContext.class,0);
1947 		}
1948 		public PackageNameContext packageName() {
1949 			return getRuleContext(PackageNameContext.class,0);
1950 		}
1951 		public PackageNameContext(ParserRuleContext parent, int invokingState) {
1952 			super(parent, invokingState);
1953 		}
1954 		@Override public int getRuleIndex() { return RULE_packageName; }
1955 		@Override
1956 		public void enterRule(ParseTreeListener listener) {
1957 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPackageName(this);
1958 		}
1959 		@Override
1960 		public void exitRule(ParseTreeListener listener) {
1961 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPackageName(this);
1962 		}
1963 	}
1964 
1965 	public final PackageNameContext packageName() throws RecognitionException {
1966 		return packageName(0);
1967 	}
1968 
1969 	private PackageNameContext packageName(int _p) throws RecognitionException {
1970 		ParserRuleContext _parentctx = _ctx;
1971 		int _parentState = getState();
1972 		PackageNameContext _localctx = new PackageNameContext(_ctx, _parentState);
1973 		PackageNameContext _prevctx = _localctx;
1974 		int _startState = 52;
1975 		enterRecursionRule(_localctx, 52, RULE_packageName, _p);
1976 		try {
1977 			int _alt;
1978 			enterOuterAlt(_localctx, 1);
1979 			{
1980 			{
1981 			setState(704);
1982 			identifier();
1983 			}
1984 			_ctx.stop = _input.LT(-1);
1985 			setState(711);
1986 			_errHandler.sync(this);
1987 			_alt = getInterpreter().adaptivePredict(_input,32,_ctx);
1988 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
1989 				if ( _alt==1 ) {
1990 					if ( _parseListeners!=null ) triggerExitRuleEvent();
1991 					_prevctx = _localctx;
1992 					{
1993 					{
1994 					_localctx = new PackageNameContext(_parentctx, _parentState);
1995 					pushNewRecursionContext(_localctx, _startState, RULE_packageName);
1996 					setState(706);
1997 					if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
1998 					setState(707);
1999 					match(DOT);
2000 					setState(708);
2001 					identifier();
2002 					}
2003 					} 
2004 				}
2005 				setState(713);
2006 				_errHandler.sync(this);
2007 				_alt = getInterpreter().adaptivePredict(_input,32,_ctx);
2008 			}
2009 			}
2010 		}
2011 		catch (RecognitionException re) {
2012 			_localctx.exception = re;
2013 			_errHandler.reportError(this, re);
2014 			_errHandler.recover(this, re);
2015 		}
2016 		finally {
2017 			unrollRecursionContexts(_parentctx);
2018 		}
2019 		return _localctx;
2020 	}
2021 
2022 	public static class TypeNameContext extends ParserRuleContext {
2023 		public IdentifierContext identifier() {
2024 			return getRuleContext(IdentifierContext.class,0);
2025 		}
2026 		public PackageOrTypeNameContext packageOrTypeName() {
2027 			return getRuleContext(PackageOrTypeNameContext.class,0);
2028 		}
2029 		public TypeNameContext(ParserRuleContext parent, int invokingState) {
2030 			super(parent, invokingState);
2031 		}
2032 		@Override public int getRuleIndex() { return RULE_typeName; }
2033 		@Override
2034 		public void enterRule(ParseTreeListener listener) {
2035 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeName(this);
2036 		}
2037 		@Override
2038 		public void exitRule(ParseTreeListener listener) {
2039 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeName(this);
2040 		}
2041 	}
2042 
2043 	public final TypeNameContext typeName() throws RecognitionException {
2044 		TypeNameContext _localctx = new TypeNameContext(_ctx, getState());
2045 		enterRule(_localctx, 54, RULE_typeName);
2046 		try {
2047 			setState(719);
2048 			_errHandler.sync(this);
2049 			switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) {
2050 			case 1:
2051 				enterOuterAlt(_localctx, 1);
2052 				{
2053 				setState(714);
2054 				identifier();
2055 				}
2056 				break;
2057 			case 2:
2058 				enterOuterAlt(_localctx, 2);
2059 				{
2060 				setState(715);
2061 				packageOrTypeName(0);
2062 				setState(716);
2063 				match(DOT);
2064 				setState(717);
2065 				identifier();
2066 				}
2067 				break;
2068 			}
2069 		}
2070 		catch (RecognitionException re) {
2071 			_localctx.exception = re;
2072 			_errHandler.reportError(this, re);
2073 			_errHandler.recover(this, re);
2074 		}
2075 		finally {
2076 			exitRule();
2077 		}
2078 		return _localctx;
2079 	}
2080 
2081 	public static class PackageOrTypeNameContext extends ParserRuleContext {
2082 		public IdentifierContext identifier() {
2083 			return getRuleContext(IdentifierContext.class,0);
2084 		}
2085 		public PackageOrTypeNameContext packageOrTypeName() {
2086 			return getRuleContext(PackageOrTypeNameContext.class,0);
2087 		}
2088 		public PackageOrTypeNameContext(ParserRuleContext parent, int invokingState) {
2089 			super(parent, invokingState);
2090 		}
2091 		@Override public int getRuleIndex() { return RULE_packageOrTypeName; }
2092 		@Override
2093 		public void enterRule(ParseTreeListener listener) {
2094 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPackageOrTypeName(this);
2095 		}
2096 		@Override
2097 		public void exitRule(ParseTreeListener listener) {
2098 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPackageOrTypeName(this);
2099 		}
2100 	}
2101 
2102 	public final PackageOrTypeNameContext packageOrTypeName() throws RecognitionException {
2103 		return packageOrTypeName(0);
2104 	}
2105 
2106 	private PackageOrTypeNameContext packageOrTypeName(int _p) throws RecognitionException {
2107 		ParserRuleContext _parentctx = _ctx;
2108 		int _parentState = getState();
2109 		PackageOrTypeNameContext _localctx = new PackageOrTypeNameContext(_ctx, _parentState);
2110 		PackageOrTypeNameContext _prevctx = _localctx;
2111 		int _startState = 56;
2112 		enterRecursionRule(_localctx, 56, RULE_packageOrTypeName, _p);
2113 		try {
2114 			int _alt;
2115 			enterOuterAlt(_localctx, 1);
2116 			{
2117 			{
2118 			setState(722);
2119 			identifier();
2120 			}
2121 			_ctx.stop = _input.LT(-1);
2122 			setState(729);
2123 			_errHandler.sync(this);
2124 			_alt = getInterpreter().adaptivePredict(_input,34,_ctx);
2125 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
2126 				if ( _alt==1 ) {
2127 					if ( _parseListeners!=null ) triggerExitRuleEvent();
2128 					_prevctx = _localctx;
2129 					{
2130 					{
2131 					_localctx = new PackageOrTypeNameContext(_parentctx, _parentState);
2132 					pushNewRecursionContext(_localctx, _startState, RULE_packageOrTypeName);
2133 					setState(724);
2134 					if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
2135 					setState(725);
2136 					match(DOT);
2137 					setState(726);
2138 					identifier();
2139 					}
2140 					} 
2141 				}
2142 				setState(731);
2143 				_errHandler.sync(this);
2144 				_alt = getInterpreter().adaptivePredict(_input,34,_ctx);
2145 			}
2146 			}
2147 		}
2148 		catch (RecognitionException re) {
2149 			_localctx.exception = re;
2150 			_errHandler.reportError(this, re);
2151 			_errHandler.recover(this, re);
2152 		}
2153 		finally {
2154 			unrollRecursionContexts(_parentctx);
2155 		}
2156 		return _localctx;
2157 	}
2158 
2159 	public static class ExpressionNameContext extends ParserRuleContext {
2160 		public IdentifierContext identifier() {
2161 			return getRuleContext(IdentifierContext.class,0);
2162 		}
2163 		public AmbiguousNameContext ambiguousName() {
2164 			return getRuleContext(AmbiguousNameContext.class,0);
2165 		}
2166 		public ExpressionNameContext(ParserRuleContext parent, int invokingState) {
2167 			super(parent, invokingState);
2168 		}
2169 		@Override public int getRuleIndex() { return RULE_expressionName; }
2170 		@Override
2171 		public void enterRule(ParseTreeListener listener) {
2172 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterExpressionName(this);
2173 		}
2174 		@Override
2175 		public void exitRule(ParseTreeListener listener) {
2176 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitExpressionName(this);
2177 		}
2178 	}
2179 
2180 	public final ExpressionNameContext expressionName() throws RecognitionException {
2181 		ExpressionNameContext _localctx = new ExpressionNameContext(_ctx, getState());
2182 		enterRule(_localctx, 58, RULE_expressionName);
2183 		try {
2184 			setState(737);
2185 			_errHandler.sync(this);
2186 			switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) {
2187 			case 1:
2188 				enterOuterAlt(_localctx, 1);
2189 				{
2190 				setState(732);
2191 				identifier();
2192 				}
2193 				break;
2194 			case 2:
2195 				enterOuterAlt(_localctx, 2);
2196 				{
2197 				setState(733);
2198 				ambiguousName(0);
2199 				setState(734);
2200 				match(DOT);
2201 				setState(735);
2202 				identifier();
2203 				}
2204 				break;
2205 			}
2206 		}
2207 		catch (RecognitionException re) {
2208 			_localctx.exception = re;
2209 			_errHandler.reportError(this, re);
2210 			_errHandler.recover(this, re);
2211 		}
2212 		finally {
2213 			exitRule();
2214 		}
2215 		return _localctx;
2216 	}
2217 
2218 	public static class MethodNameContext extends ParserRuleContext {
2219 		public IdentifierContext identifier() {
2220 			return getRuleContext(IdentifierContext.class,0);
2221 		}
2222 		public MethodNameContext(ParserRuleContext parent, int invokingState) {
2223 			super(parent, invokingState);
2224 		}
2225 		@Override public int getRuleIndex() { return RULE_methodName; }
2226 		@Override
2227 		public void enterRule(ParseTreeListener listener) {
2228 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterMethodName(this);
2229 		}
2230 		@Override
2231 		public void exitRule(ParseTreeListener listener) {
2232 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitMethodName(this);
2233 		}
2234 	}
2235 
2236 	public final MethodNameContext methodName() throws RecognitionException {
2237 		MethodNameContext _localctx = new MethodNameContext(_ctx, getState());
2238 		enterRule(_localctx, 60, RULE_methodName);
2239 		try {
2240 			enterOuterAlt(_localctx, 1);
2241 			{
2242 			setState(739);
2243 			identifier();
2244 			}
2245 		}
2246 		catch (RecognitionException re) {
2247 			_localctx.exception = re;
2248 			_errHandler.reportError(this, re);
2249 			_errHandler.recover(this, re);
2250 		}
2251 		finally {
2252 			exitRule();
2253 		}
2254 		return _localctx;
2255 	}
2256 
2257 	public static class AmbiguousNameContext extends ParserRuleContext {
2258 		public IdentifierContext identifier() {
2259 			return getRuleContext(IdentifierContext.class,0);
2260 		}
2261 		public AmbiguousNameContext ambiguousName() {
2262 			return getRuleContext(AmbiguousNameContext.class,0);
2263 		}
2264 		public AmbiguousNameContext(ParserRuleContext parent, int invokingState) {
2265 			super(parent, invokingState);
2266 		}
2267 		@Override public int getRuleIndex() { return RULE_ambiguousName; }
2268 		@Override
2269 		public void enterRule(ParseTreeListener listener) {
2270 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterAmbiguousName(this);
2271 		}
2272 		@Override
2273 		public void exitRule(ParseTreeListener listener) {
2274 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitAmbiguousName(this);
2275 		}
2276 	}
2277 
2278 	public final AmbiguousNameContext ambiguousName() throws RecognitionException {
2279 		return ambiguousName(0);
2280 	}
2281 
2282 	private AmbiguousNameContext ambiguousName(int _p) throws RecognitionException {
2283 		ParserRuleContext _parentctx = _ctx;
2284 		int _parentState = getState();
2285 		AmbiguousNameContext _localctx = new AmbiguousNameContext(_ctx, _parentState);
2286 		AmbiguousNameContext _prevctx = _localctx;
2287 		int _startState = 62;
2288 		enterRecursionRule(_localctx, 62, RULE_ambiguousName, _p);
2289 		try {
2290 			int _alt;
2291 			enterOuterAlt(_localctx, 1);
2292 			{
2293 			{
2294 			setState(742);
2295 			identifier();
2296 			}
2297 			_ctx.stop = _input.LT(-1);
2298 			setState(749);
2299 			_errHandler.sync(this);
2300 			_alt = getInterpreter().adaptivePredict(_input,36,_ctx);
2301 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
2302 				if ( _alt==1 ) {
2303 					if ( _parseListeners!=null ) triggerExitRuleEvent();
2304 					_prevctx = _localctx;
2305 					{
2306 					{
2307 					_localctx = new AmbiguousNameContext(_parentctx, _parentState);
2308 					pushNewRecursionContext(_localctx, _startState, RULE_ambiguousName);
2309 					setState(744);
2310 					if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
2311 					setState(745);
2312 					match(DOT);
2313 					setState(746);
2314 					identifier();
2315 					}
2316 					} 
2317 				}
2318 				setState(751);
2319 				_errHandler.sync(this);
2320 				_alt = getInterpreter().adaptivePredict(_input,36,_ctx);
2321 			}
2322 			}
2323 		}
2324 		catch (RecognitionException re) {
2325 			_localctx.exception = re;
2326 			_errHandler.reportError(this, re);
2327 			_errHandler.recover(this, re);
2328 		}
2329 		finally {
2330 			unrollRecursionContexts(_parentctx);
2331 		}
2332 		return _localctx;
2333 	}
2334 
2335 	public static class CompilationUnitContext extends ParserRuleContext {
2336 		public OrdinaryCompilationContext ordinaryCompilation() {
2337 			return getRuleContext(OrdinaryCompilationContext.class,0);
2338 		}
2339 		public ModularCompilationContext modularCompilation() {
2340 			return getRuleContext(ModularCompilationContext.class,0);
2341 		}
2342 		public CompilationUnitContext(ParserRuleContext parent, int invokingState) {
2343 			super(parent, invokingState);
2344 		}
2345 		@Override public int getRuleIndex() { return RULE_compilationUnit; }
2346 		@Override
2347 		public void enterRule(ParseTreeListener listener) {
2348 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterCompilationUnit(this);
2349 		}
2350 		@Override
2351 		public void exitRule(ParseTreeListener listener) {
2352 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitCompilationUnit(this);
2353 		}
2354 	}
2355 
2356 	public final CompilationUnitContext compilationUnit() throws RecognitionException {
2357 		CompilationUnitContext _localctx = new CompilationUnitContext(_ctx, getState());
2358 		enterRule(_localctx, 64, RULE_compilationUnit);
2359 		try {
2360 			setState(754);
2361 			_errHandler.sync(this);
2362 			switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) {
2363 			case 1:
2364 				enterOuterAlt(_localctx, 1);
2365 				{
2366 				setState(752);
2367 				ordinaryCompilation();
2368 				}
2369 				break;
2370 			case 2:
2371 				enterOuterAlt(_localctx, 2);
2372 				{
2373 				setState(753);
2374 				modularCompilation();
2375 				}
2376 				break;
2377 			}
2378 		}
2379 		catch (RecognitionException re) {
2380 			_localctx.exception = re;
2381 			_errHandler.reportError(this, re);
2382 			_errHandler.recover(this, re);
2383 		}
2384 		finally {
2385 			exitRule();
2386 		}
2387 		return _localctx;
2388 	}
2389 
2390 	public static class OrdinaryCompilationContext extends ParserRuleContext {
2391 		public TerminalNode EOF() { return getToken(Java9Parser.EOF, 0); }
2392 		public PackageDeclarationContext packageDeclaration() {
2393 			return getRuleContext(PackageDeclarationContext.class,0);
2394 		}
2395 		public List<ImportDeclarationContext> importDeclaration() {
2396 			return getRuleContexts(ImportDeclarationContext.class);
2397 		}
2398 		public ImportDeclarationContext importDeclaration(int i) {
2399 			return getRuleContext(ImportDeclarationContext.class,i);
2400 		}
2401 		public List<TypeDeclarationContext> typeDeclaration() {
2402 			return getRuleContexts(TypeDeclarationContext.class);
2403 		}
2404 		public TypeDeclarationContext typeDeclaration(int i) {
2405 			return getRuleContext(TypeDeclarationContext.class,i);
2406 		}
2407 		public OrdinaryCompilationContext(ParserRuleContext parent, int invokingState) {
2408 			super(parent, invokingState);
2409 		}
2410 		@Override public int getRuleIndex() { return RULE_ordinaryCompilation; }
2411 		@Override
2412 		public void enterRule(ParseTreeListener listener) {
2413 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterOrdinaryCompilation(this);
2414 		}
2415 		@Override
2416 		public void exitRule(ParseTreeListener listener) {
2417 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitOrdinaryCompilation(this);
2418 		}
2419 	}
2420 
2421 	public final OrdinaryCompilationContext ordinaryCompilation() throws RecognitionException {
2422 		OrdinaryCompilationContext _localctx = new OrdinaryCompilationContext(_ctx, getState());
2423 		enterRule(_localctx, 66, RULE_ordinaryCompilation);
2424 		int _la;
2425 		try {
2426 			enterOuterAlt(_localctx, 1);
2427 			{
2428 			setState(757);
2429 			_errHandler.sync(this);
2430 			switch ( getInterpreter().adaptivePredict(_input,38,_ctx) ) {
2431 			case 1:
2432 				{
2433 				setState(756);
2434 				packageDeclaration();
2435 				}
2436 				break;
2437 			}
2438 			setState(762);
2439 			_errHandler.sync(this);
2440 			_la = _input.LA(1);
2441 			while (_la==IMPORT) {
2442 				{
2443 				{
2444 				setState(759);
2445 				importDeclaration();
2446 				}
2447 				}
2448 				setState(764);
2449 				_errHandler.sync(this);
2450 				_la = _input.LA(1);
2451 			}
2452 			setState(768);
2453 			_errHandler.sync(this);
2454 			_la = _input.LA(1);
2455 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << CLASS) | (1L << ENUM) | (1L << FINAL) | (1L << INTERFACE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==SEMI || _la==AT) {
2456 				{
2457 				{
2458 				setState(765);
2459 				typeDeclaration();
2460 				}
2461 				}
2462 				setState(770);
2463 				_errHandler.sync(this);
2464 				_la = _input.LA(1);
2465 			}
2466 			setState(771);
2467 			match(EOF);
2468 			}
2469 		}
2470 		catch (RecognitionException re) {
2471 			_localctx.exception = re;
2472 			_errHandler.reportError(this, re);
2473 			_errHandler.recover(this, re);
2474 		}
2475 		finally {
2476 			exitRule();
2477 		}
2478 		return _localctx;
2479 	}
2480 
2481 	public static class ModularCompilationContext extends ParserRuleContext {
2482 		public ModuleDeclarationContext moduleDeclaration() {
2483 			return getRuleContext(ModuleDeclarationContext.class,0);
2484 		}
2485 		public List<ImportDeclarationContext> importDeclaration() {
2486 			return getRuleContexts(ImportDeclarationContext.class);
2487 		}
2488 		public ImportDeclarationContext importDeclaration(int i) {
2489 			return getRuleContext(ImportDeclarationContext.class,i);
2490 		}
2491 		public ModularCompilationContext(ParserRuleContext parent, int invokingState) {
2492 			super(parent, invokingState);
2493 		}
2494 		@Override public int getRuleIndex() { return RULE_modularCompilation; }
2495 		@Override
2496 		public void enterRule(ParseTreeListener listener) {
2497 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterModularCompilation(this);
2498 		}
2499 		@Override
2500 		public void exitRule(ParseTreeListener listener) {
2501 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitModularCompilation(this);
2502 		}
2503 	}
2504 
2505 	public final ModularCompilationContext modularCompilation() throws RecognitionException {
2506 		ModularCompilationContext _localctx = new ModularCompilationContext(_ctx, getState());
2507 		enterRule(_localctx, 68, RULE_modularCompilation);
2508 		int _la;
2509 		try {
2510 			enterOuterAlt(_localctx, 1);
2511 			{
2512 			setState(776);
2513 			_errHandler.sync(this);
2514 			_la = _input.LA(1);
2515 			while (_la==IMPORT) {
2516 				{
2517 				{
2518 				setState(773);
2519 				importDeclaration();
2520 				}
2521 				}
2522 				setState(778);
2523 				_errHandler.sync(this);
2524 				_la = _input.LA(1);
2525 			}
2526 			setState(779);
2527 			moduleDeclaration();
2528 			}
2529 		}
2530 		catch (RecognitionException re) {
2531 			_localctx.exception = re;
2532 			_errHandler.reportError(this, re);
2533 			_errHandler.recover(this, re);
2534 		}
2535 		finally {
2536 			exitRule();
2537 		}
2538 		return _localctx;
2539 	}
2540 
2541 	public static class PackageDeclarationContext extends ParserRuleContext {
2542 		public PackageNameContext packageName() {
2543 			return getRuleContext(PackageNameContext.class,0);
2544 		}
2545 		public List<PackageModifierContext> packageModifier() {
2546 			return getRuleContexts(PackageModifierContext.class);
2547 		}
2548 		public PackageModifierContext packageModifier(int i) {
2549 			return getRuleContext(PackageModifierContext.class,i);
2550 		}
2551 		public PackageDeclarationContext(ParserRuleContext parent, int invokingState) {
2552 			super(parent, invokingState);
2553 		}
2554 		@Override public int getRuleIndex() { return RULE_packageDeclaration; }
2555 		@Override
2556 		public void enterRule(ParseTreeListener listener) {
2557 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPackageDeclaration(this);
2558 		}
2559 		@Override
2560 		public void exitRule(ParseTreeListener listener) {
2561 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPackageDeclaration(this);
2562 		}
2563 	}
2564 
2565 	public final PackageDeclarationContext packageDeclaration() throws RecognitionException {
2566 		PackageDeclarationContext _localctx = new PackageDeclarationContext(_ctx, getState());
2567 		enterRule(_localctx, 70, RULE_packageDeclaration);
2568 		int _la;
2569 		try {
2570 			enterOuterAlt(_localctx, 1);
2571 			{
2572 			setState(784);
2573 			_errHandler.sync(this);
2574 			_la = _input.LA(1);
2575 			while (_la==AT) {
2576 				{
2577 				{
2578 				setState(781);
2579 				packageModifier();
2580 				}
2581 				}
2582 				setState(786);
2583 				_errHandler.sync(this);
2584 				_la = _input.LA(1);
2585 			}
2586 			setState(787);
2587 			match(PACKAGE);
2588 			setState(788);
2589 			packageName(0);
2590 			setState(789);
2591 			match(SEMI);
2592 			}
2593 		}
2594 		catch (RecognitionException re) {
2595 			_localctx.exception = re;
2596 			_errHandler.reportError(this, re);
2597 			_errHandler.recover(this, re);
2598 		}
2599 		finally {
2600 			exitRule();
2601 		}
2602 		return _localctx;
2603 	}
2604 
2605 	public static class PackageModifierContext extends ParserRuleContext {
2606 		public AnnotationContext annotation() {
2607 			return getRuleContext(AnnotationContext.class,0);
2608 		}
2609 		public PackageModifierContext(ParserRuleContext parent, int invokingState) {
2610 			super(parent, invokingState);
2611 		}
2612 		@Override public int getRuleIndex() { return RULE_packageModifier; }
2613 		@Override
2614 		public void enterRule(ParseTreeListener listener) {
2615 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPackageModifier(this);
2616 		}
2617 		@Override
2618 		public void exitRule(ParseTreeListener listener) {
2619 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPackageModifier(this);
2620 		}
2621 	}
2622 
2623 	public final PackageModifierContext packageModifier() throws RecognitionException {
2624 		PackageModifierContext _localctx = new PackageModifierContext(_ctx, getState());
2625 		enterRule(_localctx, 72, RULE_packageModifier);
2626 		try {
2627 			enterOuterAlt(_localctx, 1);
2628 			{
2629 			setState(791);
2630 			annotation();
2631 			}
2632 		}
2633 		catch (RecognitionException re) {
2634 			_localctx.exception = re;
2635 			_errHandler.reportError(this, re);
2636 			_errHandler.recover(this, re);
2637 		}
2638 		finally {
2639 			exitRule();
2640 		}
2641 		return _localctx;
2642 	}
2643 
2644 	public static class ImportDeclarationContext extends ParserRuleContext {
2645 		public SingleTypeImportDeclarationContext singleTypeImportDeclaration() {
2646 			return getRuleContext(SingleTypeImportDeclarationContext.class,0);
2647 		}
2648 		public TypeImportOnDemandDeclarationContext typeImportOnDemandDeclaration() {
2649 			return getRuleContext(TypeImportOnDemandDeclarationContext.class,0);
2650 		}
2651 		public SingleStaticImportDeclarationContext singleStaticImportDeclaration() {
2652 			return getRuleContext(SingleStaticImportDeclarationContext.class,0);
2653 		}
2654 		public StaticImportOnDemandDeclarationContext staticImportOnDemandDeclaration() {
2655 			return getRuleContext(StaticImportOnDemandDeclarationContext.class,0);
2656 		}
2657 		public ImportDeclarationContext(ParserRuleContext parent, int invokingState) {
2658 			super(parent, invokingState);
2659 		}
2660 		@Override public int getRuleIndex() { return RULE_importDeclaration; }
2661 		@Override
2662 		public void enterRule(ParseTreeListener listener) {
2663 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterImportDeclaration(this);
2664 		}
2665 		@Override
2666 		public void exitRule(ParseTreeListener listener) {
2667 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitImportDeclaration(this);
2668 		}
2669 	}
2670 
2671 	public final ImportDeclarationContext importDeclaration() throws RecognitionException {
2672 		ImportDeclarationContext _localctx = new ImportDeclarationContext(_ctx, getState());
2673 		enterRule(_localctx, 74, RULE_importDeclaration);
2674 		try {
2675 			setState(797);
2676 			_errHandler.sync(this);
2677 			switch ( getInterpreter().adaptivePredict(_input,43,_ctx) ) {
2678 			case 1:
2679 				enterOuterAlt(_localctx, 1);
2680 				{
2681 				setState(793);
2682 				singleTypeImportDeclaration();
2683 				}
2684 				break;
2685 			case 2:
2686 				enterOuterAlt(_localctx, 2);
2687 				{
2688 				setState(794);
2689 				typeImportOnDemandDeclaration();
2690 				}
2691 				break;
2692 			case 3:
2693 				enterOuterAlt(_localctx, 3);
2694 				{
2695 				setState(795);
2696 				singleStaticImportDeclaration();
2697 				}
2698 				break;
2699 			case 4:
2700 				enterOuterAlt(_localctx, 4);
2701 				{
2702 				setState(796);
2703 				staticImportOnDemandDeclaration();
2704 				}
2705 				break;
2706 			}
2707 		}
2708 		catch (RecognitionException re) {
2709 			_localctx.exception = re;
2710 			_errHandler.reportError(this, re);
2711 			_errHandler.recover(this, re);
2712 		}
2713 		finally {
2714 			exitRule();
2715 		}
2716 		return _localctx;
2717 	}
2718 
2719 	public static class SingleTypeImportDeclarationContext extends ParserRuleContext {
2720 		public TypeNameContext typeName() {
2721 			return getRuleContext(TypeNameContext.class,0);
2722 		}
2723 		public SingleTypeImportDeclarationContext(ParserRuleContext parent, int invokingState) {
2724 			super(parent, invokingState);
2725 		}
2726 		@Override public int getRuleIndex() { return RULE_singleTypeImportDeclaration; }
2727 		@Override
2728 		public void enterRule(ParseTreeListener listener) {
2729 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterSingleTypeImportDeclaration(this);
2730 		}
2731 		@Override
2732 		public void exitRule(ParseTreeListener listener) {
2733 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitSingleTypeImportDeclaration(this);
2734 		}
2735 	}
2736 
2737 	public final SingleTypeImportDeclarationContext singleTypeImportDeclaration() throws RecognitionException {
2738 		SingleTypeImportDeclarationContext _localctx = new SingleTypeImportDeclarationContext(_ctx, getState());
2739 		enterRule(_localctx, 76, RULE_singleTypeImportDeclaration);
2740 		try {
2741 			enterOuterAlt(_localctx, 1);
2742 			{
2743 			setState(799);
2744 			match(IMPORT);
2745 			setState(800);
2746 			typeName();
2747 			setState(801);
2748 			match(SEMI);
2749 			}
2750 		}
2751 		catch (RecognitionException re) {
2752 			_localctx.exception = re;
2753 			_errHandler.reportError(this, re);
2754 			_errHandler.recover(this, re);
2755 		}
2756 		finally {
2757 			exitRule();
2758 		}
2759 		return _localctx;
2760 	}
2761 
2762 	public static class TypeImportOnDemandDeclarationContext extends ParserRuleContext {
2763 		public PackageOrTypeNameContext packageOrTypeName() {
2764 			return getRuleContext(PackageOrTypeNameContext.class,0);
2765 		}
2766 		public TypeImportOnDemandDeclarationContext(ParserRuleContext parent, int invokingState) {
2767 			super(parent, invokingState);
2768 		}
2769 		@Override public int getRuleIndex() { return RULE_typeImportOnDemandDeclaration; }
2770 		@Override
2771 		public void enterRule(ParseTreeListener listener) {
2772 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeImportOnDemandDeclaration(this);
2773 		}
2774 		@Override
2775 		public void exitRule(ParseTreeListener listener) {
2776 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeImportOnDemandDeclaration(this);
2777 		}
2778 	}
2779 
2780 	public final TypeImportOnDemandDeclarationContext typeImportOnDemandDeclaration() throws RecognitionException {
2781 		TypeImportOnDemandDeclarationContext _localctx = new TypeImportOnDemandDeclarationContext(_ctx, getState());
2782 		enterRule(_localctx, 78, RULE_typeImportOnDemandDeclaration);
2783 		try {
2784 			enterOuterAlt(_localctx, 1);
2785 			{
2786 			setState(803);
2787 			match(IMPORT);
2788 			setState(804);
2789 			packageOrTypeName(0);
2790 			setState(805);
2791 			match(DOT);
2792 			setState(806);
2793 			match(MUL);
2794 			setState(807);
2795 			match(SEMI);
2796 			}
2797 		}
2798 		catch (RecognitionException re) {
2799 			_localctx.exception = re;
2800 			_errHandler.reportError(this, re);
2801 			_errHandler.recover(this, re);
2802 		}
2803 		finally {
2804 			exitRule();
2805 		}
2806 		return _localctx;
2807 	}
2808 
2809 	public static class SingleStaticImportDeclarationContext extends ParserRuleContext {
2810 		public TypeNameContext typeName() {
2811 			return getRuleContext(TypeNameContext.class,0);
2812 		}
2813 		public IdentifierContext identifier() {
2814 			return getRuleContext(IdentifierContext.class,0);
2815 		}
2816 		public SingleStaticImportDeclarationContext(ParserRuleContext parent, int invokingState) {
2817 			super(parent, invokingState);
2818 		}
2819 		@Override public int getRuleIndex() { return RULE_singleStaticImportDeclaration; }
2820 		@Override
2821 		public void enterRule(ParseTreeListener listener) {
2822 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterSingleStaticImportDeclaration(this);
2823 		}
2824 		@Override
2825 		public void exitRule(ParseTreeListener listener) {
2826 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitSingleStaticImportDeclaration(this);
2827 		}
2828 	}
2829 
2830 	public final SingleStaticImportDeclarationContext singleStaticImportDeclaration() throws RecognitionException {
2831 		SingleStaticImportDeclarationContext _localctx = new SingleStaticImportDeclarationContext(_ctx, getState());
2832 		enterRule(_localctx, 80, RULE_singleStaticImportDeclaration);
2833 		try {
2834 			enterOuterAlt(_localctx, 1);
2835 			{
2836 			setState(809);
2837 			match(IMPORT);
2838 			setState(810);
2839 			match(STATIC);
2840 			setState(811);
2841 			typeName();
2842 			setState(812);
2843 			match(DOT);
2844 			setState(813);
2845 			identifier();
2846 			setState(814);
2847 			match(SEMI);
2848 			}
2849 		}
2850 		catch (RecognitionException re) {
2851 			_localctx.exception = re;
2852 			_errHandler.reportError(this, re);
2853 			_errHandler.recover(this, re);
2854 		}
2855 		finally {
2856 			exitRule();
2857 		}
2858 		return _localctx;
2859 	}
2860 
2861 	public static class StaticImportOnDemandDeclarationContext extends ParserRuleContext {
2862 		public TypeNameContext typeName() {
2863 			return getRuleContext(TypeNameContext.class,0);
2864 		}
2865 		public StaticImportOnDemandDeclarationContext(ParserRuleContext parent, int invokingState) {
2866 			super(parent, invokingState);
2867 		}
2868 		@Override public int getRuleIndex() { return RULE_staticImportOnDemandDeclaration; }
2869 		@Override
2870 		public void enterRule(ParseTreeListener listener) {
2871 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterStaticImportOnDemandDeclaration(this);
2872 		}
2873 		@Override
2874 		public void exitRule(ParseTreeListener listener) {
2875 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitStaticImportOnDemandDeclaration(this);
2876 		}
2877 	}
2878 
2879 	public final StaticImportOnDemandDeclarationContext staticImportOnDemandDeclaration() throws RecognitionException {
2880 		StaticImportOnDemandDeclarationContext _localctx = new StaticImportOnDemandDeclarationContext(_ctx, getState());
2881 		enterRule(_localctx, 82, RULE_staticImportOnDemandDeclaration);
2882 		try {
2883 			enterOuterAlt(_localctx, 1);
2884 			{
2885 			setState(816);
2886 			match(IMPORT);
2887 			setState(817);
2888 			match(STATIC);
2889 			setState(818);
2890 			typeName();
2891 			setState(819);
2892 			match(DOT);
2893 			setState(820);
2894 			match(MUL);
2895 			setState(821);
2896 			match(SEMI);
2897 			}
2898 		}
2899 		catch (RecognitionException re) {
2900 			_localctx.exception = re;
2901 			_errHandler.reportError(this, re);
2902 			_errHandler.recover(this, re);
2903 		}
2904 		finally {
2905 			exitRule();
2906 		}
2907 		return _localctx;
2908 	}
2909 
2910 	public static class TypeDeclarationContext extends ParserRuleContext {
2911 		public ClassDeclarationContext classDeclaration() {
2912 			return getRuleContext(ClassDeclarationContext.class,0);
2913 		}
2914 		public InterfaceDeclarationContext interfaceDeclaration() {
2915 			return getRuleContext(InterfaceDeclarationContext.class,0);
2916 		}
2917 		public TypeDeclarationContext(ParserRuleContext parent, int invokingState) {
2918 			super(parent, invokingState);
2919 		}
2920 		@Override public int getRuleIndex() { return RULE_typeDeclaration; }
2921 		@Override
2922 		public void enterRule(ParseTreeListener listener) {
2923 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeDeclaration(this);
2924 		}
2925 		@Override
2926 		public void exitRule(ParseTreeListener listener) {
2927 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeDeclaration(this);
2928 		}
2929 	}
2930 
2931 	public final TypeDeclarationContext typeDeclaration() throws RecognitionException {
2932 		TypeDeclarationContext _localctx = new TypeDeclarationContext(_ctx, getState());
2933 		enterRule(_localctx, 84, RULE_typeDeclaration);
2934 		try {
2935 			setState(826);
2936 			_errHandler.sync(this);
2937 			switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) {
2938 			case 1:
2939 				enterOuterAlt(_localctx, 1);
2940 				{
2941 				setState(823);
2942 				classDeclaration();
2943 				}
2944 				break;
2945 			case 2:
2946 				enterOuterAlt(_localctx, 2);
2947 				{
2948 				setState(824);
2949 				interfaceDeclaration();
2950 				}
2951 				break;
2952 			case 3:
2953 				enterOuterAlt(_localctx, 3);
2954 				{
2955 				setState(825);
2956 				match(SEMI);
2957 				}
2958 				break;
2959 			}
2960 		}
2961 		catch (RecognitionException re) {
2962 			_localctx.exception = re;
2963 			_errHandler.reportError(this, re);
2964 			_errHandler.recover(this, re);
2965 		}
2966 		finally {
2967 			exitRule();
2968 		}
2969 		return _localctx;
2970 	}
2971 
2972 	public static class ModuleDeclarationContext extends ParserRuleContext {
2973 		public ModuleNameContext moduleName() {
2974 			return getRuleContext(ModuleNameContext.class,0);
2975 		}
2976 		public List<AnnotationContext> annotation() {
2977 			return getRuleContexts(AnnotationContext.class);
2978 		}
2979 		public AnnotationContext annotation(int i) {
2980 			return getRuleContext(AnnotationContext.class,i);
2981 		}
2982 		public List<ModuleDirectiveContext> moduleDirective() {
2983 			return getRuleContexts(ModuleDirectiveContext.class);
2984 		}
2985 		public ModuleDirectiveContext moduleDirective(int i) {
2986 			return getRuleContext(ModuleDirectiveContext.class,i);
2987 		}
2988 		public ModuleDeclarationContext(ParserRuleContext parent, int invokingState) {
2989 			super(parent, invokingState);
2990 		}
2991 		@Override public int getRuleIndex() { return RULE_moduleDeclaration; }
2992 		@Override
2993 		public void enterRule(ParseTreeListener listener) {
2994 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterModuleDeclaration(this);
2995 		}
2996 		@Override
2997 		public void exitRule(ParseTreeListener listener) {
2998 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitModuleDeclaration(this);
2999 		}
3000 	}
3001 
3002 	public final ModuleDeclarationContext moduleDeclaration() throws RecognitionException {
3003 		ModuleDeclarationContext _localctx = new ModuleDeclarationContext(_ctx, getState());
3004 		enterRule(_localctx, 86, RULE_moduleDeclaration);
3005 		int _la;
3006 		try {
3007 			enterOuterAlt(_localctx, 1);
3008 			{
3009 			setState(831);
3010 			_errHandler.sync(this);
3011 			_la = _input.LA(1);
3012 			while (_la==AT) {
3013 				{
3014 				{
3015 				setState(828);
3016 				annotation();
3017 				}
3018 				}
3019 				setState(833);
3020 				_errHandler.sync(this);
3021 				_la = _input.LA(1);
3022 			}
3023 			setState(835);
3024 			_errHandler.sync(this);
3025 			_la = _input.LA(1);
3026 			if (_la==T__0) {
3027 				{
3028 				setState(834);
3029 				match(T__0);
3030 				}
3031 			}
3032 
3033 			setState(837);
3034 			match(T__1);
3035 			setState(838);
3036 			moduleName(0);
3037 			setState(839);
3038 			match(LBRACE);
3039 			setState(843);
3040 			_errHandler.sync(this);
3041 			_la = _input.LA(1);
3042 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__2) | (1L << T__3) | (1L << T__5) | (1L << T__6) | (1L << T__7))) != 0)) {
3043 				{
3044 				{
3045 				setState(840);
3046 				moduleDirective();
3047 				}
3048 				}
3049 				setState(845);
3050 				_errHandler.sync(this);
3051 				_la = _input.LA(1);
3052 			}
3053 			setState(846);
3054 			match(RBRACE);
3055 			}
3056 		}
3057 		catch (RecognitionException re) {
3058 			_localctx.exception = re;
3059 			_errHandler.reportError(this, re);
3060 			_errHandler.recover(this, re);
3061 		}
3062 		finally {
3063 			exitRule();
3064 		}
3065 		return _localctx;
3066 	}
3067 
3068 	public static class ModuleDirectiveContext extends ParserRuleContext {
3069 		public RequiresDirectiveContext requiresDirective() {
3070 			return getRuleContext(RequiresDirectiveContext.class,0);
3071 		}
3072 		public ExportsDirectiveContext exportsDirective() {
3073 			return getRuleContext(ExportsDirectiveContext.class,0);
3074 		}
3075 		public OpensDirectiveContext opensDirective() {
3076 			return getRuleContext(OpensDirectiveContext.class,0);
3077 		}
3078 		public UsesDirectiveContext usesDirective() {
3079 			return getRuleContext(UsesDirectiveContext.class,0);
3080 		}
3081 		public ProvidesDirectiveContext providesDirective() {
3082 			return getRuleContext(ProvidesDirectiveContext.class,0);
3083 		}
3084 		public ModuleDirectiveContext(ParserRuleContext parent, int invokingState) {
3085 			super(parent, invokingState);
3086 		}
3087 		@Override public int getRuleIndex() { return RULE_moduleDirective; }
3088 		@Override
3089 		public void enterRule(ParseTreeListener listener) {
3090 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterModuleDirective(this);
3091 		}
3092 		@Override
3093 		public void exitRule(ParseTreeListener listener) {
3094 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitModuleDirective(this);
3095 		}
3096 	}
3097 
3098 	public final ModuleDirectiveContext moduleDirective() throws RecognitionException {
3099 		ModuleDirectiveContext _localctx = new ModuleDirectiveContext(_ctx, getState());
3100 		enterRule(_localctx, 88, RULE_moduleDirective);
3101 		try {
3102 			setState(853);
3103 			_errHandler.sync(this);
3104 			switch (_input.LA(1)) {
3105 			case T__2:
3106 				enterOuterAlt(_localctx, 1);
3107 				{
3108 				setState(848);
3109 				requiresDirective();
3110 				}
3111 				break;
3112 			case T__3:
3113 				enterOuterAlt(_localctx, 2);
3114 				{
3115 				setState(849);
3116 				exportsDirective();
3117 				}
3118 				break;
3119 			case T__5:
3120 				enterOuterAlt(_localctx, 3);
3121 				{
3122 				setState(850);
3123 				opensDirective();
3124 				}
3125 				break;
3126 			case T__6:
3127 				enterOuterAlt(_localctx, 4);
3128 				{
3129 				setState(851);
3130 				usesDirective();
3131 				}
3132 				break;
3133 			case T__7:
3134 				enterOuterAlt(_localctx, 5);
3135 				{
3136 				setState(852);
3137 				providesDirective();
3138 				}
3139 				break;
3140 			default:
3141 				throw new NoViableAltException(this);
3142 			}
3143 		}
3144 		catch (RecognitionException re) {
3145 			_localctx.exception = re;
3146 			_errHandler.reportError(this, re);
3147 			_errHandler.recover(this, re);
3148 		}
3149 		finally {
3150 			exitRule();
3151 		}
3152 		return _localctx;
3153 	}
3154 
3155 	public static class RequiresDirectiveContext extends ParserRuleContext {
3156 		public ModuleNameContext moduleName() {
3157 			return getRuleContext(ModuleNameContext.class,0);
3158 		}
3159 		public List<RequiresModifierContext> requiresModifier() {
3160 			return getRuleContexts(RequiresModifierContext.class);
3161 		}
3162 		public RequiresModifierContext requiresModifier(int i) {
3163 			return getRuleContext(RequiresModifierContext.class,i);
3164 		}
3165 		public RequiresDirectiveContext(ParserRuleContext parent, int invokingState) {
3166 			super(parent, invokingState);
3167 		}
3168 		@Override public int getRuleIndex() { return RULE_requiresDirective; }
3169 		@Override
3170 		public void enterRule(ParseTreeListener listener) {
3171 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterRequiresDirective(this);
3172 		}
3173 		@Override
3174 		public void exitRule(ParseTreeListener listener) {
3175 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitRequiresDirective(this);
3176 		}
3177 	}
3178 
3179 	public final RequiresDirectiveContext requiresDirective() throws RecognitionException {
3180 		RequiresDirectiveContext _localctx = new RequiresDirectiveContext(_ctx, getState());
3181 		enterRule(_localctx, 90, RULE_requiresDirective);
3182 		int _la;
3183 		try {
3184 			enterOuterAlt(_localctx, 1);
3185 			{
3186 			setState(855);
3187 			match(T__2);
3188 			setState(859);
3189 			_errHandler.sync(this);
3190 			_la = _input.LA(1);
3191 			while (_la==T__9 || _la==STATIC) {
3192 				{
3193 				{
3194 				setState(856);
3195 				requiresModifier();
3196 				}
3197 				}
3198 				setState(861);
3199 				_errHandler.sync(this);
3200 				_la = _input.LA(1);
3201 			}
3202 			setState(862);
3203 			moduleName(0);
3204 			setState(863);
3205 			match(SEMI);
3206 			}
3207 		}
3208 		catch (RecognitionException re) {
3209 			_localctx.exception = re;
3210 			_errHandler.reportError(this, re);
3211 			_errHandler.recover(this, re);
3212 		}
3213 		finally {
3214 			exitRule();
3215 		}
3216 		return _localctx;
3217 	}
3218 
3219 	public static class ExportsDirectiveContext extends ParserRuleContext {
3220 		public PackageNameContext packageName() {
3221 			return getRuleContext(PackageNameContext.class,0);
3222 		}
3223 		public List<ModuleNameContext> moduleName() {
3224 			return getRuleContexts(ModuleNameContext.class);
3225 		}
3226 		public ModuleNameContext moduleName(int i) {
3227 			return getRuleContext(ModuleNameContext.class,i);
3228 		}
3229 		public ExportsDirectiveContext(ParserRuleContext parent, int invokingState) {
3230 			super(parent, invokingState);
3231 		}
3232 		@Override public int getRuleIndex() { return RULE_exportsDirective; }
3233 		@Override
3234 		public void enterRule(ParseTreeListener listener) {
3235 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterExportsDirective(this);
3236 		}
3237 		@Override
3238 		public void exitRule(ParseTreeListener listener) {
3239 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitExportsDirective(this);
3240 		}
3241 	}
3242 
3243 	public final ExportsDirectiveContext exportsDirective() throws RecognitionException {
3244 		ExportsDirectiveContext _localctx = new ExportsDirectiveContext(_ctx, getState());
3245 		enterRule(_localctx, 92, RULE_exportsDirective);
3246 		int _la;
3247 		try {
3248 			enterOuterAlt(_localctx, 1);
3249 			{
3250 			setState(865);
3251 			match(T__3);
3252 			setState(866);
3253 			packageName(0);
3254 			setState(876);
3255 			_errHandler.sync(this);
3256 			_la = _input.LA(1);
3257 			if (_la==T__4) {
3258 				{
3259 				setState(867);
3260 				match(T__4);
3261 				setState(868);
3262 				moduleName(0);
3263 				setState(873);
3264 				_errHandler.sync(this);
3265 				_la = _input.LA(1);
3266 				while (_la==COMMA) {
3267 					{
3268 					{
3269 					setState(869);
3270 					match(COMMA);
3271 					setState(870);
3272 					moduleName(0);
3273 					}
3274 					}
3275 					setState(875);
3276 					_errHandler.sync(this);
3277 					_la = _input.LA(1);
3278 				}
3279 				}
3280 			}
3281 
3282 			setState(878);
3283 			match(SEMI);
3284 			}
3285 		}
3286 		catch (RecognitionException re) {
3287 			_localctx.exception = re;
3288 			_errHandler.reportError(this, re);
3289 			_errHandler.recover(this, re);
3290 		}
3291 		finally {
3292 			exitRule();
3293 		}
3294 		return _localctx;
3295 	}
3296 
3297 	public static class OpensDirectiveContext extends ParserRuleContext {
3298 		public PackageNameContext packageName() {
3299 			return getRuleContext(PackageNameContext.class,0);
3300 		}
3301 		public List<ModuleNameContext> moduleName() {
3302 			return getRuleContexts(ModuleNameContext.class);
3303 		}
3304 		public ModuleNameContext moduleName(int i) {
3305 			return getRuleContext(ModuleNameContext.class,i);
3306 		}
3307 		public OpensDirectiveContext(ParserRuleContext parent, int invokingState) {
3308 			super(parent, invokingState);
3309 		}
3310 		@Override public int getRuleIndex() { return RULE_opensDirective; }
3311 		@Override
3312 		public void enterRule(ParseTreeListener listener) {
3313 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterOpensDirective(this);
3314 		}
3315 		@Override
3316 		public void exitRule(ParseTreeListener listener) {
3317 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitOpensDirective(this);
3318 		}
3319 	}
3320 
3321 	public final OpensDirectiveContext opensDirective() throws RecognitionException {
3322 		OpensDirectiveContext _localctx = new OpensDirectiveContext(_ctx, getState());
3323 		enterRule(_localctx, 94, RULE_opensDirective);
3324 		int _la;
3325 		try {
3326 			enterOuterAlt(_localctx, 1);
3327 			{
3328 			setState(880);
3329 			match(T__5);
3330 			setState(881);
3331 			packageName(0);
3332 			setState(891);
3333 			_errHandler.sync(this);
3334 			_la = _input.LA(1);
3335 			if (_la==T__4) {
3336 				{
3337 				setState(882);
3338 				match(T__4);
3339 				setState(883);
3340 				moduleName(0);
3341 				setState(888);
3342 				_errHandler.sync(this);
3343 				_la = _input.LA(1);
3344 				while (_la==COMMA) {
3345 					{
3346 					{
3347 					setState(884);
3348 					match(COMMA);
3349 					setState(885);
3350 					moduleName(0);
3351 					}
3352 					}
3353 					setState(890);
3354 					_errHandler.sync(this);
3355 					_la = _input.LA(1);
3356 				}
3357 				}
3358 			}
3359 
3360 			setState(893);
3361 			match(SEMI);
3362 			}
3363 		}
3364 		catch (RecognitionException re) {
3365 			_localctx.exception = re;
3366 			_errHandler.reportError(this, re);
3367 			_errHandler.recover(this, re);
3368 		}
3369 		finally {
3370 			exitRule();
3371 		}
3372 		return _localctx;
3373 	}
3374 
3375 	public static class UsesDirectiveContext extends ParserRuleContext {
3376 		public TypeNameContext typeName() {
3377 			return getRuleContext(TypeNameContext.class,0);
3378 		}
3379 		public UsesDirectiveContext(ParserRuleContext parent, int invokingState) {
3380 			super(parent, invokingState);
3381 		}
3382 		@Override public int getRuleIndex() { return RULE_usesDirective; }
3383 		@Override
3384 		public void enterRule(ParseTreeListener listener) {
3385 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUsesDirective(this);
3386 		}
3387 		@Override
3388 		public void exitRule(ParseTreeListener listener) {
3389 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUsesDirective(this);
3390 		}
3391 	}
3392 
3393 	public final UsesDirectiveContext usesDirective() throws RecognitionException {
3394 		UsesDirectiveContext _localctx = new UsesDirectiveContext(_ctx, getState());
3395 		enterRule(_localctx, 96, RULE_usesDirective);
3396 		try {
3397 			enterOuterAlt(_localctx, 1);
3398 			{
3399 			setState(895);
3400 			match(T__6);
3401 			setState(896);
3402 			typeName();
3403 			setState(897);
3404 			match(SEMI);
3405 			}
3406 		}
3407 		catch (RecognitionException re) {
3408 			_localctx.exception = re;
3409 			_errHandler.reportError(this, re);
3410 			_errHandler.recover(this, re);
3411 		}
3412 		finally {
3413 			exitRule();
3414 		}
3415 		return _localctx;
3416 	}
3417 
3418 	public static class ProvidesDirectiveContext extends ParserRuleContext {
3419 		public List<TypeNameContext> typeName() {
3420 			return getRuleContexts(TypeNameContext.class);
3421 		}
3422 		public TypeNameContext typeName(int i) {
3423 			return getRuleContext(TypeNameContext.class,i);
3424 		}
3425 		public ProvidesDirectiveContext(ParserRuleContext parent, int invokingState) {
3426 			super(parent, invokingState);
3427 		}
3428 		@Override public int getRuleIndex() { return RULE_providesDirective; }
3429 		@Override
3430 		public void enterRule(ParseTreeListener listener) {
3431 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterProvidesDirective(this);
3432 		}
3433 		@Override
3434 		public void exitRule(ParseTreeListener listener) {
3435 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitProvidesDirective(this);
3436 		}
3437 	}
3438 
3439 	public final ProvidesDirectiveContext providesDirective() throws RecognitionException {
3440 		ProvidesDirectiveContext _localctx = new ProvidesDirectiveContext(_ctx, getState());
3441 		enterRule(_localctx, 98, RULE_providesDirective);
3442 		int _la;
3443 		try {
3444 			enterOuterAlt(_localctx, 1);
3445 			{
3446 			setState(899);
3447 			match(T__7);
3448 			setState(900);
3449 			typeName();
3450 			setState(901);
3451 			match(T__8);
3452 			setState(902);
3453 			typeName();
3454 			setState(907);
3455 			_errHandler.sync(this);
3456 			_la = _input.LA(1);
3457 			while (_la==COMMA) {
3458 				{
3459 				{
3460 				setState(903);
3461 				match(COMMA);
3462 				setState(904);
3463 				typeName();
3464 				}
3465 				}
3466 				setState(909);
3467 				_errHandler.sync(this);
3468 				_la = _input.LA(1);
3469 			}
3470 			setState(910);
3471 			match(SEMI);
3472 			}
3473 		}
3474 		catch (RecognitionException re) {
3475 			_localctx.exception = re;
3476 			_errHandler.reportError(this, re);
3477 			_errHandler.recover(this, re);
3478 		}
3479 		finally {
3480 			exitRule();
3481 		}
3482 		return _localctx;
3483 	}
3484 
3485 	public static class RequiresModifierContext extends ParserRuleContext {
3486 		public RequiresModifierContext(ParserRuleContext parent, int invokingState) {
3487 			super(parent, invokingState);
3488 		}
3489 		@Override public int getRuleIndex() { return RULE_requiresModifier; }
3490 		@Override
3491 		public void enterRule(ParseTreeListener listener) {
3492 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterRequiresModifier(this);
3493 		}
3494 		@Override
3495 		public void exitRule(ParseTreeListener listener) {
3496 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitRequiresModifier(this);
3497 		}
3498 	}
3499 
3500 	public final RequiresModifierContext requiresModifier() throws RecognitionException {
3501 		RequiresModifierContext _localctx = new RequiresModifierContext(_ctx, getState());
3502 		enterRule(_localctx, 100, RULE_requiresModifier);
3503 		int _la;
3504 		try {
3505 			enterOuterAlt(_localctx, 1);
3506 			{
3507 			setState(912);
3508 			_la = _input.LA(1);
3509 			if ( !(_la==T__9 || _la==STATIC) ) {
3510 			_errHandler.recoverInline(this);
3511 			}
3512 			else {
3513 				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
3514 				_errHandler.reportMatch(this);
3515 				consume();
3516 			}
3517 			}
3518 		}
3519 		catch (RecognitionException re) {
3520 			_localctx.exception = re;
3521 			_errHandler.reportError(this, re);
3522 			_errHandler.recover(this, re);
3523 		}
3524 		finally {
3525 			exitRule();
3526 		}
3527 		return _localctx;
3528 	}
3529 
3530 	public static class ClassDeclarationContext extends ParserRuleContext {
3531 		public NormalClassDeclarationContext normalClassDeclaration() {
3532 			return getRuleContext(NormalClassDeclarationContext.class,0);
3533 		}
3534 		public EnumDeclarationContext enumDeclaration() {
3535 			return getRuleContext(EnumDeclarationContext.class,0);
3536 		}
3537 		public ClassDeclarationContext(ParserRuleContext parent, int invokingState) {
3538 			super(parent, invokingState);
3539 		}
3540 		@Override public int getRuleIndex() { return RULE_classDeclaration; }
3541 		@Override
3542 		public void enterRule(ParseTreeListener listener) {
3543 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterClassDeclaration(this);
3544 		}
3545 		@Override
3546 		public void exitRule(ParseTreeListener listener) {
3547 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitClassDeclaration(this);
3548 		}
3549 	}
3550 
3551 	public final ClassDeclarationContext classDeclaration() throws RecognitionException {
3552 		ClassDeclarationContext _localctx = new ClassDeclarationContext(_ctx, getState());
3553 		enterRule(_localctx, 102, RULE_classDeclaration);
3554 		try {
3555 			setState(916);
3556 			_errHandler.sync(this);
3557 			switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) {
3558 			case 1:
3559 				enterOuterAlt(_localctx, 1);
3560 				{
3561 				setState(914);
3562 				normalClassDeclaration();
3563 				}
3564 				break;
3565 			case 2:
3566 				enterOuterAlt(_localctx, 2);
3567 				{
3568 				setState(915);
3569 				enumDeclaration();
3570 				}
3571 				break;
3572 			}
3573 		}
3574 		catch (RecognitionException re) {
3575 			_localctx.exception = re;
3576 			_errHandler.reportError(this, re);
3577 			_errHandler.recover(this, re);
3578 		}
3579 		finally {
3580 			exitRule();
3581 		}
3582 		return _localctx;
3583 	}
3584 
3585 	public static class NormalClassDeclarationContext extends ParserRuleContext {
3586 		public IdentifierContext identifier() {
3587 			return getRuleContext(IdentifierContext.class,0);
3588 		}
3589 		public ClassBodyContext classBody() {
3590 			return getRuleContext(ClassBodyContext.class,0);
3591 		}
3592 		public List<ClassModifierContext> classModifier() {
3593 			return getRuleContexts(ClassModifierContext.class);
3594 		}
3595 		public ClassModifierContext classModifier(int i) {
3596 			return getRuleContext(ClassModifierContext.class,i);
3597 		}
3598 		public TypeParametersContext typeParameters() {
3599 			return getRuleContext(TypeParametersContext.class,0);
3600 		}
3601 		public SuperclassContext superclass() {
3602 			return getRuleContext(SuperclassContext.class,0);
3603 		}
3604 		public SuperinterfacesContext superinterfaces() {
3605 			return getRuleContext(SuperinterfacesContext.class,0);
3606 		}
3607 		public NormalClassDeclarationContext(ParserRuleContext parent, int invokingState) {
3608 			super(parent, invokingState);
3609 		}
3610 		@Override public int getRuleIndex() { return RULE_normalClassDeclaration; }
3611 		@Override
3612 		public void enterRule(ParseTreeListener listener) {
3613 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterNormalClassDeclaration(this);
3614 		}
3615 		@Override
3616 		public void exitRule(ParseTreeListener listener) {
3617 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitNormalClassDeclaration(this);
3618 		}
3619 	}
3620 
3621 	public final NormalClassDeclarationContext normalClassDeclaration() throws RecognitionException {
3622 		NormalClassDeclarationContext _localctx = new NormalClassDeclarationContext(_ctx, getState());
3623 		enterRule(_localctx, 104, RULE_normalClassDeclaration);
3624 		int _la;
3625 		try {
3626 			enterOuterAlt(_localctx, 1);
3627 			{
3628 			setState(921);
3629 			_errHandler.sync(this);
3630 			_la = _input.LA(1);
3631 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) {
3632 				{
3633 				{
3634 				setState(918);
3635 				classModifier();
3636 				}
3637 				}
3638 				setState(923);
3639 				_errHandler.sync(this);
3640 				_la = _input.LA(1);
3641 			}
3642 			setState(924);
3643 			match(CLASS);
3644 			setState(925);
3645 			identifier();
3646 			setState(927);
3647 			_errHandler.sync(this);
3648 			_la = _input.LA(1);
3649 			if (_la==LT) {
3650 				{
3651 				setState(926);
3652 				typeParameters();
3653 				}
3654 			}
3655 
3656 			setState(930);
3657 			_errHandler.sync(this);
3658 			_la = _input.LA(1);
3659 			if (_la==EXTENDS) {
3660 				{
3661 				setState(929);
3662 				superclass();
3663 				}
3664 			}
3665 
3666 			setState(933);
3667 			_errHandler.sync(this);
3668 			_la = _input.LA(1);
3669 			if (_la==IMPLEMENTS) {
3670 				{
3671 				setState(932);
3672 				superinterfaces();
3673 				}
3674 			}
3675 
3676 			setState(935);
3677 			classBody();
3678 			}
3679 		}
3680 		catch (RecognitionException re) {
3681 			_localctx.exception = re;
3682 			_errHandler.reportError(this, re);
3683 			_errHandler.recover(this, re);
3684 		}
3685 		finally {
3686 			exitRule();
3687 		}
3688 		return _localctx;
3689 	}
3690 
3691 	public static class ClassModifierContext extends ParserRuleContext {
3692 		public AnnotationContext annotation() {
3693 			return getRuleContext(AnnotationContext.class,0);
3694 		}
3695 		public ClassModifierContext(ParserRuleContext parent, int invokingState) {
3696 			super(parent, invokingState);
3697 		}
3698 		@Override public int getRuleIndex() { return RULE_classModifier; }
3699 		@Override
3700 		public void enterRule(ParseTreeListener listener) {
3701 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterClassModifier(this);
3702 		}
3703 		@Override
3704 		public void exitRule(ParseTreeListener listener) {
3705 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitClassModifier(this);
3706 		}
3707 	}
3708 
3709 	public final ClassModifierContext classModifier() throws RecognitionException {
3710 		ClassModifierContext _localctx = new ClassModifierContext(_ctx, getState());
3711 		enterRule(_localctx, 106, RULE_classModifier);
3712 		try {
3713 			setState(945);
3714 			_errHandler.sync(this);
3715 			switch (_input.LA(1)) {
3716 			case AT:
3717 				enterOuterAlt(_localctx, 1);
3718 				{
3719 				setState(937);
3720 				annotation();
3721 				}
3722 				break;
3723 			case PUBLIC:
3724 				enterOuterAlt(_localctx, 2);
3725 				{
3726 				setState(938);
3727 				match(PUBLIC);
3728 				}
3729 				break;
3730 			case PROTECTED:
3731 				enterOuterAlt(_localctx, 3);
3732 				{
3733 				setState(939);
3734 				match(PROTECTED);
3735 				}
3736 				break;
3737 			case PRIVATE:
3738 				enterOuterAlt(_localctx, 4);
3739 				{
3740 				setState(940);
3741 				match(PRIVATE);
3742 				}
3743 				break;
3744 			case ABSTRACT:
3745 				enterOuterAlt(_localctx, 5);
3746 				{
3747 				setState(941);
3748 				match(ABSTRACT);
3749 				}
3750 				break;
3751 			case STATIC:
3752 				enterOuterAlt(_localctx, 6);
3753 				{
3754 				setState(942);
3755 				match(STATIC);
3756 				}
3757 				break;
3758 			case FINAL:
3759 				enterOuterAlt(_localctx, 7);
3760 				{
3761 				setState(943);
3762 				match(FINAL);
3763 				}
3764 				break;
3765 			case STRICTFP:
3766 				enterOuterAlt(_localctx, 8);
3767 				{
3768 				setState(944);
3769 				match(STRICTFP);
3770 				}
3771 				break;
3772 			default:
3773 				throw new NoViableAltException(this);
3774 			}
3775 		}
3776 		catch (RecognitionException re) {
3777 			_localctx.exception = re;
3778 			_errHandler.reportError(this, re);
3779 			_errHandler.recover(this, re);
3780 		}
3781 		finally {
3782 			exitRule();
3783 		}
3784 		return _localctx;
3785 	}
3786 
3787 	public static class TypeParametersContext extends ParserRuleContext {
3788 		public TypeParameterListContext typeParameterList() {
3789 			return getRuleContext(TypeParameterListContext.class,0);
3790 		}
3791 		public TypeParametersContext(ParserRuleContext parent, int invokingState) {
3792 			super(parent, invokingState);
3793 		}
3794 		@Override public int getRuleIndex() { return RULE_typeParameters; }
3795 		@Override
3796 		public void enterRule(ParseTreeListener listener) {
3797 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeParameters(this);
3798 		}
3799 		@Override
3800 		public void exitRule(ParseTreeListener listener) {
3801 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeParameters(this);
3802 		}
3803 	}
3804 
3805 	public final TypeParametersContext typeParameters() throws RecognitionException {
3806 		TypeParametersContext _localctx = new TypeParametersContext(_ctx, getState());
3807 		enterRule(_localctx, 108, RULE_typeParameters);
3808 		try {
3809 			enterOuterAlt(_localctx, 1);
3810 			{
3811 			setState(947);
3812 			match(LT);
3813 			setState(948);
3814 			typeParameterList();
3815 			setState(949);
3816 			match(GT);
3817 			}
3818 		}
3819 		catch (RecognitionException re) {
3820 			_localctx.exception = re;
3821 			_errHandler.reportError(this, re);
3822 			_errHandler.recover(this, re);
3823 		}
3824 		finally {
3825 			exitRule();
3826 		}
3827 		return _localctx;
3828 	}
3829 
3830 	public static class TypeParameterListContext extends ParserRuleContext {
3831 		public List<TypeParameterContext> typeParameter() {
3832 			return getRuleContexts(TypeParameterContext.class);
3833 		}
3834 		public TypeParameterContext typeParameter(int i) {
3835 			return getRuleContext(TypeParameterContext.class,i);
3836 		}
3837 		public TypeParameterListContext(ParserRuleContext parent, int invokingState) {
3838 			super(parent, invokingState);
3839 		}
3840 		@Override public int getRuleIndex() { return RULE_typeParameterList; }
3841 		@Override
3842 		public void enterRule(ParseTreeListener listener) {
3843 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeParameterList(this);
3844 		}
3845 		@Override
3846 		public void exitRule(ParseTreeListener listener) {
3847 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeParameterList(this);
3848 		}
3849 	}
3850 
3851 	public final TypeParameterListContext typeParameterList() throws RecognitionException {
3852 		TypeParameterListContext _localctx = new TypeParameterListContext(_ctx, getState());
3853 		enterRule(_localctx, 110, RULE_typeParameterList);
3854 		int _la;
3855 		try {
3856 			enterOuterAlt(_localctx, 1);
3857 			{
3858 			setState(951);
3859 			typeParameter();
3860 			setState(956);
3861 			_errHandler.sync(this);
3862 			_la = _input.LA(1);
3863 			while (_la==COMMA) {
3864 				{
3865 				{
3866 				setState(952);
3867 				match(COMMA);
3868 				setState(953);
3869 				typeParameter();
3870 				}
3871 				}
3872 				setState(958);
3873 				_errHandler.sync(this);
3874 				_la = _input.LA(1);
3875 			}
3876 			}
3877 		}
3878 		catch (RecognitionException re) {
3879 			_localctx.exception = re;
3880 			_errHandler.reportError(this, re);
3881 			_errHandler.recover(this, re);
3882 		}
3883 		finally {
3884 			exitRule();
3885 		}
3886 		return _localctx;
3887 	}
3888 
3889 	public static class SuperclassContext extends ParserRuleContext {
3890 		public ClassTypeContext classType() {
3891 			return getRuleContext(ClassTypeContext.class,0);
3892 		}
3893 		public SuperclassContext(ParserRuleContext parent, int invokingState) {
3894 			super(parent, invokingState);
3895 		}
3896 		@Override public int getRuleIndex() { return RULE_superclass; }
3897 		@Override
3898 		public void enterRule(ParseTreeListener listener) {
3899 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterSuperclass(this);
3900 		}
3901 		@Override
3902 		public void exitRule(ParseTreeListener listener) {
3903 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitSuperclass(this);
3904 		}
3905 	}
3906 
3907 	public final SuperclassContext superclass() throws RecognitionException {
3908 		SuperclassContext _localctx = new SuperclassContext(_ctx, getState());
3909 		enterRule(_localctx, 112, RULE_superclass);
3910 		try {
3911 			enterOuterAlt(_localctx, 1);
3912 			{
3913 			setState(959);
3914 			match(EXTENDS);
3915 			setState(960);
3916 			classType();
3917 			}
3918 		}
3919 		catch (RecognitionException re) {
3920 			_localctx.exception = re;
3921 			_errHandler.reportError(this, re);
3922 			_errHandler.recover(this, re);
3923 		}
3924 		finally {
3925 			exitRule();
3926 		}
3927 		return _localctx;
3928 	}
3929 
3930 	public static class SuperinterfacesContext extends ParserRuleContext {
3931 		public InterfaceTypeListContext interfaceTypeList() {
3932 			return getRuleContext(InterfaceTypeListContext.class,0);
3933 		}
3934 		public SuperinterfacesContext(ParserRuleContext parent, int invokingState) {
3935 			super(parent, invokingState);
3936 		}
3937 		@Override public int getRuleIndex() { return RULE_superinterfaces; }
3938 		@Override
3939 		public void enterRule(ParseTreeListener listener) {
3940 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterSuperinterfaces(this);
3941 		}
3942 		@Override
3943 		public void exitRule(ParseTreeListener listener) {
3944 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitSuperinterfaces(this);
3945 		}
3946 	}
3947 
3948 	public final SuperinterfacesContext superinterfaces() throws RecognitionException {
3949 		SuperinterfacesContext _localctx = new SuperinterfacesContext(_ctx, getState());
3950 		enterRule(_localctx, 114, RULE_superinterfaces);
3951 		try {
3952 			enterOuterAlt(_localctx, 1);
3953 			{
3954 			setState(962);
3955 			match(IMPLEMENTS);
3956 			setState(963);
3957 			interfaceTypeList();
3958 			}
3959 		}
3960 		catch (RecognitionException re) {
3961 			_localctx.exception = re;
3962 			_errHandler.reportError(this, re);
3963 			_errHandler.recover(this, re);
3964 		}
3965 		finally {
3966 			exitRule();
3967 		}
3968 		return _localctx;
3969 	}
3970 
3971 	public static class InterfaceTypeListContext extends ParserRuleContext {
3972 		public List<InterfaceTypeContext> interfaceType() {
3973 			return getRuleContexts(InterfaceTypeContext.class);
3974 		}
3975 		public InterfaceTypeContext interfaceType(int i) {
3976 			return getRuleContext(InterfaceTypeContext.class,i);
3977 		}
3978 		public InterfaceTypeListContext(ParserRuleContext parent, int invokingState) {
3979 			super(parent, invokingState);
3980 		}
3981 		@Override public int getRuleIndex() { return RULE_interfaceTypeList; }
3982 		@Override
3983 		public void enterRule(ParseTreeListener listener) {
3984 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInterfaceTypeList(this);
3985 		}
3986 		@Override
3987 		public void exitRule(ParseTreeListener listener) {
3988 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInterfaceTypeList(this);
3989 		}
3990 	}
3991 
3992 	public final InterfaceTypeListContext interfaceTypeList() throws RecognitionException {
3993 		InterfaceTypeListContext _localctx = new InterfaceTypeListContext(_ctx, getState());
3994 		enterRule(_localctx, 116, RULE_interfaceTypeList);
3995 		int _la;
3996 		try {
3997 			enterOuterAlt(_localctx, 1);
3998 			{
3999 			setState(965);
4000 			interfaceType();
4001 			setState(970);
4002 			_errHandler.sync(this);
4003 			_la = _input.LA(1);
4004 			while (_la==COMMA) {
4005 				{
4006 				{
4007 				setState(966);
4008 				match(COMMA);
4009 				setState(967);
4010 				interfaceType();
4011 				}
4012 				}
4013 				setState(972);
4014 				_errHandler.sync(this);
4015 				_la = _input.LA(1);
4016 			}
4017 			}
4018 		}
4019 		catch (RecognitionException re) {
4020 			_localctx.exception = re;
4021 			_errHandler.reportError(this, re);
4022 			_errHandler.recover(this, re);
4023 		}
4024 		finally {
4025 			exitRule();
4026 		}
4027 		return _localctx;
4028 	}
4029 
4030 	public static class ClassBodyContext extends ParserRuleContext {
4031 		public List<ClassBodyDeclarationContext> classBodyDeclaration() {
4032 			return getRuleContexts(ClassBodyDeclarationContext.class);
4033 		}
4034 		public ClassBodyDeclarationContext classBodyDeclaration(int i) {
4035 			return getRuleContext(ClassBodyDeclarationContext.class,i);
4036 		}
4037 		public ClassBodyContext(ParserRuleContext parent, int invokingState) {
4038 			super(parent, invokingState);
4039 		}
4040 		@Override public int getRuleIndex() { return RULE_classBody; }
4041 		@Override
4042 		public void enterRule(ParseTreeListener listener) {
4043 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterClassBody(this);
4044 		}
4045 		@Override
4046 		public void exitRule(ParseTreeListener listener) {
4047 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitClassBody(this);
4048 		}
4049 	}
4050 
4051 	public final ClassBodyContext classBody() throws RecognitionException {
4052 		ClassBodyContext _localctx = new ClassBodyContext(_ctx, getState());
4053 		enterRule(_localctx, 118, RULE_classBody);
4054 		int _la;
4055 		try {
4056 			enterOuterAlt(_localctx, 1);
4057 			{
4058 			setState(973);
4059 			match(LBRACE);
4060 			setState(977);
4061 			_errHandler.sync(this);
4062 			_la = _input.LA(1);
4063 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << NATIVE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SYNCHRONIZED) | (1L << TRANSIENT) | (1L << VOID) | (1L << VOLATILE))) != 0) || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & ((1L << (LBRACE - 70)) | (1L << (SEMI - 70)) | (1L << (AT - 70)) | (1L << (LT - 70)) | (1L << (Identifier - 70)))) != 0)) {
4064 				{
4065 				{
4066 				setState(974);
4067 				classBodyDeclaration();
4068 				}
4069 				}
4070 				setState(979);
4071 				_errHandler.sync(this);
4072 				_la = _input.LA(1);
4073 			}
4074 			setState(980);
4075 			match(RBRACE);
4076 			}
4077 		}
4078 		catch (RecognitionException re) {
4079 			_localctx.exception = re;
4080 			_errHandler.reportError(this, re);
4081 			_errHandler.recover(this, re);
4082 		}
4083 		finally {
4084 			exitRule();
4085 		}
4086 		return _localctx;
4087 	}
4088 
4089 	public static class ClassBodyDeclarationContext extends ParserRuleContext {
4090 		public ClassMemberDeclarationContext classMemberDeclaration() {
4091 			return getRuleContext(ClassMemberDeclarationContext.class,0);
4092 		}
4093 		public InstanceInitializerContext instanceInitializer() {
4094 			return getRuleContext(InstanceInitializerContext.class,0);
4095 		}
4096 		public StaticInitializerContext staticInitializer() {
4097 			return getRuleContext(StaticInitializerContext.class,0);
4098 		}
4099 		public ConstructorDeclarationContext constructorDeclaration() {
4100 			return getRuleContext(ConstructorDeclarationContext.class,0);
4101 		}
4102 		public ClassBodyDeclarationContext(ParserRuleContext parent, int invokingState) {
4103 			super(parent, invokingState);
4104 		}
4105 		@Override public int getRuleIndex() { return RULE_classBodyDeclaration; }
4106 		@Override
4107 		public void enterRule(ParseTreeListener listener) {
4108 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterClassBodyDeclaration(this);
4109 		}
4110 		@Override
4111 		public void exitRule(ParseTreeListener listener) {
4112 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitClassBodyDeclaration(this);
4113 		}
4114 	}
4115 
4116 	public final ClassBodyDeclarationContext classBodyDeclaration() throws RecognitionException {
4117 		ClassBodyDeclarationContext _localctx = new ClassBodyDeclarationContext(_ctx, getState());
4118 		enterRule(_localctx, 120, RULE_classBodyDeclaration);
4119 		try {
4120 			setState(986);
4121 			_errHandler.sync(this);
4122 			switch ( getInterpreter().adaptivePredict(_input,64,_ctx) ) {
4123 			case 1:
4124 				enterOuterAlt(_localctx, 1);
4125 				{
4126 				setState(982);
4127 				classMemberDeclaration();
4128 				}
4129 				break;
4130 			case 2:
4131 				enterOuterAlt(_localctx, 2);
4132 				{
4133 				setState(983);
4134 				instanceInitializer();
4135 				}
4136 				break;
4137 			case 3:
4138 				enterOuterAlt(_localctx, 3);
4139 				{
4140 				setState(984);
4141 				staticInitializer();
4142 				}
4143 				break;
4144 			case 4:
4145 				enterOuterAlt(_localctx, 4);
4146 				{
4147 				setState(985);
4148 				constructorDeclaration();
4149 				}
4150 				break;
4151 			}
4152 		}
4153 		catch (RecognitionException re) {
4154 			_localctx.exception = re;
4155 			_errHandler.reportError(this, re);
4156 			_errHandler.recover(this, re);
4157 		}
4158 		finally {
4159 			exitRule();
4160 		}
4161 		return _localctx;
4162 	}
4163 
4164 	public static class ClassMemberDeclarationContext extends ParserRuleContext {
4165 		public FieldDeclarationContext fieldDeclaration() {
4166 			return getRuleContext(FieldDeclarationContext.class,0);
4167 		}
4168 		public MethodDeclarationContext methodDeclaration() {
4169 			return getRuleContext(MethodDeclarationContext.class,0);
4170 		}
4171 		public ClassDeclarationContext classDeclaration() {
4172 			return getRuleContext(ClassDeclarationContext.class,0);
4173 		}
4174 		public InterfaceDeclarationContext interfaceDeclaration() {
4175 			return getRuleContext(InterfaceDeclarationContext.class,0);
4176 		}
4177 		public ClassMemberDeclarationContext(ParserRuleContext parent, int invokingState) {
4178 			super(parent, invokingState);
4179 		}
4180 		@Override public int getRuleIndex() { return RULE_classMemberDeclaration; }
4181 		@Override
4182 		public void enterRule(ParseTreeListener listener) {
4183 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterClassMemberDeclaration(this);
4184 		}
4185 		@Override
4186 		public void exitRule(ParseTreeListener listener) {
4187 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitClassMemberDeclaration(this);
4188 		}
4189 	}
4190 
4191 	public final ClassMemberDeclarationContext classMemberDeclaration() throws RecognitionException {
4192 		ClassMemberDeclarationContext _localctx = new ClassMemberDeclarationContext(_ctx, getState());
4193 		enterRule(_localctx, 122, RULE_classMemberDeclaration);
4194 		try {
4195 			setState(993);
4196 			_errHandler.sync(this);
4197 			switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) {
4198 			case 1:
4199 				enterOuterAlt(_localctx, 1);
4200 				{
4201 				setState(988);
4202 				fieldDeclaration();
4203 				}
4204 				break;
4205 			case 2:
4206 				enterOuterAlt(_localctx, 2);
4207 				{
4208 				setState(989);
4209 				methodDeclaration();
4210 				}
4211 				break;
4212 			case 3:
4213 				enterOuterAlt(_localctx, 3);
4214 				{
4215 				setState(990);
4216 				classDeclaration();
4217 				}
4218 				break;
4219 			case 4:
4220 				enterOuterAlt(_localctx, 4);
4221 				{
4222 				setState(991);
4223 				interfaceDeclaration();
4224 				}
4225 				break;
4226 			case 5:
4227 				enterOuterAlt(_localctx, 5);
4228 				{
4229 				setState(992);
4230 				match(SEMI);
4231 				}
4232 				break;
4233 			}
4234 		}
4235 		catch (RecognitionException re) {
4236 			_localctx.exception = re;
4237 			_errHandler.reportError(this, re);
4238 			_errHandler.recover(this, re);
4239 		}
4240 		finally {
4241 			exitRule();
4242 		}
4243 		return _localctx;
4244 	}
4245 
4246 	public static class FieldDeclarationContext extends ParserRuleContext {
4247 		public UnannTypeContext unannType() {
4248 			return getRuleContext(UnannTypeContext.class,0);
4249 		}
4250 		public VariableDeclaratorListContext variableDeclaratorList() {
4251 			return getRuleContext(VariableDeclaratorListContext.class,0);
4252 		}
4253 		public List<FieldModifierContext> fieldModifier() {
4254 			return getRuleContexts(FieldModifierContext.class);
4255 		}
4256 		public FieldModifierContext fieldModifier(int i) {
4257 			return getRuleContext(FieldModifierContext.class,i);
4258 		}
4259 		public FieldDeclarationContext(ParserRuleContext parent, int invokingState) {
4260 			super(parent, invokingState);
4261 		}
4262 		@Override public int getRuleIndex() { return RULE_fieldDeclaration; }
4263 		@Override
4264 		public void enterRule(ParseTreeListener listener) {
4265 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterFieldDeclaration(this);
4266 		}
4267 		@Override
4268 		public void exitRule(ParseTreeListener listener) {
4269 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitFieldDeclaration(this);
4270 		}
4271 	}
4272 
4273 	public final FieldDeclarationContext fieldDeclaration() throws RecognitionException {
4274 		FieldDeclarationContext _localctx = new FieldDeclarationContext(_ctx, getState());
4275 		enterRule(_localctx, 124, RULE_fieldDeclaration);
4276 		int _la;
4277 		try {
4278 			enterOuterAlt(_localctx, 1);
4279 			{
4280 			setState(998);
4281 			_errHandler.sync(this);
4282 			_la = _input.LA(1);
4283 			while (((((_la - 28)) & ~0x3f) == 0 && ((1L << (_la - 28)) & ((1L << (FINAL - 28)) | (1L << (PRIVATE - 28)) | (1L << (PROTECTED - 28)) | (1L << (PUBLIC - 28)) | (1L << (STATIC - 28)) | (1L << (TRANSIENT - 28)) | (1L << (VOLATILE - 28)) | (1L << (AT - 28)))) != 0)) {
4284 				{
4285 				{
4286 				setState(995);
4287 				fieldModifier();
4288 				}
4289 				}
4290 				setState(1000);
4291 				_errHandler.sync(this);
4292 				_la = _input.LA(1);
4293 			}
4294 			setState(1001);
4295 			unannType();
4296 			setState(1002);
4297 			variableDeclaratorList();
4298 			setState(1003);
4299 			match(SEMI);
4300 			}
4301 		}
4302 		catch (RecognitionException re) {
4303 			_localctx.exception = re;
4304 			_errHandler.reportError(this, re);
4305 			_errHandler.recover(this, re);
4306 		}
4307 		finally {
4308 			exitRule();
4309 		}
4310 		return _localctx;
4311 	}
4312 
4313 	public static class FieldModifierContext extends ParserRuleContext {
4314 		public AnnotationContext annotation() {
4315 			return getRuleContext(AnnotationContext.class,0);
4316 		}
4317 		public FieldModifierContext(ParserRuleContext parent, int invokingState) {
4318 			super(parent, invokingState);
4319 		}
4320 		@Override public int getRuleIndex() { return RULE_fieldModifier; }
4321 		@Override
4322 		public void enterRule(ParseTreeListener listener) {
4323 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterFieldModifier(this);
4324 		}
4325 		@Override
4326 		public void exitRule(ParseTreeListener listener) {
4327 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitFieldModifier(this);
4328 		}
4329 	}
4330 
4331 	public final FieldModifierContext fieldModifier() throws RecognitionException {
4332 		FieldModifierContext _localctx = new FieldModifierContext(_ctx, getState());
4333 		enterRule(_localctx, 126, RULE_fieldModifier);
4334 		try {
4335 			setState(1013);
4336 			_errHandler.sync(this);
4337 			switch (_input.LA(1)) {
4338 			case AT:
4339 				enterOuterAlt(_localctx, 1);
4340 				{
4341 				setState(1005);
4342 				annotation();
4343 				}
4344 				break;
4345 			case PUBLIC:
4346 				enterOuterAlt(_localctx, 2);
4347 				{
4348 				setState(1006);
4349 				match(PUBLIC);
4350 				}
4351 				break;
4352 			case PROTECTED:
4353 				enterOuterAlt(_localctx, 3);
4354 				{
4355 				setState(1007);
4356 				match(PROTECTED);
4357 				}
4358 				break;
4359 			case PRIVATE:
4360 				enterOuterAlt(_localctx, 4);
4361 				{
4362 				setState(1008);
4363 				match(PRIVATE);
4364 				}
4365 				break;
4366 			case STATIC:
4367 				enterOuterAlt(_localctx, 5);
4368 				{
4369 				setState(1009);
4370 				match(STATIC);
4371 				}
4372 				break;
4373 			case FINAL:
4374 				enterOuterAlt(_localctx, 6);
4375 				{
4376 				setState(1010);
4377 				match(FINAL);
4378 				}
4379 				break;
4380 			case TRANSIENT:
4381 				enterOuterAlt(_localctx, 7);
4382 				{
4383 				setState(1011);
4384 				match(TRANSIENT);
4385 				}
4386 				break;
4387 			case VOLATILE:
4388 				enterOuterAlt(_localctx, 8);
4389 				{
4390 				setState(1012);
4391 				match(VOLATILE);
4392 				}
4393 				break;
4394 			default:
4395 				throw new NoViableAltException(this);
4396 			}
4397 		}
4398 		catch (RecognitionException re) {
4399 			_localctx.exception = re;
4400 			_errHandler.reportError(this, re);
4401 			_errHandler.recover(this, re);
4402 		}
4403 		finally {
4404 			exitRule();
4405 		}
4406 		return _localctx;
4407 	}
4408 
4409 	public static class VariableDeclaratorListContext extends ParserRuleContext {
4410 		public List<VariableDeclaratorContext> variableDeclarator() {
4411 			return getRuleContexts(VariableDeclaratorContext.class);
4412 		}
4413 		public VariableDeclaratorContext variableDeclarator(int i) {
4414 			return getRuleContext(VariableDeclaratorContext.class,i);
4415 		}
4416 		public VariableDeclaratorListContext(ParserRuleContext parent, int invokingState) {
4417 			super(parent, invokingState);
4418 		}
4419 		@Override public int getRuleIndex() { return RULE_variableDeclaratorList; }
4420 		@Override
4421 		public void enterRule(ParseTreeListener listener) {
4422 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterVariableDeclaratorList(this);
4423 		}
4424 		@Override
4425 		public void exitRule(ParseTreeListener listener) {
4426 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitVariableDeclaratorList(this);
4427 		}
4428 	}
4429 
4430 	public final VariableDeclaratorListContext variableDeclaratorList() throws RecognitionException {
4431 		VariableDeclaratorListContext _localctx = new VariableDeclaratorListContext(_ctx, getState());
4432 		enterRule(_localctx, 128, RULE_variableDeclaratorList);
4433 		int _la;
4434 		try {
4435 			enterOuterAlt(_localctx, 1);
4436 			{
4437 			setState(1015);
4438 			variableDeclarator();
4439 			setState(1020);
4440 			_errHandler.sync(this);
4441 			_la = _input.LA(1);
4442 			while (_la==COMMA) {
4443 				{
4444 				{
4445 				setState(1016);
4446 				match(COMMA);
4447 				setState(1017);
4448 				variableDeclarator();
4449 				}
4450 				}
4451 				setState(1022);
4452 				_errHandler.sync(this);
4453 				_la = _input.LA(1);
4454 			}
4455 			}
4456 		}
4457 		catch (RecognitionException re) {
4458 			_localctx.exception = re;
4459 			_errHandler.reportError(this, re);
4460 			_errHandler.recover(this, re);
4461 		}
4462 		finally {
4463 			exitRule();
4464 		}
4465 		return _localctx;
4466 	}
4467 
4468 	public static class VariableDeclaratorContext extends ParserRuleContext {
4469 		public VariableDeclaratorIdContext variableDeclaratorId() {
4470 			return getRuleContext(VariableDeclaratorIdContext.class,0);
4471 		}
4472 		public VariableInitializerContext variableInitializer() {
4473 			return getRuleContext(VariableInitializerContext.class,0);
4474 		}
4475 		public VariableDeclaratorContext(ParserRuleContext parent, int invokingState) {
4476 			super(parent, invokingState);
4477 		}
4478 		@Override public int getRuleIndex() { return RULE_variableDeclarator; }
4479 		@Override
4480 		public void enterRule(ParseTreeListener listener) {
4481 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterVariableDeclarator(this);
4482 		}
4483 		@Override
4484 		public void exitRule(ParseTreeListener listener) {
4485 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitVariableDeclarator(this);
4486 		}
4487 	}
4488 
4489 	public final VariableDeclaratorContext variableDeclarator() throws RecognitionException {
4490 		VariableDeclaratorContext _localctx = new VariableDeclaratorContext(_ctx, getState());
4491 		enterRule(_localctx, 130, RULE_variableDeclarator);
4492 		int _la;
4493 		try {
4494 			enterOuterAlt(_localctx, 1);
4495 			{
4496 			setState(1023);
4497 			variableDeclaratorId();
4498 			setState(1026);
4499 			_errHandler.sync(this);
4500 			_la = _input.LA(1);
4501 			if (_la==ASSIGN) {
4502 				{
4503 				setState(1024);
4504 				match(ASSIGN);
4505 				setState(1025);
4506 				variableInitializer();
4507 				}
4508 			}
4509 
4510 			}
4511 		}
4512 		catch (RecognitionException re) {
4513 			_localctx.exception = re;
4514 			_errHandler.reportError(this, re);
4515 			_errHandler.recover(this, re);
4516 		}
4517 		finally {
4518 			exitRule();
4519 		}
4520 		return _localctx;
4521 	}
4522 
4523 	public static class VariableDeclaratorIdContext extends ParserRuleContext {
4524 		public IdentifierContext identifier() {
4525 			return getRuleContext(IdentifierContext.class,0);
4526 		}
4527 		public DimsContext dims() {
4528 			return getRuleContext(DimsContext.class,0);
4529 		}
4530 		public VariableDeclaratorIdContext(ParserRuleContext parent, int invokingState) {
4531 			super(parent, invokingState);
4532 		}
4533 		@Override public int getRuleIndex() { return RULE_variableDeclaratorId; }
4534 		@Override
4535 		public void enterRule(ParseTreeListener listener) {
4536 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterVariableDeclaratorId(this);
4537 		}
4538 		@Override
4539 		public void exitRule(ParseTreeListener listener) {
4540 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitVariableDeclaratorId(this);
4541 		}
4542 	}
4543 
4544 	public final VariableDeclaratorIdContext variableDeclaratorId() throws RecognitionException {
4545 		VariableDeclaratorIdContext _localctx = new VariableDeclaratorIdContext(_ctx, getState());
4546 		enterRule(_localctx, 132, RULE_variableDeclaratorId);
4547 		int _la;
4548 		try {
4549 			enterOuterAlt(_localctx, 1);
4550 			{
4551 			setState(1028);
4552 			identifier();
4553 			setState(1030);
4554 			_errHandler.sync(this);
4555 			_la = _input.LA(1);
4556 			if (_la==LBRACK || _la==AT) {
4557 				{
4558 				setState(1029);
4559 				dims();
4560 				}
4561 			}
4562 
4563 			}
4564 		}
4565 		catch (RecognitionException re) {
4566 			_localctx.exception = re;
4567 			_errHandler.reportError(this, re);
4568 			_errHandler.recover(this, re);
4569 		}
4570 		finally {
4571 			exitRule();
4572 		}
4573 		return _localctx;
4574 	}
4575 
4576 	public static class VariableInitializerContext extends ParserRuleContext {
4577 		public ExpressionContext expression() {
4578 			return getRuleContext(ExpressionContext.class,0);
4579 		}
4580 		public ArrayInitializerContext arrayInitializer() {
4581 			return getRuleContext(ArrayInitializerContext.class,0);
4582 		}
4583 		public VariableInitializerContext(ParserRuleContext parent, int invokingState) {
4584 			super(parent, invokingState);
4585 		}
4586 		@Override public int getRuleIndex() { return RULE_variableInitializer; }
4587 		@Override
4588 		public void enterRule(ParseTreeListener listener) {
4589 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterVariableInitializer(this);
4590 		}
4591 		@Override
4592 		public void exitRule(ParseTreeListener listener) {
4593 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitVariableInitializer(this);
4594 		}
4595 	}
4596 
4597 	public final VariableInitializerContext variableInitializer() throws RecognitionException {
4598 		VariableInitializerContext _localctx = new VariableInitializerContext(_ctx, getState());
4599 		enterRule(_localctx, 134, RULE_variableInitializer);
4600 		try {
4601 			setState(1034);
4602 			_errHandler.sync(this);
4603 			switch (_input.LA(1)) {
4604 			case T__0:
4605 			case T__1:
4606 			case T__2:
4607 			case T__3:
4608 			case T__4:
4609 			case T__5:
4610 			case T__6:
4611 			case T__7:
4612 			case T__8:
4613 			case BOOLEAN:
4614 			case BYTE:
4615 			case CHAR:
4616 			case DOUBLE:
4617 			case FLOAT:
4618 			case INT:
4619 			case LONG:
4620 			case NEW:
4621 			case SHORT:
4622 			case SUPER:
4623 			case THIS:
4624 			case VOID:
4625 			case IntegerLiteral:
4626 			case FloatingPointLiteral:
4627 			case BooleanLiteral:
4628 			case CharacterLiteral:
4629 			case StringLiteral:
4630 			case NullLiteral:
4631 			case LPAREN:
4632 			case AT:
4633 			case BANG:
4634 			case TILDE:
4635 			case INC:
4636 			case DEC:
4637 			case ADD:
4638 			case SUB:
4639 			case Identifier:
4640 				enterOuterAlt(_localctx, 1);
4641 				{
4642 				setState(1032);
4643 				expression();
4644 				}
4645 				break;
4646 			case LBRACE:
4647 				enterOuterAlt(_localctx, 2);
4648 				{
4649 				setState(1033);
4650 				arrayInitializer();
4651 				}
4652 				break;
4653 			default:
4654 				throw new NoViableAltException(this);
4655 			}
4656 		}
4657 		catch (RecognitionException re) {
4658 			_localctx.exception = re;
4659 			_errHandler.reportError(this, re);
4660 			_errHandler.recover(this, re);
4661 		}
4662 		finally {
4663 			exitRule();
4664 		}
4665 		return _localctx;
4666 	}
4667 
4668 	public static class UnannTypeContext extends ParserRuleContext {
4669 		public UnannPrimitiveTypeContext unannPrimitiveType() {
4670 			return getRuleContext(UnannPrimitiveTypeContext.class,0);
4671 		}
4672 		public UnannReferenceTypeContext unannReferenceType() {
4673 			return getRuleContext(UnannReferenceTypeContext.class,0);
4674 		}
4675 		public UnannTypeContext(ParserRuleContext parent, int invokingState) {
4676 			super(parent, invokingState);
4677 		}
4678 		@Override public int getRuleIndex() { return RULE_unannType; }
4679 		@Override
4680 		public void enterRule(ParseTreeListener listener) {
4681 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannType(this);
4682 		}
4683 		@Override
4684 		public void exitRule(ParseTreeListener listener) {
4685 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannType(this);
4686 		}
4687 	}
4688 
4689 	public final UnannTypeContext unannType() throws RecognitionException {
4690 		UnannTypeContext _localctx = new UnannTypeContext(_ctx, getState());
4691 		enterRule(_localctx, 136, RULE_unannType);
4692 		try {
4693 			setState(1038);
4694 			_errHandler.sync(this);
4695 			switch ( getInterpreter().adaptivePredict(_input,72,_ctx) ) {
4696 			case 1:
4697 				enterOuterAlt(_localctx, 1);
4698 				{
4699 				setState(1036);
4700 				unannPrimitiveType();
4701 				}
4702 				break;
4703 			case 2:
4704 				enterOuterAlt(_localctx, 2);
4705 				{
4706 				setState(1037);
4707 				unannReferenceType();
4708 				}
4709 				break;
4710 			}
4711 		}
4712 		catch (RecognitionException re) {
4713 			_localctx.exception = re;
4714 			_errHandler.reportError(this, re);
4715 			_errHandler.recover(this, re);
4716 		}
4717 		finally {
4718 			exitRule();
4719 		}
4720 		return _localctx;
4721 	}
4722 
4723 	public static class UnannPrimitiveTypeContext extends ParserRuleContext {
4724 		public NumericTypeContext numericType() {
4725 			return getRuleContext(NumericTypeContext.class,0);
4726 		}
4727 		public UnannPrimitiveTypeContext(ParserRuleContext parent, int invokingState) {
4728 			super(parent, invokingState);
4729 		}
4730 		@Override public int getRuleIndex() { return RULE_unannPrimitiveType; }
4731 		@Override
4732 		public void enterRule(ParseTreeListener listener) {
4733 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannPrimitiveType(this);
4734 		}
4735 		@Override
4736 		public void exitRule(ParseTreeListener listener) {
4737 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannPrimitiveType(this);
4738 		}
4739 	}
4740 
4741 	public final UnannPrimitiveTypeContext unannPrimitiveType() throws RecognitionException {
4742 		UnannPrimitiveTypeContext _localctx = new UnannPrimitiveTypeContext(_ctx, getState());
4743 		enterRule(_localctx, 138, RULE_unannPrimitiveType);
4744 		try {
4745 			setState(1042);
4746 			_errHandler.sync(this);
4747 			switch (_input.LA(1)) {
4748 			case BYTE:
4749 			case CHAR:
4750 			case DOUBLE:
4751 			case FLOAT:
4752 			case INT:
4753 			case LONG:
4754 			case SHORT:
4755 				enterOuterAlt(_localctx, 1);
4756 				{
4757 				setState(1040);
4758 				numericType();
4759 				}
4760 				break;
4761 			case BOOLEAN:
4762 				enterOuterAlt(_localctx, 2);
4763 				{
4764 				setState(1041);
4765 				match(BOOLEAN);
4766 				}
4767 				break;
4768 			default:
4769 				throw new NoViableAltException(this);
4770 			}
4771 		}
4772 		catch (RecognitionException re) {
4773 			_localctx.exception = re;
4774 			_errHandler.reportError(this, re);
4775 			_errHandler.recover(this, re);
4776 		}
4777 		finally {
4778 			exitRule();
4779 		}
4780 		return _localctx;
4781 	}
4782 
4783 	public static class UnannReferenceTypeContext extends ParserRuleContext {
4784 		public UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() {
4785 			return getRuleContext(UnannClassOrInterfaceTypeContext.class,0);
4786 		}
4787 		public UnannTypeVariableContext unannTypeVariable() {
4788 			return getRuleContext(UnannTypeVariableContext.class,0);
4789 		}
4790 		public UnannArrayTypeContext unannArrayType() {
4791 			return getRuleContext(UnannArrayTypeContext.class,0);
4792 		}
4793 		public UnannReferenceTypeContext(ParserRuleContext parent, int invokingState) {
4794 			super(parent, invokingState);
4795 		}
4796 		@Override public int getRuleIndex() { return RULE_unannReferenceType; }
4797 		@Override
4798 		public void enterRule(ParseTreeListener listener) {
4799 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannReferenceType(this);
4800 		}
4801 		@Override
4802 		public void exitRule(ParseTreeListener listener) {
4803 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannReferenceType(this);
4804 		}
4805 	}
4806 
4807 	public final UnannReferenceTypeContext unannReferenceType() throws RecognitionException {
4808 		UnannReferenceTypeContext _localctx = new UnannReferenceTypeContext(_ctx, getState());
4809 		enterRule(_localctx, 140, RULE_unannReferenceType);
4810 		try {
4811 			setState(1047);
4812 			_errHandler.sync(this);
4813 			switch ( getInterpreter().adaptivePredict(_input,74,_ctx) ) {
4814 			case 1:
4815 				enterOuterAlt(_localctx, 1);
4816 				{
4817 				setState(1044);
4818 				unannClassOrInterfaceType();
4819 				}
4820 				break;
4821 			case 2:
4822 				enterOuterAlt(_localctx, 2);
4823 				{
4824 				setState(1045);
4825 				unannTypeVariable();
4826 				}
4827 				break;
4828 			case 3:
4829 				enterOuterAlt(_localctx, 3);
4830 				{
4831 				setState(1046);
4832 				unannArrayType();
4833 				}
4834 				break;
4835 			}
4836 		}
4837 		catch (RecognitionException re) {
4838 			_localctx.exception = re;
4839 			_errHandler.reportError(this, re);
4840 			_errHandler.recover(this, re);
4841 		}
4842 		finally {
4843 			exitRule();
4844 		}
4845 		return _localctx;
4846 	}
4847 
4848 	public static class UnannClassOrInterfaceTypeContext extends ParserRuleContext {
4849 		public UnannClassType_lfno_unannClassOrInterfaceTypeContext unannClassType_lfno_unannClassOrInterfaceType() {
4850 			return getRuleContext(UnannClassType_lfno_unannClassOrInterfaceTypeContext.class,0);
4851 		}
4852 		public UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext unannInterfaceType_lfno_unannClassOrInterfaceType() {
4853 			return getRuleContext(UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext.class,0);
4854 		}
4855 		public List<UnannClassType_lf_unannClassOrInterfaceTypeContext> unannClassType_lf_unannClassOrInterfaceType() {
4856 			return getRuleContexts(UnannClassType_lf_unannClassOrInterfaceTypeContext.class);
4857 		}
4858 		public UnannClassType_lf_unannClassOrInterfaceTypeContext unannClassType_lf_unannClassOrInterfaceType(int i) {
4859 			return getRuleContext(UnannClassType_lf_unannClassOrInterfaceTypeContext.class,i);
4860 		}
4861 		public List<UnannInterfaceType_lf_unannClassOrInterfaceTypeContext> unannInterfaceType_lf_unannClassOrInterfaceType() {
4862 			return getRuleContexts(UnannInterfaceType_lf_unannClassOrInterfaceTypeContext.class);
4863 		}
4864 		public UnannInterfaceType_lf_unannClassOrInterfaceTypeContext unannInterfaceType_lf_unannClassOrInterfaceType(int i) {
4865 			return getRuleContext(UnannInterfaceType_lf_unannClassOrInterfaceTypeContext.class,i);
4866 		}
4867 		public UnannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
4868 			super(parent, invokingState);
4869 		}
4870 		@Override public int getRuleIndex() { return RULE_unannClassOrInterfaceType; }
4871 		@Override
4872 		public void enterRule(ParseTreeListener listener) {
4873 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannClassOrInterfaceType(this);
4874 		}
4875 		@Override
4876 		public void exitRule(ParseTreeListener listener) {
4877 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannClassOrInterfaceType(this);
4878 		}
4879 	}
4880 
4881 	public final UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() throws RecognitionException {
4882 		UnannClassOrInterfaceTypeContext _localctx = new UnannClassOrInterfaceTypeContext(_ctx, getState());
4883 		enterRule(_localctx, 142, RULE_unannClassOrInterfaceType);
4884 		try {
4885 			int _alt;
4886 			enterOuterAlt(_localctx, 1);
4887 			{
4888 			setState(1051);
4889 			_errHandler.sync(this);
4890 			switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
4891 			case 1:
4892 				{
4893 				setState(1049);
4894 				unannClassType_lfno_unannClassOrInterfaceType();
4895 				}
4896 				break;
4897 			case 2:
4898 				{
4899 				setState(1050);
4900 				unannInterfaceType_lfno_unannClassOrInterfaceType();
4901 				}
4902 				break;
4903 			}
4904 			setState(1057);
4905 			_errHandler.sync(this);
4906 			_alt = getInterpreter().adaptivePredict(_input,77,_ctx);
4907 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
4908 				if ( _alt==1 ) {
4909 					{
4910 					setState(1055);
4911 					_errHandler.sync(this);
4912 					switch ( getInterpreter().adaptivePredict(_input,76,_ctx) ) {
4913 					case 1:
4914 						{
4915 						setState(1053);
4916 						unannClassType_lf_unannClassOrInterfaceType();
4917 						}
4918 						break;
4919 					case 2:
4920 						{
4921 						setState(1054);
4922 						unannInterfaceType_lf_unannClassOrInterfaceType();
4923 						}
4924 						break;
4925 					}
4926 					} 
4927 				}
4928 				setState(1059);
4929 				_errHandler.sync(this);
4930 				_alt = getInterpreter().adaptivePredict(_input,77,_ctx);
4931 			}
4932 			}
4933 		}
4934 		catch (RecognitionException re) {
4935 			_localctx.exception = re;
4936 			_errHandler.reportError(this, re);
4937 			_errHandler.recover(this, re);
4938 		}
4939 		finally {
4940 			exitRule();
4941 		}
4942 		return _localctx;
4943 	}
4944 
4945 	public static class UnannClassTypeContext extends ParserRuleContext {
4946 		public IdentifierContext identifier() {
4947 			return getRuleContext(IdentifierContext.class,0);
4948 		}
4949 		public TypeArgumentsContext typeArguments() {
4950 			return getRuleContext(TypeArgumentsContext.class,0);
4951 		}
4952 		public UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() {
4953 			return getRuleContext(UnannClassOrInterfaceTypeContext.class,0);
4954 		}
4955 		public List<AnnotationContext> annotation() {
4956 			return getRuleContexts(AnnotationContext.class);
4957 		}
4958 		public AnnotationContext annotation(int i) {
4959 			return getRuleContext(AnnotationContext.class,i);
4960 		}
4961 		public UnannClassTypeContext(ParserRuleContext parent, int invokingState) {
4962 			super(parent, invokingState);
4963 		}
4964 		@Override public int getRuleIndex() { return RULE_unannClassType; }
4965 		@Override
4966 		public void enterRule(ParseTreeListener listener) {
4967 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannClassType(this);
4968 		}
4969 		@Override
4970 		public void exitRule(ParseTreeListener listener) {
4971 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannClassType(this);
4972 		}
4973 	}
4974 
4975 	public final UnannClassTypeContext unannClassType() throws RecognitionException {
4976 		UnannClassTypeContext _localctx = new UnannClassTypeContext(_ctx, getState());
4977 		enterRule(_localctx, 144, RULE_unannClassType);
4978 		int _la;
4979 		try {
4980 			setState(1076);
4981 			_errHandler.sync(this);
4982 			switch ( getInterpreter().adaptivePredict(_input,81,_ctx) ) {
4983 			case 1:
4984 				enterOuterAlt(_localctx, 1);
4985 				{
4986 				setState(1060);
4987 				identifier();
4988 				setState(1062);
4989 				_errHandler.sync(this);
4990 				_la = _input.LA(1);
4991 				if (_la==LT) {
4992 					{
4993 					setState(1061);
4994 					typeArguments();
4995 					}
4996 				}
4997 
4998 				}
4999 				break;
5000 			case 2:
5001 				enterOuterAlt(_localctx, 2);
5002 				{
5003 				setState(1064);
5004 				unannClassOrInterfaceType();
5005 				setState(1065);
5006 				match(DOT);
5007 				setState(1069);
5008 				_errHandler.sync(this);
5009 				_la = _input.LA(1);
5010 				while (_la==AT) {
5011 					{
5012 					{
5013 					setState(1066);
5014 					annotation();
5015 					}
5016 					}
5017 					setState(1071);
5018 					_errHandler.sync(this);
5019 					_la = _input.LA(1);
5020 				}
5021 				setState(1072);
5022 				identifier();
5023 				setState(1074);
5024 				_errHandler.sync(this);
5025 				_la = _input.LA(1);
5026 				if (_la==LT) {
5027 					{
5028 					setState(1073);
5029 					typeArguments();
5030 					}
5031 				}
5032 
5033 				}
5034 				break;
5035 			}
5036 		}
5037 		catch (RecognitionException re) {
5038 			_localctx.exception = re;
5039 			_errHandler.reportError(this, re);
5040 			_errHandler.recover(this, re);
5041 		}
5042 		finally {
5043 			exitRule();
5044 		}
5045 		return _localctx;
5046 	}
5047 
5048 	public static class UnannClassType_lf_unannClassOrInterfaceTypeContext extends ParserRuleContext {
5049 		public IdentifierContext identifier() {
5050 			return getRuleContext(IdentifierContext.class,0);
5051 		}
5052 		public List<AnnotationContext> annotation() {
5053 			return getRuleContexts(AnnotationContext.class);
5054 		}
5055 		public AnnotationContext annotation(int i) {
5056 			return getRuleContext(AnnotationContext.class,i);
5057 		}
5058 		public TypeArgumentsContext typeArguments() {
5059 			return getRuleContext(TypeArgumentsContext.class,0);
5060 		}
5061 		public UnannClassType_lf_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
5062 			super(parent, invokingState);
5063 		}
5064 		@Override public int getRuleIndex() { return RULE_unannClassType_lf_unannClassOrInterfaceType; }
5065 		@Override
5066 		public void enterRule(ParseTreeListener listener) {
5067 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannClassType_lf_unannClassOrInterfaceType(this);
5068 		}
5069 		@Override
5070 		public void exitRule(ParseTreeListener listener) {
5071 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannClassType_lf_unannClassOrInterfaceType(this);
5072 		}
5073 	}
5074 
5075 	public final UnannClassType_lf_unannClassOrInterfaceTypeContext unannClassType_lf_unannClassOrInterfaceType() throws RecognitionException {
5076 		UnannClassType_lf_unannClassOrInterfaceTypeContext _localctx = new UnannClassType_lf_unannClassOrInterfaceTypeContext(_ctx, getState());
5077 		enterRule(_localctx, 146, RULE_unannClassType_lf_unannClassOrInterfaceType);
5078 		int _la;
5079 		try {
5080 			enterOuterAlt(_localctx, 1);
5081 			{
5082 			setState(1078);
5083 			match(DOT);
5084 			setState(1082);
5085 			_errHandler.sync(this);
5086 			_la = _input.LA(1);
5087 			while (_la==AT) {
5088 				{
5089 				{
5090 				setState(1079);
5091 				annotation();
5092 				}
5093 				}
5094 				setState(1084);
5095 				_errHandler.sync(this);
5096 				_la = _input.LA(1);
5097 			}
5098 			setState(1085);
5099 			identifier();
5100 			setState(1087);
5101 			_errHandler.sync(this);
5102 			_la = _input.LA(1);
5103 			if (_la==LT) {
5104 				{
5105 				setState(1086);
5106 				typeArguments();
5107 				}
5108 			}
5109 
5110 			}
5111 		}
5112 		catch (RecognitionException re) {
5113 			_localctx.exception = re;
5114 			_errHandler.reportError(this, re);
5115 			_errHandler.recover(this, re);
5116 		}
5117 		finally {
5118 			exitRule();
5119 		}
5120 		return _localctx;
5121 	}
5122 
5123 	public static class UnannClassType_lfno_unannClassOrInterfaceTypeContext extends ParserRuleContext {
5124 		public IdentifierContext identifier() {
5125 			return getRuleContext(IdentifierContext.class,0);
5126 		}
5127 		public TypeArgumentsContext typeArguments() {
5128 			return getRuleContext(TypeArgumentsContext.class,0);
5129 		}
5130 		public UnannClassType_lfno_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
5131 			super(parent, invokingState);
5132 		}
5133 		@Override public int getRuleIndex() { return RULE_unannClassType_lfno_unannClassOrInterfaceType; }
5134 		@Override
5135 		public void enterRule(ParseTreeListener listener) {
5136 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannClassType_lfno_unannClassOrInterfaceType(this);
5137 		}
5138 		@Override
5139 		public void exitRule(ParseTreeListener listener) {
5140 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannClassType_lfno_unannClassOrInterfaceType(this);
5141 		}
5142 	}
5143 
5144 	public final UnannClassType_lfno_unannClassOrInterfaceTypeContext unannClassType_lfno_unannClassOrInterfaceType() throws RecognitionException {
5145 		UnannClassType_lfno_unannClassOrInterfaceTypeContext _localctx = new UnannClassType_lfno_unannClassOrInterfaceTypeContext(_ctx, getState());
5146 		enterRule(_localctx, 148, RULE_unannClassType_lfno_unannClassOrInterfaceType);
5147 		int _la;
5148 		try {
5149 			enterOuterAlt(_localctx, 1);
5150 			{
5151 			setState(1089);
5152 			identifier();
5153 			setState(1091);
5154 			_errHandler.sync(this);
5155 			_la = _input.LA(1);
5156 			if (_la==LT) {
5157 				{
5158 				setState(1090);
5159 				typeArguments();
5160 				}
5161 			}
5162 
5163 			}
5164 		}
5165 		catch (RecognitionException re) {
5166 			_localctx.exception = re;
5167 			_errHandler.reportError(this, re);
5168 			_errHandler.recover(this, re);
5169 		}
5170 		finally {
5171 			exitRule();
5172 		}
5173 		return _localctx;
5174 	}
5175 
5176 	public static class UnannInterfaceTypeContext extends ParserRuleContext {
5177 		public UnannClassTypeContext unannClassType() {
5178 			return getRuleContext(UnannClassTypeContext.class,0);
5179 		}
5180 		public UnannInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
5181 			super(parent, invokingState);
5182 		}
5183 		@Override public int getRuleIndex() { return RULE_unannInterfaceType; }
5184 		@Override
5185 		public void enterRule(ParseTreeListener listener) {
5186 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannInterfaceType(this);
5187 		}
5188 		@Override
5189 		public void exitRule(ParseTreeListener listener) {
5190 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannInterfaceType(this);
5191 		}
5192 	}
5193 
5194 	public final UnannInterfaceTypeContext unannInterfaceType() throws RecognitionException {
5195 		UnannInterfaceTypeContext _localctx = new UnannInterfaceTypeContext(_ctx, getState());
5196 		enterRule(_localctx, 150, RULE_unannInterfaceType);
5197 		try {
5198 			enterOuterAlt(_localctx, 1);
5199 			{
5200 			setState(1093);
5201 			unannClassType();
5202 			}
5203 		}
5204 		catch (RecognitionException re) {
5205 			_localctx.exception = re;
5206 			_errHandler.reportError(this, re);
5207 			_errHandler.recover(this, re);
5208 		}
5209 		finally {
5210 			exitRule();
5211 		}
5212 		return _localctx;
5213 	}
5214 
5215 	public static class UnannInterfaceType_lf_unannClassOrInterfaceTypeContext extends ParserRuleContext {
5216 		public UnannClassType_lf_unannClassOrInterfaceTypeContext unannClassType_lf_unannClassOrInterfaceType() {
5217 			return getRuleContext(UnannClassType_lf_unannClassOrInterfaceTypeContext.class,0);
5218 		}
5219 		public UnannInterfaceType_lf_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
5220 			super(parent, invokingState);
5221 		}
5222 		@Override public int getRuleIndex() { return RULE_unannInterfaceType_lf_unannClassOrInterfaceType; }
5223 		@Override
5224 		public void enterRule(ParseTreeListener listener) {
5225 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannInterfaceType_lf_unannClassOrInterfaceType(this);
5226 		}
5227 		@Override
5228 		public void exitRule(ParseTreeListener listener) {
5229 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannInterfaceType_lf_unannClassOrInterfaceType(this);
5230 		}
5231 	}
5232 
5233 	public final UnannInterfaceType_lf_unannClassOrInterfaceTypeContext unannInterfaceType_lf_unannClassOrInterfaceType() throws RecognitionException {
5234 		UnannInterfaceType_lf_unannClassOrInterfaceTypeContext _localctx = new UnannInterfaceType_lf_unannClassOrInterfaceTypeContext(_ctx, getState());
5235 		enterRule(_localctx, 152, RULE_unannInterfaceType_lf_unannClassOrInterfaceType);
5236 		try {
5237 			enterOuterAlt(_localctx, 1);
5238 			{
5239 			setState(1095);
5240 			unannClassType_lf_unannClassOrInterfaceType();
5241 			}
5242 		}
5243 		catch (RecognitionException re) {
5244 			_localctx.exception = re;
5245 			_errHandler.reportError(this, re);
5246 			_errHandler.recover(this, re);
5247 		}
5248 		finally {
5249 			exitRule();
5250 		}
5251 		return _localctx;
5252 	}
5253 
5254 	public static class UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext extends ParserRuleContext {
5255 		public UnannClassType_lfno_unannClassOrInterfaceTypeContext unannClassType_lfno_unannClassOrInterfaceType() {
5256 			return getRuleContext(UnannClassType_lfno_unannClassOrInterfaceTypeContext.class,0);
5257 		}
5258 		public UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
5259 			super(parent, invokingState);
5260 		}
5261 		@Override public int getRuleIndex() { return RULE_unannInterfaceType_lfno_unannClassOrInterfaceType; }
5262 		@Override
5263 		public void enterRule(ParseTreeListener listener) {
5264 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannInterfaceType_lfno_unannClassOrInterfaceType(this);
5265 		}
5266 		@Override
5267 		public void exitRule(ParseTreeListener listener) {
5268 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannInterfaceType_lfno_unannClassOrInterfaceType(this);
5269 		}
5270 	}
5271 
5272 	public final UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext unannInterfaceType_lfno_unannClassOrInterfaceType() throws RecognitionException {
5273 		UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext _localctx = new UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext(_ctx, getState());
5274 		enterRule(_localctx, 154, RULE_unannInterfaceType_lfno_unannClassOrInterfaceType);
5275 		try {
5276 			enterOuterAlt(_localctx, 1);
5277 			{
5278 			setState(1097);
5279 			unannClassType_lfno_unannClassOrInterfaceType();
5280 			}
5281 		}
5282 		catch (RecognitionException re) {
5283 			_localctx.exception = re;
5284 			_errHandler.reportError(this, re);
5285 			_errHandler.recover(this, re);
5286 		}
5287 		finally {
5288 			exitRule();
5289 		}
5290 		return _localctx;
5291 	}
5292 
5293 	public static class UnannTypeVariableContext extends ParserRuleContext {
5294 		public IdentifierContext identifier() {
5295 			return getRuleContext(IdentifierContext.class,0);
5296 		}
5297 		public UnannTypeVariableContext(ParserRuleContext parent, int invokingState) {
5298 			super(parent, invokingState);
5299 		}
5300 		@Override public int getRuleIndex() { return RULE_unannTypeVariable; }
5301 		@Override
5302 		public void enterRule(ParseTreeListener listener) {
5303 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannTypeVariable(this);
5304 		}
5305 		@Override
5306 		public void exitRule(ParseTreeListener listener) {
5307 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannTypeVariable(this);
5308 		}
5309 	}
5310 
5311 	public final UnannTypeVariableContext unannTypeVariable() throws RecognitionException {
5312 		UnannTypeVariableContext _localctx = new UnannTypeVariableContext(_ctx, getState());
5313 		enterRule(_localctx, 156, RULE_unannTypeVariable);
5314 		try {
5315 			enterOuterAlt(_localctx, 1);
5316 			{
5317 			setState(1099);
5318 			identifier();
5319 			}
5320 		}
5321 		catch (RecognitionException re) {
5322 			_localctx.exception = re;
5323 			_errHandler.reportError(this, re);
5324 			_errHandler.recover(this, re);
5325 		}
5326 		finally {
5327 			exitRule();
5328 		}
5329 		return _localctx;
5330 	}
5331 
5332 	public static class UnannArrayTypeContext extends ParserRuleContext {
5333 		public UnannPrimitiveTypeContext unannPrimitiveType() {
5334 			return getRuleContext(UnannPrimitiveTypeContext.class,0);
5335 		}
5336 		public DimsContext dims() {
5337 			return getRuleContext(DimsContext.class,0);
5338 		}
5339 		public UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() {
5340 			return getRuleContext(UnannClassOrInterfaceTypeContext.class,0);
5341 		}
5342 		public UnannTypeVariableContext unannTypeVariable() {
5343 			return getRuleContext(UnannTypeVariableContext.class,0);
5344 		}
5345 		public UnannArrayTypeContext(ParserRuleContext parent, int invokingState) {
5346 			super(parent, invokingState);
5347 		}
5348 		@Override public int getRuleIndex() { return RULE_unannArrayType; }
5349 		@Override
5350 		public void enterRule(ParseTreeListener listener) {
5351 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannArrayType(this);
5352 		}
5353 		@Override
5354 		public void exitRule(ParseTreeListener listener) {
5355 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannArrayType(this);
5356 		}
5357 	}
5358 
5359 	public final UnannArrayTypeContext unannArrayType() throws RecognitionException {
5360 		UnannArrayTypeContext _localctx = new UnannArrayTypeContext(_ctx, getState());
5361 		enterRule(_localctx, 158, RULE_unannArrayType);
5362 		try {
5363 			setState(1110);
5364 			_errHandler.sync(this);
5365 			switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) {
5366 			case 1:
5367 				enterOuterAlt(_localctx, 1);
5368 				{
5369 				setState(1101);
5370 				unannPrimitiveType();
5371 				setState(1102);
5372 				dims();
5373 				}
5374 				break;
5375 			case 2:
5376 				enterOuterAlt(_localctx, 2);
5377 				{
5378 				setState(1104);
5379 				unannClassOrInterfaceType();
5380 				setState(1105);
5381 				dims();
5382 				}
5383 				break;
5384 			case 3:
5385 				enterOuterAlt(_localctx, 3);
5386 				{
5387 				setState(1107);
5388 				unannTypeVariable();
5389 				setState(1108);
5390 				dims();
5391 				}
5392 				break;
5393 			}
5394 		}
5395 		catch (RecognitionException re) {
5396 			_localctx.exception = re;
5397 			_errHandler.reportError(this, re);
5398 			_errHandler.recover(this, re);
5399 		}
5400 		finally {
5401 			exitRule();
5402 		}
5403 		return _localctx;
5404 	}
5405 
5406 	public static class MethodDeclarationContext extends ParserRuleContext {
5407 		public MethodHeaderContext methodHeader() {
5408 			return getRuleContext(MethodHeaderContext.class,0);
5409 		}
5410 		public MethodBodyContext methodBody() {
5411 			return getRuleContext(MethodBodyContext.class,0);
5412 		}
5413 		public List<MethodModifierContext> methodModifier() {
5414 			return getRuleContexts(MethodModifierContext.class);
5415 		}
5416 		public MethodModifierContext methodModifier(int i) {
5417 			return getRuleContext(MethodModifierContext.class,i);
5418 		}
5419 		public MethodDeclarationContext(ParserRuleContext parent, int invokingState) {
5420 			super(parent, invokingState);
5421 		}
5422 		@Override public int getRuleIndex() { return RULE_methodDeclaration; }
5423 		@Override
5424 		public void enterRule(ParseTreeListener listener) {
5425 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterMethodDeclaration(this);
5426 		}
5427 		@Override
5428 		public void exitRule(ParseTreeListener listener) {
5429 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitMethodDeclaration(this);
5430 		}
5431 	}
5432 
5433 	public final MethodDeclarationContext methodDeclaration() throws RecognitionException {
5434 		MethodDeclarationContext _localctx = new MethodDeclarationContext(_ctx, getState());
5435 		enterRule(_localctx, 160, RULE_methodDeclaration);
5436 		int _la;
5437 		try {
5438 			enterOuterAlt(_localctx, 1);
5439 			{
5440 			setState(1115);
5441 			_errHandler.sync(this);
5442 			_la = _input.LA(1);
5443 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << NATIVE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP) | (1L << SYNCHRONIZED))) != 0) || _la==AT) {
5444 				{
5445 				{
5446 				setState(1112);
5447 				methodModifier();
5448 				}
5449 				}
5450 				setState(1117);
5451 				_errHandler.sync(this);
5452 				_la = _input.LA(1);
5453 			}
5454 			setState(1118);
5455 			methodHeader();
5456 			setState(1119);
5457 			methodBody();
5458 			}
5459 		}
5460 		catch (RecognitionException re) {
5461 			_localctx.exception = re;
5462 			_errHandler.reportError(this, re);
5463 			_errHandler.recover(this, re);
5464 		}
5465 		finally {
5466 			exitRule();
5467 		}
5468 		return _localctx;
5469 	}
5470 
5471 	public static class MethodModifierContext extends ParserRuleContext {
5472 		public AnnotationContext annotation() {
5473 			return getRuleContext(AnnotationContext.class,0);
5474 		}
5475 		public MethodModifierContext(ParserRuleContext parent, int invokingState) {
5476 			super(parent, invokingState);
5477 		}
5478 		@Override public int getRuleIndex() { return RULE_methodModifier; }
5479 		@Override
5480 		public void enterRule(ParseTreeListener listener) {
5481 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterMethodModifier(this);
5482 		}
5483 		@Override
5484 		public void exitRule(ParseTreeListener listener) {
5485 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitMethodModifier(this);
5486 		}
5487 	}
5488 
5489 	public final MethodModifierContext methodModifier() throws RecognitionException {
5490 		MethodModifierContext _localctx = new MethodModifierContext(_ctx, getState());
5491 		enterRule(_localctx, 162, RULE_methodModifier);
5492 		try {
5493 			setState(1131);
5494 			_errHandler.sync(this);
5495 			switch (_input.LA(1)) {
5496 			case AT:
5497 				enterOuterAlt(_localctx, 1);
5498 				{
5499 				setState(1121);
5500 				annotation();
5501 				}
5502 				break;
5503 			case PUBLIC:
5504 				enterOuterAlt(_localctx, 2);
5505 				{
5506 				setState(1122);
5507 				match(PUBLIC);
5508 				}
5509 				break;
5510 			case PROTECTED:
5511 				enterOuterAlt(_localctx, 3);
5512 				{
5513 				setState(1123);
5514 				match(PROTECTED);
5515 				}
5516 				break;
5517 			case PRIVATE:
5518 				enterOuterAlt(_localctx, 4);
5519 				{
5520 				setState(1124);
5521 				match(PRIVATE);
5522 				}
5523 				break;
5524 			case ABSTRACT:
5525 				enterOuterAlt(_localctx, 5);
5526 				{
5527 				setState(1125);
5528 				match(ABSTRACT);
5529 				}
5530 				break;
5531 			case STATIC:
5532 				enterOuterAlt(_localctx, 6);
5533 				{
5534 				setState(1126);
5535 				match(STATIC);
5536 				}
5537 				break;
5538 			case FINAL:
5539 				enterOuterAlt(_localctx, 7);
5540 				{
5541 				setState(1127);
5542 				match(FINAL);
5543 				}
5544 				break;
5545 			case SYNCHRONIZED:
5546 				enterOuterAlt(_localctx, 8);
5547 				{
5548 				setState(1128);
5549 				match(SYNCHRONIZED);
5550 				}
5551 				break;
5552 			case NATIVE:
5553 				enterOuterAlt(_localctx, 9);
5554 				{
5555 				setState(1129);
5556 				match(NATIVE);
5557 				}
5558 				break;
5559 			case STRICTFP:
5560 				enterOuterAlt(_localctx, 10);
5561 				{
5562 				setState(1130);
5563 				match(STRICTFP);
5564 				}
5565 				break;
5566 			default:
5567 				throw new NoViableAltException(this);
5568 			}
5569 		}
5570 		catch (RecognitionException re) {
5571 			_localctx.exception = re;
5572 			_errHandler.reportError(this, re);
5573 			_errHandler.recover(this, re);
5574 		}
5575 		finally {
5576 			exitRule();
5577 		}
5578 		return _localctx;
5579 	}
5580 
5581 	public static class MethodHeaderContext extends ParserRuleContext {
5582 		public ResultContext result() {
5583 			return getRuleContext(ResultContext.class,0);
5584 		}
5585 		public MethodDeclaratorContext methodDeclarator() {
5586 			return getRuleContext(MethodDeclaratorContext.class,0);
5587 		}
5588 		public Throws_Context throws_() {
5589 			return getRuleContext(Throws_Context.class,0);
5590 		}
5591 		public TypeParametersContext typeParameters() {
5592 			return getRuleContext(TypeParametersContext.class,0);
5593 		}
5594 		public List<AnnotationContext> annotation() {
5595 			return getRuleContexts(AnnotationContext.class);
5596 		}
5597 		public AnnotationContext annotation(int i) {
5598 			return getRuleContext(AnnotationContext.class,i);
5599 		}
5600 		public MethodHeaderContext(ParserRuleContext parent, int invokingState) {
5601 			super(parent, invokingState);
5602 		}
5603 		@Override public int getRuleIndex() { return RULE_methodHeader; }
5604 		@Override
5605 		public void enterRule(ParseTreeListener listener) {
5606 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterMethodHeader(this);
5607 		}
5608 		@Override
5609 		public void exitRule(ParseTreeListener listener) {
5610 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitMethodHeader(this);
5611 		}
5612 	}
5613 
5614 	public final MethodHeaderContext methodHeader() throws RecognitionException {
5615 		MethodHeaderContext _localctx = new MethodHeaderContext(_ctx, getState());
5616 		enterRule(_localctx, 164, RULE_methodHeader);
5617 		int _la;
5618 		try {
5619 			setState(1150);
5620 			_errHandler.sync(this);
5621 			switch (_input.LA(1)) {
5622 			case T__0:
5623 			case T__1:
5624 			case T__2:
5625 			case T__3:
5626 			case T__4:
5627 			case T__5:
5628 			case T__6:
5629 			case T__7:
5630 			case T__8:
5631 			case BOOLEAN:
5632 			case BYTE:
5633 			case CHAR:
5634 			case DOUBLE:
5635 			case FLOAT:
5636 			case INT:
5637 			case LONG:
5638 			case SHORT:
5639 			case VOID:
5640 			case Identifier:
5641 				enterOuterAlt(_localctx, 1);
5642 				{
5643 				setState(1133);
5644 				result();
5645 				setState(1134);
5646 				methodDeclarator();
5647 				setState(1136);
5648 				_errHandler.sync(this);
5649 				_la = _input.LA(1);
5650 				if (_la==THROWS) {
5651 					{
5652 					setState(1135);
5653 					throws_();
5654 					}
5655 				}
5656 
5657 				}
5658 				break;
5659 			case LT:
5660 				enterOuterAlt(_localctx, 2);
5661 				{
5662 				setState(1138);
5663 				typeParameters();
5664 				setState(1142);
5665 				_errHandler.sync(this);
5666 				_la = _input.LA(1);
5667 				while (_la==AT) {
5668 					{
5669 					{
5670 					setState(1139);
5671 					annotation();
5672 					}
5673 					}
5674 					setState(1144);
5675 					_errHandler.sync(this);
5676 					_la = _input.LA(1);
5677 				}
5678 				setState(1145);
5679 				result();
5680 				setState(1146);
5681 				methodDeclarator();
5682 				setState(1148);
5683 				_errHandler.sync(this);
5684 				_la = _input.LA(1);
5685 				if (_la==THROWS) {
5686 					{
5687 					setState(1147);
5688 					throws_();
5689 					}
5690 				}
5691 
5692 				}
5693 				break;
5694 			default:
5695 				throw new NoViableAltException(this);
5696 			}
5697 		}
5698 		catch (RecognitionException re) {
5699 			_localctx.exception = re;
5700 			_errHandler.reportError(this, re);
5701 			_errHandler.recover(this, re);
5702 		}
5703 		finally {
5704 			exitRule();
5705 		}
5706 		return _localctx;
5707 	}
5708 
5709 	public static class ResultContext extends ParserRuleContext {
5710 		public UnannTypeContext unannType() {
5711 			return getRuleContext(UnannTypeContext.class,0);
5712 		}
5713 		public ResultContext(ParserRuleContext parent, int invokingState) {
5714 			super(parent, invokingState);
5715 		}
5716 		@Override public int getRuleIndex() { return RULE_result; }
5717 		@Override
5718 		public void enterRule(ParseTreeListener listener) {
5719 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterResult(this);
5720 		}
5721 		@Override
5722 		public void exitRule(ParseTreeListener listener) {
5723 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitResult(this);
5724 		}
5725 	}
5726 
5727 	public final ResultContext result() throws RecognitionException {
5728 		ResultContext _localctx = new ResultContext(_ctx, getState());
5729 		enterRule(_localctx, 166, RULE_result);
5730 		try {
5731 			setState(1154);
5732 			_errHandler.sync(this);
5733 			switch (_input.LA(1)) {
5734 			case T__0:
5735 			case T__1:
5736 			case T__2:
5737 			case T__3:
5738 			case T__4:
5739 			case T__5:
5740 			case T__6:
5741 			case T__7:
5742 			case T__8:
5743 			case BOOLEAN:
5744 			case BYTE:
5745 			case CHAR:
5746 			case DOUBLE:
5747 			case FLOAT:
5748 			case INT:
5749 			case LONG:
5750 			case SHORT:
5751 			case Identifier:
5752 				enterOuterAlt(_localctx, 1);
5753 				{
5754 				setState(1152);
5755 				unannType();
5756 				}
5757 				break;
5758 			case VOID:
5759 				enterOuterAlt(_localctx, 2);
5760 				{
5761 				setState(1153);
5762 				match(VOID);
5763 				}
5764 				break;
5765 			default:
5766 				throw new NoViableAltException(this);
5767 			}
5768 		}
5769 		catch (RecognitionException re) {
5770 			_localctx.exception = re;
5771 			_errHandler.reportError(this, re);
5772 			_errHandler.recover(this, re);
5773 		}
5774 		finally {
5775 			exitRule();
5776 		}
5777 		return _localctx;
5778 	}
5779 
5780 	public static class MethodDeclaratorContext extends ParserRuleContext {
5781 		public IdentifierContext identifier() {
5782 			return getRuleContext(IdentifierContext.class,0);
5783 		}
5784 		public FormalParameterListContext formalParameterList() {
5785 			return getRuleContext(FormalParameterListContext.class,0);
5786 		}
5787 		public DimsContext dims() {
5788 			return getRuleContext(DimsContext.class,0);
5789 		}
5790 		public MethodDeclaratorContext(ParserRuleContext parent, int invokingState) {
5791 			super(parent, invokingState);
5792 		}
5793 		@Override public int getRuleIndex() { return RULE_methodDeclarator; }
5794 		@Override
5795 		public void enterRule(ParseTreeListener listener) {
5796 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterMethodDeclarator(this);
5797 		}
5798 		@Override
5799 		public void exitRule(ParseTreeListener listener) {
5800 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitMethodDeclarator(this);
5801 		}
5802 	}
5803 
5804 	public final MethodDeclaratorContext methodDeclarator() throws RecognitionException {
5805 		MethodDeclaratorContext _localctx = new MethodDeclaratorContext(_ctx, getState());
5806 		enterRule(_localctx, 168, RULE_methodDeclarator);
5807 		int _la;
5808 		try {
5809 			enterOuterAlt(_localctx, 1);
5810 			{
5811 			setState(1156);
5812 			identifier();
5813 			setState(1157);
5814 			match(LPAREN);
5815 			setState(1159);
5816 			_errHandler.sync(this);
5817 			_la = _input.LA(1);
5818 			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << SHORT))) != 0) || _la==AT || _la==Identifier) {
5819 				{
5820 				setState(1158);
5821 				formalParameterList();
5822 				}
5823 			}
5824 
5825 			setState(1161);
5826 			match(RPAREN);
5827 			setState(1163);
5828 			_errHandler.sync(this);
5829 			_la = _input.LA(1);
5830 			if (_la==LBRACK || _la==AT) {
5831 				{
5832 				setState(1162);
5833 				dims();
5834 				}
5835 			}
5836 
5837 			}
5838 		}
5839 		catch (RecognitionException re) {
5840 			_localctx.exception = re;
5841 			_errHandler.reportError(this, re);
5842 			_errHandler.recover(this, re);
5843 		}
5844 		finally {
5845 			exitRule();
5846 		}
5847 		return _localctx;
5848 	}
5849 
5850 	public static class FormalParameterListContext extends ParserRuleContext {
5851 		public FormalParametersContext formalParameters() {
5852 			return getRuleContext(FormalParametersContext.class,0);
5853 		}
5854 		public LastFormalParameterContext lastFormalParameter() {
5855 			return getRuleContext(LastFormalParameterContext.class,0);
5856 		}
5857 		public ReceiverParameterContext receiverParameter() {
5858 			return getRuleContext(ReceiverParameterContext.class,0);
5859 		}
5860 		public FormalParameterListContext(ParserRuleContext parent, int invokingState) {
5861 			super(parent, invokingState);
5862 		}
5863 		@Override public int getRuleIndex() { return RULE_formalParameterList; }
5864 		@Override
5865 		public void enterRule(ParseTreeListener listener) {
5866 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterFormalParameterList(this);
5867 		}
5868 		@Override
5869 		public void exitRule(ParseTreeListener listener) {
5870 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitFormalParameterList(this);
5871 		}
5872 	}
5873 
5874 	public final FormalParameterListContext formalParameterList() throws RecognitionException {
5875 		FormalParameterListContext _localctx = new FormalParameterListContext(_ctx, getState());
5876 		enterRule(_localctx, 170, RULE_formalParameterList);
5877 		try {
5878 			setState(1171);
5879 			_errHandler.sync(this);
5880 			switch ( getInterpreter().adaptivePredict(_input,95,_ctx) ) {
5881 			case 1:
5882 				enterOuterAlt(_localctx, 1);
5883 				{
5884 				setState(1165);
5885 				formalParameters();
5886 				setState(1166);
5887 				match(COMMA);
5888 				setState(1167);
5889 				lastFormalParameter();
5890 				}
5891 				break;
5892 			case 2:
5893 				enterOuterAlt(_localctx, 2);
5894 				{
5895 				setState(1169);
5896 				lastFormalParameter();
5897 				}
5898 				break;
5899 			case 3:
5900 				enterOuterAlt(_localctx, 3);
5901 				{
5902 				setState(1170);
5903 				receiverParameter();
5904 				}
5905 				break;
5906 			}
5907 		}
5908 		catch (RecognitionException re) {
5909 			_localctx.exception = re;
5910 			_errHandler.reportError(this, re);
5911 			_errHandler.recover(this, re);
5912 		}
5913 		finally {
5914 			exitRule();
5915 		}
5916 		return _localctx;
5917 	}
5918 
5919 	public static class FormalParametersContext extends ParserRuleContext {
5920 		public List<FormalParameterContext> formalParameter() {
5921 			return getRuleContexts(FormalParameterContext.class);
5922 		}
5923 		public FormalParameterContext formalParameter(int i) {
5924 			return getRuleContext(FormalParameterContext.class,i);
5925 		}
5926 		public ReceiverParameterContext receiverParameter() {
5927 			return getRuleContext(ReceiverParameterContext.class,0);
5928 		}
5929 		public FormalParametersContext(ParserRuleContext parent, int invokingState) {
5930 			super(parent, invokingState);
5931 		}
5932 		@Override public int getRuleIndex() { return RULE_formalParameters; }
5933 		@Override
5934 		public void enterRule(ParseTreeListener listener) {
5935 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterFormalParameters(this);
5936 		}
5937 		@Override
5938 		public void exitRule(ParseTreeListener listener) {
5939 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitFormalParameters(this);
5940 		}
5941 	}
5942 
5943 	public final FormalParametersContext formalParameters() throws RecognitionException {
5944 		FormalParametersContext _localctx = new FormalParametersContext(_ctx, getState());
5945 		enterRule(_localctx, 172, RULE_formalParameters);
5946 		try {
5947 			int _alt;
5948 			setState(1189);
5949 			_errHandler.sync(this);
5950 			switch ( getInterpreter().adaptivePredict(_input,98,_ctx) ) {
5951 			case 1:
5952 				enterOuterAlt(_localctx, 1);
5953 				{
5954 				setState(1173);
5955 				formalParameter();
5956 				setState(1178);
5957 				_errHandler.sync(this);
5958 				_alt = getInterpreter().adaptivePredict(_input,96,_ctx);
5959 				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
5960 					if ( _alt==1 ) {
5961 						{
5962 						{
5963 						setState(1174);
5964 						match(COMMA);
5965 						setState(1175);
5966 						formalParameter();
5967 						}
5968 						} 
5969 					}
5970 					setState(1180);
5971 					_errHandler.sync(this);
5972 					_alt = getInterpreter().adaptivePredict(_input,96,_ctx);
5973 				}
5974 				}
5975 				break;
5976 			case 2:
5977 				enterOuterAlt(_localctx, 2);
5978 				{
5979 				setState(1181);
5980 				receiverParameter();
5981 				setState(1186);
5982 				_errHandler.sync(this);
5983 				_alt = getInterpreter().adaptivePredict(_input,97,_ctx);
5984 				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
5985 					if ( _alt==1 ) {
5986 						{
5987 						{
5988 						setState(1182);
5989 						match(COMMA);
5990 						setState(1183);
5991 						formalParameter();
5992 						}
5993 						} 
5994 					}
5995 					setState(1188);
5996 					_errHandler.sync(this);
5997 					_alt = getInterpreter().adaptivePredict(_input,97,_ctx);
5998 				}
5999 				}
6000 				break;
6001 			}
6002 		}
6003 		catch (RecognitionException re) {
6004 			_localctx.exception = re;
6005 			_errHandler.reportError(this, re);
6006 			_errHandler.recover(this, re);
6007 		}
6008 		finally {
6009 			exitRule();
6010 		}
6011 		return _localctx;
6012 	}
6013 
6014 	public static class FormalParameterContext extends ParserRuleContext {
6015 		public UnannTypeContext unannType() {
6016 			return getRuleContext(UnannTypeContext.class,0);
6017 		}
6018 		public VariableDeclaratorIdContext variableDeclaratorId() {
6019 			return getRuleContext(VariableDeclaratorIdContext.class,0);
6020 		}
6021 		public List<VariableModifierContext> variableModifier() {
6022 			return getRuleContexts(VariableModifierContext.class);
6023 		}
6024 		public VariableModifierContext variableModifier(int i) {
6025 			return getRuleContext(VariableModifierContext.class,i);
6026 		}
6027 		public FormalParameterContext(ParserRuleContext parent, int invokingState) {
6028 			super(parent, invokingState);
6029 		}
6030 		@Override public int getRuleIndex() { return RULE_formalParameter; }
6031 		@Override
6032 		public void enterRule(ParseTreeListener listener) {
6033 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterFormalParameter(this);
6034 		}
6035 		@Override
6036 		public void exitRule(ParseTreeListener listener) {
6037 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitFormalParameter(this);
6038 		}
6039 	}
6040 
6041 	public final FormalParameterContext formalParameter() throws RecognitionException {
6042 		FormalParameterContext _localctx = new FormalParameterContext(_ctx, getState());
6043 		enterRule(_localctx, 174, RULE_formalParameter);
6044 		int _la;
6045 		try {
6046 			enterOuterAlt(_localctx, 1);
6047 			{
6048 			setState(1194);
6049 			_errHandler.sync(this);
6050 			_la = _input.LA(1);
6051 			while (_la==FINAL || _la==AT) {
6052 				{
6053 				{
6054 				setState(1191);
6055 				variableModifier();
6056 				}
6057 				}
6058 				setState(1196);
6059 				_errHandler.sync(this);
6060 				_la = _input.LA(1);
6061 			}
6062 			setState(1197);
6063 			unannType();
6064 			setState(1198);
6065 			variableDeclaratorId();
6066 			}
6067 		}
6068 		catch (RecognitionException re) {
6069 			_localctx.exception = re;
6070 			_errHandler.reportError(this, re);
6071 			_errHandler.recover(this, re);
6072 		}
6073 		finally {
6074 			exitRule();
6075 		}
6076 		return _localctx;
6077 	}
6078 
6079 	public static class VariableModifierContext extends ParserRuleContext {
6080 		public AnnotationContext annotation() {
6081 			return getRuleContext(AnnotationContext.class,0);
6082 		}
6083 		public VariableModifierContext(ParserRuleContext parent, int invokingState) {
6084 			super(parent, invokingState);
6085 		}
6086 		@Override public int getRuleIndex() { return RULE_variableModifier; }
6087 		@Override
6088 		public void enterRule(ParseTreeListener listener) {
6089 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterVariableModifier(this);
6090 		}
6091 		@Override
6092 		public void exitRule(ParseTreeListener listener) {
6093 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitVariableModifier(this);
6094 		}
6095 	}
6096 
6097 	public final VariableModifierContext variableModifier() throws RecognitionException {
6098 		VariableModifierContext _localctx = new VariableModifierContext(_ctx, getState());
6099 		enterRule(_localctx, 176, RULE_variableModifier);
6100 		try {
6101 			setState(1202);
6102 			_errHandler.sync(this);
6103 			switch (_input.LA(1)) {
6104 			case AT:
6105 				enterOuterAlt(_localctx, 1);
6106 				{
6107 				setState(1200);
6108 				annotation();
6109 				}
6110 				break;
6111 			case FINAL:
6112 				enterOuterAlt(_localctx, 2);
6113 				{
6114 				setState(1201);
6115 				match(FINAL);
6116 				}
6117 				break;
6118 			default:
6119 				throw new NoViableAltException(this);
6120 			}
6121 		}
6122 		catch (RecognitionException re) {
6123 			_localctx.exception = re;
6124 			_errHandler.reportError(this, re);
6125 			_errHandler.recover(this, re);
6126 		}
6127 		finally {
6128 			exitRule();
6129 		}
6130 		return _localctx;
6131 	}
6132 
6133 	public static class LastFormalParameterContext extends ParserRuleContext {
6134 		public UnannTypeContext unannType() {
6135 			return getRuleContext(UnannTypeContext.class,0);
6136 		}
6137 		public VariableDeclaratorIdContext variableDeclaratorId() {
6138 			return getRuleContext(VariableDeclaratorIdContext.class,0);
6139 		}
6140 		public List<VariableModifierContext> variableModifier() {
6141 			return getRuleContexts(VariableModifierContext.class);
6142 		}
6143 		public VariableModifierContext variableModifier(int i) {
6144 			return getRuleContext(VariableModifierContext.class,i);
6145 		}
6146 		public List<AnnotationContext> annotation() {
6147 			return getRuleContexts(AnnotationContext.class);
6148 		}
6149 		public AnnotationContext annotation(int i) {
6150 			return getRuleContext(AnnotationContext.class,i);
6151 		}
6152 		public FormalParameterContext formalParameter() {
6153 			return getRuleContext(FormalParameterContext.class,0);
6154 		}
6155 		public LastFormalParameterContext(ParserRuleContext parent, int invokingState) {
6156 			super(parent, invokingState);
6157 		}
6158 		@Override public int getRuleIndex() { return RULE_lastFormalParameter; }
6159 		@Override
6160 		public void enterRule(ParseTreeListener listener) {
6161 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterLastFormalParameter(this);
6162 		}
6163 		@Override
6164 		public void exitRule(ParseTreeListener listener) {
6165 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitLastFormalParameter(this);
6166 		}
6167 	}
6168 
6169 	public final LastFormalParameterContext lastFormalParameter() throws RecognitionException {
6170 		LastFormalParameterContext _localctx = new LastFormalParameterContext(_ctx, getState());
6171 		enterRule(_localctx, 178, RULE_lastFormalParameter);
6172 		int _la;
6173 		try {
6174 			setState(1221);
6175 			_errHandler.sync(this);
6176 			switch ( getInterpreter().adaptivePredict(_input,103,_ctx) ) {
6177 			case 1:
6178 				enterOuterAlt(_localctx, 1);
6179 				{
6180 				setState(1207);
6181 				_errHandler.sync(this);
6182 				_la = _input.LA(1);
6183 				while (_la==FINAL || _la==AT) {
6184 					{
6185 					{
6186 					setState(1204);
6187 					variableModifier();
6188 					}
6189 					}
6190 					setState(1209);
6191 					_errHandler.sync(this);
6192 					_la = _input.LA(1);
6193 				}
6194 				setState(1210);
6195 				unannType();
6196 				setState(1214);
6197 				_errHandler.sync(this);
6198 				_la = _input.LA(1);
6199 				while (_la==AT) {
6200 					{
6201 					{
6202 					setState(1211);
6203 					annotation();
6204 					}
6205 					}
6206 					setState(1216);
6207 					_errHandler.sync(this);
6208 					_la = _input.LA(1);
6209 				}
6210 				setState(1217);
6211 				match(ELLIPSIS);
6212 				setState(1218);
6213 				variableDeclaratorId();
6214 				}
6215 				break;
6216 			case 2:
6217 				enterOuterAlt(_localctx, 2);
6218 				{
6219 				setState(1220);
6220 				formalParameter();
6221 				}
6222 				break;
6223 			}
6224 		}
6225 		catch (RecognitionException re) {
6226 			_localctx.exception = re;
6227 			_errHandler.reportError(this, re);
6228 			_errHandler.recover(this, re);
6229 		}
6230 		finally {
6231 			exitRule();
6232 		}
6233 		return _localctx;
6234 	}
6235 
6236 	public static class ReceiverParameterContext extends ParserRuleContext {
6237 		public UnannTypeContext unannType() {
6238 			return getRuleContext(UnannTypeContext.class,0);
6239 		}
6240 		public List<AnnotationContext> annotation() {
6241 			return getRuleContexts(AnnotationContext.class);
6242 		}
6243 		public AnnotationContext annotation(int i) {
6244 			return getRuleContext(AnnotationContext.class,i);
6245 		}
6246 		public IdentifierContext identifier() {
6247 			return getRuleContext(IdentifierContext.class,0);
6248 		}
6249 		public ReceiverParameterContext(ParserRuleContext parent, int invokingState) {
6250 			super(parent, invokingState);
6251 		}
6252 		@Override public int getRuleIndex() { return RULE_receiverParameter; }
6253 		@Override
6254 		public void enterRule(ParseTreeListener listener) {
6255 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterReceiverParameter(this);
6256 		}
6257 		@Override
6258 		public void exitRule(ParseTreeListener listener) {
6259 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitReceiverParameter(this);
6260 		}
6261 	}
6262 
6263 	public final ReceiverParameterContext receiverParameter() throws RecognitionException {
6264 		ReceiverParameterContext _localctx = new ReceiverParameterContext(_ctx, getState());
6265 		enterRule(_localctx, 180, RULE_receiverParameter);
6266 		int _la;
6267 		try {
6268 			enterOuterAlt(_localctx, 1);
6269 			{
6270 			setState(1226);
6271 			_errHandler.sync(this);
6272 			_la = _input.LA(1);
6273 			while (_la==AT) {
6274 				{
6275 				{
6276 				setState(1223);
6277 				annotation();
6278 				}
6279 				}
6280 				setState(1228);
6281 				_errHandler.sync(this);
6282 				_la = _input.LA(1);
6283 			}
6284 			setState(1229);
6285 			unannType();
6286 			setState(1233);
6287 			_errHandler.sync(this);
6288 			_la = _input.LA(1);
6289 			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8))) != 0) || _la==Identifier) {
6290 				{
6291 				setState(1230);
6292 				identifier();
6293 				setState(1231);
6294 				match(DOT);
6295 				}
6296 			}
6297 
6298 			setState(1235);
6299 			match(THIS);
6300 			}
6301 		}
6302 		catch (RecognitionException re) {
6303 			_localctx.exception = re;
6304 			_errHandler.reportError(this, re);
6305 			_errHandler.recover(this, re);
6306 		}
6307 		finally {
6308 			exitRule();
6309 		}
6310 		return _localctx;
6311 	}
6312 
6313 	public static class Throws_Context extends ParserRuleContext {
6314 		public ExceptionTypeListContext exceptionTypeList() {
6315 			return getRuleContext(ExceptionTypeListContext.class,0);
6316 		}
6317 		public Throws_Context(ParserRuleContext parent, int invokingState) {
6318 			super(parent, invokingState);
6319 		}
6320 		@Override public int getRuleIndex() { return RULE_throws_; }
6321 		@Override
6322 		public void enterRule(ParseTreeListener listener) {
6323 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterThrows_(this);
6324 		}
6325 		@Override
6326 		public void exitRule(ParseTreeListener listener) {
6327 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitThrows_(this);
6328 		}
6329 	}
6330 
6331 	public final Throws_Context throws_() throws RecognitionException {
6332 		Throws_Context _localctx = new Throws_Context(_ctx, getState());
6333 		enterRule(_localctx, 182, RULE_throws_);
6334 		try {
6335 			enterOuterAlt(_localctx, 1);
6336 			{
6337 			setState(1237);
6338 			match(THROWS);
6339 			setState(1238);
6340 			exceptionTypeList();
6341 			}
6342 		}
6343 		catch (RecognitionException re) {
6344 			_localctx.exception = re;
6345 			_errHandler.reportError(this, re);
6346 			_errHandler.recover(this, re);
6347 		}
6348 		finally {
6349 			exitRule();
6350 		}
6351 		return _localctx;
6352 	}
6353 
6354 	public static class ExceptionTypeListContext extends ParserRuleContext {
6355 		public List<ExceptionTypeContext> exceptionType() {
6356 			return getRuleContexts(ExceptionTypeContext.class);
6357 		}
6358 		public ExceptionTypeContext exceptionType(int i) {
6359 			return getRuleContext(ExceptionTypeContext.class,i);
6360 		}
6361 		public ExceptionTypeListContext(ParserRuleContext parent, int invokingState) {
6362 			super(parent, invokingState);
6363 		}
6364 		@Override public int getRuleIndex() { return RULE_exceptionTypeList; }
6365 		@Override
6366 		public void enterRule(ParseTreeListener listener) {
6367 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterExceptionTypeList(this);
6368 		}
6369 		@Override
6370 		public void exitRule(ParseTreeListener listener) {
6371 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitExceptionTypeList(this);
6372 		}
6373 	}
6374 
6375 	public final ExceptionTypeListContext exceptionTypeList() throws RecognitionException {
6376 		ExceptionTypeListContext _localctx = new ExceptionTypeListContext(_ctx, getState());
6377 		enterRule(_localctx, 184, RULE_exceptionTypeList);
6378 		int _la;
6379 		try {
6380 			enterOuterAlt(_localctx, 1);
6381 			{
6382 			setState(1240);
6383 			exceptionType();
6384 			setState(1245);
6385 			_errHandler.sync(this);
6386 			_la = _input.LA(1);
6387 			while (_la==COMMA) {
6388 				{
6389 				{
6390 				setState(1241);
6391 				match(COMMA);
6392 				setState(1242);
6393 				exceptionType();
6394 				}
6395 				}
6396 				setState(1247);
6397 				_errHandler.sync(this);
6398 				_la = _input.LA(1);
6399 			}
6400 			}
6401 		}
6402 		catch (RecognitionException re) {
6403 			_localctx.exception = re;
6404 			_errHandler.reportError(this, re);
6405 			_errHandler.recover(this, re);
6406 		}
6407 		finally {
6408 			exitRule();
6409 		}
6410 		return _localctx;
6411 	}
6412 
6413 	public static class ExceptionTypeContext extends ParserRuleContext {
6414 		public ClassTypeContext classType() {
6415 			return getRuleContext(ClassTypeContext.class,0);
6416 		}
6417 		public TypeVariableContext typeVariable() {
6418 			return getRuleContext(TypeVariableContext.class,0);
6419 		}
6420 		public ExceptionTypeContext(ParserRuleContext parent, int invokingState) {
6421 			super(parent, invokingState);
6422 		}
6423 		@Override public int getRuleIndex() { return RULE_exceptionType; }
6424 		@Override
6425 		public void enterRule(ParseTreeListener listener) {
6426 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterExceptionType(this);
6427 		}
6428 		@Override
6429 		public void exitRule(ParseTreeListener listener) {
6430 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitExceptionType(this);
6431 		}
6432 	}
6433 
6434 	public final ExceptionTypeContext exceptionType() throws RecognitionException {
6435 		ExceptionTypeContext _localctx = new ExceptionTypeContext(_ctx, getState());
6436 		enterRule(_localctx, 186, RULE_exceptionType);
6437 		try {
6438 			setState(1250);
6439 			_errHandler.sync(this);
6440 			switch ( getInterpreter().adaptivePredict(_input,107,_ctx) ) {
6441 			case 1:
6442 				enterOuterAlt(_localctx, 1);
6443 				{
6444 				setState(1248);
6445 				classType();
6446 				}
6447 				break;
6448 			case 2:
6449 				enterOuterAlt(_localctx, 2);
6450 				{
6451 				setState(1249);
6452 				typeVariable();
6453 				}
6454 				break;
6455 			}
6456 		}
6457 		catch (RecognitionException re) {
6458 			_localctx.exception = re;
6459 			_errHandler.reportError(this, re);
6460 			_errHandler.recover(this, re);
6461 		}
6462 		finally {
6463 			exitRule();
6464 		}
6465 		return _localctx;
6466 	}
6467 
6468 	public static class MethodBodyContext extends ParserRuleContext {
6469 		public BlockContext block() {
6470 			return getRuleContext(BlockContext.class,0);
6471 		}
6472 		public MethodBodyContext(ParserRuleContext parent, int invokingState) {
6473 			super(parent, invokingState);
6474 		}
6475 		@Override public int getRuleIndex() { return RULE_methodBody; }
6476 		@Override
6477 		public void enterRule(ParseTreeListener listener) {
6478 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterMethodBody(this);
6479 		}
6480 		@Override
6481 		public void exitRule(ParseTreeListener listener) {
6482 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitMethodBody(this);
6483 		}
6484 	}
6485 
6486 	public final MethodBodyContext methodBody() throws RecognitionException {
6487 		MethodBodyContext _localctx = new MethodBodyContext(_ctx, getState());
6488 		enterRule(_localctx, 188, RULE_methodBody);
6489 		try {
6490 			setState(1254);
6491 			_errHandler.sync(this);
6492 			switch (_input.LA(1)) {
6493 			case LBRACE:
6494 				enterOuterAlt(_localctx, 1);
6495 				{
6496 				setState(1252);
6497 				block();
6498 				}
6499 				break;
6500 			case SEMI:
6501 				enterOuterAlt(_localctx, 2);
6502 				{
6503 				setState(1253);
6504 				match(SEMI);
6505 				}
6506 				break;
6507 			default:
6508 				throw new NoViableAltException(this);
6509 			}
6510 		}
6511 		catch (RecognitionException re) {
6512 			_localctx.exception = re;
6513 			_errHandler.reportError(this, re);
6514 			_errHandler.recover(this, re);
6515 		}
6516 		finally {
6517 			exitRule();
6518 		}
6519 		return _localctx;
6520 	}
6521 
6522 	public static class InstanceInitializerContext extends ParserRuleContext {
6523 		public BlockContext block() {
6524 			return getRuleContext(BlockContext.class,0);
6525 		}
6526 		public InstanceInitializerContext(ParserRuleContext parent, int invokingState) {
6527 			super(parent, invokingState);
6528 		}
6529 		@Override public int getRuleIndex() { return RULE_instanceInitializer; }
6530 		@Override
6531 		public void enterRule(ParseTreeListener listener) {
6532 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInstanceInitializer(this);
6533 		}
6534 		@Override
6535 		public void exitRule(ParseTreeListener listener) {
6536 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInstanceInitializer(this);
6537 		}
6538 	}
6539 
6540 	public final InstanceInitializerContext instanceInitializer() throws RecognitionException {
6541 		InstanceInitializerContext _localctx = new InstanceInitializerContext(_ctx, getState());
6542 		enterRule(_localctx, 190, RULE_instanceInitializer);
6543 		try {
6544 			enterOuterAlt(_localctx, 1);
6545 			{
6546 			setState(1256);
6547 			block();
6548 			}
6549 		}
6550 		catch (RecognitionException re) {
6551 			_localctx.exception = re;
6552 			_errHandler.reportError(this, re);
6553 			_errHandler.recover(this, re);
6554 		}
6555 		finally {
6556 			exitRule();
6557 		}
6558 		return _localctx;
6559 	}
6560 
6561 	public static class StaticInitializerContext extends ParserRuleContext {
6562 		public BlockContext block() {
6563 			return getRuleContext(BlockContext.class,0);
6564 		}
6565 		public StaticInitializerContext(ParserRuleContext parent, int invokingState) {
6566 			super(parent, invokingState);
6567 		}
6568 		@Override public int getRuleIndex() { return RULE_staticInitializer; }
6569 		@Override
6570 		public void enterRule(ParseTreeListener listener) {
6571 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterStaticInitializer(this);
6572 		}
6573 		@Override
6574 		public void exitRule(ParseTreeListener listener) {
6575 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitStaticInitializer(this);
6576 		}
6577 	}
6578 
6579 	public final StaticInitializerContext staticInitializer() throws RecognitionException {
6580 		StaticInitializerContext _localctx = new StaticInitializerContext(_ctx, getState());
6581 		enterRule(_localctx, 192, RULE_staticInitializer);
6582 		try {
6583 			enterOuterAlt(_localctx, 1);
6584 			{
6585 			setState(1258);
6586 			match(STATIC);
6587 			setState(1259);
6588 			block();
6589 			}
6590 		}
6591 		catch (RecognitionException re) {
6592 			_localctx.exception = re;
6593 			_errHandler.reportError(this, re);
6594 			_errHandler.recover(this, re);
6595 		}
6596 		finally {
6597 			exitRule();
6598 		}
6599 		return _localctx;
6600 	}
6601 
6602 	public static class ConstructorDeclarationContext extends ParserRuleContext {
6603 		public ConstructorDeclaratorContext constructorDeclarator() {
6604 			return getRuleContext(ConstructorDeclaratorContext.class,0);
6605 		}
6606 		public ConstructorBodyContext constructorBody() {
6607 			return getRuleContext(ConstructorBodyContext.class,0);
6608 		}
6609 		public List<ConstructorModifierContext> constructorModifier() {
6610 			return getRuleContexts(ConstructorModifierContext.class);
6611 		}
6612 		public ConstructorModifierContext constructorModifier(int i) {
6613 			return getRuleContext(ConstructorModifierContext.class,i);
6614 		}
6615 		public Throws_Context throws_() {
6616 			return getRuleContext(Throws_Context.class,0);
6617 		}
6618 		public ConstructorDeclarationContext(ParserRuleContext parent, int invokingState) {
6619 			super(parent, invokingState);
6620 		}
6621 		@Override public int getRuleIndex() { return RULE_constructorDeclaration; }
6622 		@Override
6623 		public void enterRule(ParseTreeListener listener) {
6624 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterConstructorDeclaration(this);
6625 		}
6626 		@Override
6627 		public void exitRule(ParseTreeListener listener) {
6628 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitConstructorDeclaration(this);
6629 		}
6630 	}
6631 
6632 	public final ConstructorDeclarationContext constructorDeclaration() throws RecognitionException {
6633 		ConstructorDeclarationContext _localctx = new ConstructorDeclarationContext(_ctx, getState());
6634 		enterRule(_localctx, 194, RULE_constructorDeclaration);
6635 		int _la;
6636 		try {
6637 			enterOuterAlt(_localctx, 1);
6638 			{
6639 			setState(1264);
6640 			_errHandler.sync(this);
6641 			_la = _input.LA(1);
6642 			while (((((_la - 43)) & ~0x3f) == 0 && ((1L << (_la - 43)) & ((1L << (PRIVATE - 43)) | (1L << (PROTECTED - 43)) | (1L << (PUBLIC - 43)) | (1L << (AT - 43)))) != 0)) {
6643 				{
6644 				{
6645 				setState(1261);
6646 				constructorModifier();
6647 				}
6648 				}
6649 				setState(1266);
6650 				_errHandler.sync(this);
6651 				_la = _input.LA(1);
6652 			}
6653 			setState(1267);
6654 			constructorDeclarator();
6655 			setState(1269);
6656 			_errHandler.sync(this);
6657 			_la = _input.LA(1);
6658 			if (_la==THROWS) {
6659 				{
6660 				setState(1268);
6661 				throws_();
6662 				}
6663 			}
6664 
6665 			setState(1271);
6666 			constructorBody();
6667 			}
6668 		}
6669 		catch (RecognitionException re) {
6670 			_localctx.exception = re;
6671 			_errHandler.reportError(this, re);
6672 			_errHandler.recover(this, re);
6673 		}
6674 		finally {
6675 			exitRule();
6676 		}
6677 		return _localctx;
6678 	}
6679 
6680 	public static class ConstructorModifierContext extends ParserRuleContext {
6681 		public AnnotationContext annotation() {
6682 			return getRuleContext(AnnotationContext.class,0);
6683 		}
6684 		public ConstructorModifierContext(ParserRuleContext parent, int invokingState) {
6685 			super(parent, invokingState);
6686 		}
6687 		@Override public int getRuleIndex() { return RULE_constructorModifier; }
6688 		@Override
6689 		public void enterRule(ParseTreeListener listener) {
6690 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterConstructorModifier(this);
6691 		}
6692 		@Override
6693 		public void exitRule(ParseTreeListener listener) {
6694 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitConstructorModifier(this);
6695 		}
6696 	}
6697 
6698 	public final ConstructorModifierContext constructorModifier() throws RecognitionException {
6699 		ConstructorModifierContext _localctx = new ConstructorModifierContext(_ctx, getState());
6700 		enterRule(_localctx, 196, RULE_constructorModifier);
6701 		try {
6702 			setState(1277);
6703 			_errHandler.sync(this);
6704 			switch (_input.LA(1)) {
6705 			case AT:
6706 				enterOuterAlt(_localctx, 1);
6707 				{
6708 				setState(1273);
6709 				annotation();
6710 				}
6711 				break;
6712 			case PUBLIC:
6713 				enterOuterAlt(_localctx, 2);
6714 				{
6715 				setState(1274);
6716 				match(PUBLIC);
6717 				}
6718 				break;
6719 			case PROTECTED:
6720 				enterOuterAlt(_localctx, 3);
6721 				{
6722 				setState(1275);
6723 				match(PROTECTED);
6724 				}
6725 				break;
6726 			case PRIVATE:
6727 				enterOuterAlt(_localctx, 4);
6728 				{
6729 				setState(1276);
6730 				match(PRIVATE);
6731 				}
6732 				break;
6733 			default:
6734 				throw new NoViableAltException(this);
6735 			}
6736 		}
6737 		catch (RecognitionException re) {
6738 			_localctx.exception = re;
6739 			_errHandler.reportError(this, re);
6740 			_errHandler.recover(this, re);
6741 		}
6742 		finally {
6743 			exitRule();
6744 		}
6745 		return _localctx;
6746 	}
6747 
6748 	public static class ConstructorDeclaratorContext extends ParserRuleContext {
6749 		public SimpleTypeNameContext simpleTypeName() {
6750 			return getRuleContext(SimpleTypeNameContext.class,0);
6751 		}
6752 		public TypeParametersContext typeParameters() {
6753 			return getRuleContext(TypeParametersContext.class,0);
6754 		}
6755 		public FormalParameterListContext formalParameterList() {
6756 			return getRuleContext(FormalParameterListContext.class,0);
6757 		}
6758 		public ConstructorDeclaratorContext(ParserRuleContext parent, int invokingState) {
6759 			super(parent, invokingState);
6760 		}
6761 		@Override public int getRuleIndex() { return RULE_constructorDeclarator; }
6762 		@Override
6763 		public void enterRule(ParseTreeListener listener) {
6764 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterConstructorDeclarator(this);
6765 		}
6766 		@Override
6767 		public void exitRule(ParseTreeListener listener) {
6768 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitConstructorDeclarator(this);
6769 		}
6770 	}
6771 
6772 	public final ConstructorDeclaratorContext constructorDeclarator() throws RecognitionException {
6773 		ConstructorDeclaratorContext _localctx = new ConstructorDeclaratorContext(_ctx, getState());
6774 		enterRule(_localctx, 198, RULE_constructorDeclarator);
6775 		int _la;
6776 		try {
6777 			enterOuterAlt(_localctx, 1);
6778 			{
6779 			setState(1280);
6780 			_errHandler.sync(this);
6781 			_la = _input.LA(1);
6782 			if (_la==LT) {
6783 				{
6784 				setState(1279);
6785 				typeParameters();
6786 				}
6787 			}
6788 
6789 			setState(1282);
6790 			simpleTypeName();
6791 			setState(1283);
6792 			match(LPAREN);
6793 			setState(1285);
6794 			_errHandler.sync(this);
6795 			_la = _input.LA(1);
6796 			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << SHORT))) != 0) || _la==AT || _la==Identifier) {
6797 				{
6798 				setState(1284);
6799 				formalParameterList();
6800 				}
6801 			}
6802 
6803 			setState(1287);
6804 			match(RPAREN);
6805 			}
6806 		}
6807 		catch (RecognitionException re) {
6808 			_localctx.exception = re;
6809 			_errHandler.reportError(this, re);
6810 			_errHandler.recover(this, re);
6811 		}
6812 		finally {
6813 			exitRule();
6814 		}
6815 		return _localctx;
6816 	}
6817 
6818 	public static class SimpleTypeNameContext extends ParserRuleContext {
6819 		public IdentifierContext identifier() {
6820 			return getRuleContext(IdentifierContext.class,0);
6821 		}
6822 		public SimpleTypeNameContext(ParserRuleContext parent, int invokingState) {
6823 			super(parent, invokingState);
6824 		}
6825 		@Override public int getRuleIndex() { return RULE_simpleTypeName; }
6826 		@Override
6827 		public void enterRule(ParseTreeListener listener) {
6828 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterSimpleTypeName(this);
6829 		}
6830 		@Override
6831 		public void exitRule(ParseTreeListener listener) {
6832 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitSimpleTypeName(this);
6833 		}
6834 	}
6835 
6836 	public final SimpleTypeNameContext simpleTypeName() throws RecognitionException {
6837 		SimpleTypeNameContext _localctx = new SimpleTypeNameContext(_ctx, getState());
6838 		enterRule(_localctx, 200, RULE_simpleTypeName);
6839 		try {
6840 			enterOuterAlt(_localctx, 1);
6841 			{
6842 			setState(1289);
6843 			identifier();
6844 			}
6845 		}
6846 		catch (RecognitionException re) {
6847 			_localctx.exception = re;
6848 			_errHandler.reportError(this, re);
6849 			_errHandler.recover(this, re);
6850 		}
6851 		finally {
6852 			exitRule();
6853 		}
6854 		return _localctx;
6855 	}
6856 
6857 	public static class ConstructorBodyContext extends ParserRuleContext {
6858 		public ExplicitConstructorInvocationContext explicitConstructorInvocation() {
6859 			return getRuleContext(ExplicitConstructorInvocationContext.class,0);
6860 		}
6861 		public BlockStatementsContext blockStatements() {
6862 			return getRuleContext(BlockStatementsContext.class,0);
6863 		}
6864 		public ConstructorBodyContext(ParserRuleContext parent, int invokingState) {
6865 			super(parent, invokingState);
6866 		}
6867 		@Override public int getRuleIndex() { return RULE_constructorBody; }
6868 		@Override
6869 		public void enterRule(ParseTreeListener listener) {
6870 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterConstructorBody(this);
6871 		}
6872 		@Override
6873 		public void exitRule(ParseTreeListener listener) {
6874 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitConstructorBody(this);
6875 		}
6876 	}
6877 
6878 	public final ConstructorBodyContext constructorBody() throws RecognitionException {
6879 		ConstructorBodyContext _localctx = new ConstructorBodyContext(_ctx, getState());
6880 		enterRule(_localctx, 202, RULE_constructorBody);
6881 		int _la;
6882 		try {
6883 			enterOuterAlt(_localctx, 1);
6884 			{
6885 			setState(1291);
6886 			match(LBRACE);
6887 			setState(1293);
6888 			_errHandler.sync(this);
6889 			switch ( getInterpreter().adaptivePredict(_input,114,_ctx) ) {
6890 			case 1:
6891 				{
6892 				setState(1292);
6893 				explicitConstructorInvocation();
6894 				}
6895 				break;
6896 			}
6897 			setState(1296);
6898 			_errHandler.sync(this);
6899 			_la = _input.LA(1);
6900 			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << ABSTRACT) | (1L << ASSERT) | (1L << BOOLEAN) | (1L << BREAK) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << CONTINUE) | (1L << DO) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << FOR) | (1L << IF) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << RETURN) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SUPER) | (1L << SWITCH) | (1L << SYNCHRONIZED) | (1L << THIS) | (1L << THROW) | (1L << TRY) | (1L << VOID) | (1L << WHILE) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (LBRACE - 64)) | (1L << (SEMI - 64)) | (1L << (AT - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (Identifier - 64)))) != 0)) {
6901 				{
6902 				setState(1295);
6903 				blockStatements();
6904 				}
6905 			}
6906 
6907 			setState(1298);
6908 			match(RBRACE);
6909 			}
6910 		}
6911 		catch (RecognitionException re) {
6912 			_localctx.exception = re;
6913 			_errHandler.reportError(this, re);
6914 			_errHandler.recover(this, re);
6915 		}
6916 		finally {
6917 			exitRule();
6918 		}
6919 		return _localctx;
6920 	}
6921 
6922 	public static class ExplicitConstructorInvocationContext extends ParserRuleContext {
6923 		public TypeArgumentsContext typeArguments() {
6924 			return getRuleContext(TypeArgumentsContext.class,0);
6925 		}
6926 		public ArgumentListContext argumentList() {
6927 			return getRuleContext(ArgumentListContext.class,0);
6928 		}
6929 		public ExpressionNameContext expressionName() {
6930 			return getRuleContext(ExpressionNameContext.class,0);
6931 		}
6932 		public PrimaryContext primary() {
6933 			return getRuleContext(PrimaryContext.class,0);
6934 		}
6935 		public ExplicitConstructorInvocationContext(ParserRuleContext parent, int invokingState) {
6936 			super(parent, invokingState);
6937 		}
6938 		@Override public int getRuleIndex() { return RULE_explicitConstructorInvocation; }
6939 		@Override
6940 		public void enterRule(ParseTreeListener listener) {
6941 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterExplicitConstructorInvocation(this);
6942 		}
6943 		@Override
6944 		public void exitRule(ParseTreeListener listener) {
6945 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitExplicitConstructorInvocation(this);
6946 		}
6947 	}
6948 
6949 	public final ExplicitConstructorInvocationContext explicitConstructorInvocation() throws RecognitionException {
6950 		ExplicitConstructorInvocationContext _localctx = new ExplicitConstructorInvocationContext(_ctx, getState());
6951 		enterRule(_localctx, 204, RULE_explicitConstructorInvocation);
6952 		int _la;
6953 		try {
6954 			setState(1346);
6955 			_errHandler.sync(this);
6956 			switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) {
6957 			case 1:
6958 				enterOuterAlt(_localctx, 1);
6959 				{
6960 				setState(1301);
6961 				_errHandler.sync(this);
6962 				_la = _input.LA(1);
6963 				if (_la==LT) {
6964 					{
6965 					setState(1300);
6966 					typeArguments();
6967 					}
6968 				}
6969 
6970 				setState(1303);
6971 				match(THIS);
6972 				setState(1304);
6973 				match(LPAREN);
6974 				setState(1306);
6975 				_errHandler.sync(this);
6976 				_la = _input.LA(1);
6977 				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) {
6978 					{
6979 					setState(1305);
6980 					argumentList();
6981 					}
6982 				}
6983 
6984 				setState(1308);
6985 				match(RPAREN);
6986 				setState(1309);
6987 				match(SEMI);
6988 				}
6989 				break;
6990 			case 2:
6991 				enterOuterAlt(_localctx, 2);
6992 				{
6993 				setState(1311);
6994 				_errHandler.sync(this);
6995 				_la = _input.LA(1);
6996 				if (_la==LT) {
6997 					{
6998 					setState(1310);
6999 					typeArguments();
7000 					}
7001 				}
7002 
7003 				setState(1313);
7004 				match(SUPER);
7005 				setState(1314);
7006 				match(LPAREN);
7007 				setState(1316);
7008 				_errHandler.sync(this);
7009 				_la = _input.LA(1);
7010 				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) {
7011 					{
7012 					setState(1315);
7013 					argumentList();
7014 					}
7015 				}
7016 
7017 				setState(1318);
7018 				match(RPAREN);
7019 				setState(1319);
7020 				match(SEMI);
7021 				}
7022 				break;
7023 			case 3:
7024 				enterOuterAlt(_localctx, 3);
7025 				{
7026 				setState(1320);
7027 				expressionName();
7028 				setState(1321);
7029 				match(DOT);
7030 				setState(1323);
7031 				_errHandler.sync(this);
7032 				_la = _input.LA(1);
7033 				if (_la==LT) {
7034 					{
7035 					setState(1322);
7036 					typeArguments();
7037 					}
7038 				}
7039 
7040 				setState(1325);
7041 				match(SUPER);
7042 				setState(1326);
7043 				match(LPAREN);
7044 				setState(1328);
7045 				_errHandler.sync(this);
7046 				_la = _input.LA(1);
7047 				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) {
7048 					{
7049 					setState(1327);
7050 					argumentList();
7051 					}
7052 				}
7053 
7054 				setState(1330);
7055 				match(RPAREN);
7056 				setState(1331);
7057 				match(SEMI);
7058 				}
7059 				break;
7060 			case 4:
7061 				enterOuterAlt(_localctx, 4);
7062 				{
7063 				setState(1333);
7064 				primary();
7065 				setState(1334);
7066 				match(DOT);
7067 				setState(1336);
7068 				_errHandler.sync(this);
7069 				_la = _input.LA(1);
7070 				if (_la==LT) {
7071 					{
7072 					setState(1335);
7073 					typeArguments();
7074 					}
7075 				}
7076 
7077 				setState(1338);
7078 				match(SUPER);
7079 				setState(1339);
7080 				match(LPAREN);
7081 				setState(1341);
7082 				_errHandler.sync(this);
7083 				_la = _input.LA(1);
7084 				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) {
7085 					{
7086 					setState(1340);
7087 					argumentList();
7088 					}
7089 				}
7090 
7091 				setState(1343);
7092 				match(RPAREN);
7093 				setState(1344);
7094 				match(SEMI);
7095 				}
7096 				break;
7097 			}
7098 		}
7099 		catch (RecognitionException re) {
7100 			_localctx.exception = re;
7101 			_errHandler.reportError(this, re);
7102 			_errHandler.recover(this, re);
7103 		}
7104 		finally {
7105 			exitRule();
7106 		}
7107 		return _localctx;
7108 	}
7109 
7110 	public static class EnumDeclarationContext extends ParserRuleContext {
7111 		public IdentifierContext identifier() {
7112 			return getRuleContext(IdentifierContext.class,0);
7113 		}
7114 		public EnumBodyContext enumBody() {
7115 			return getRuleContext(EnumBodyContext.class,0);
7116 		}
7117 		public List<ClassModifierContext> classModifier() {
7118 			return getRuleContexts(ClassModifierContext.class);
7119 		}
7120 		public ClassModifierContext classModifier(int i) {
7121 			return getRuleContext(ClassModifierContext.class,i);
7122 		}
7123 		public SuperinterfacesContext superinterfaces() {
7124 			return getRuleContext(SuperinterfacesContext.class,0);
7125 		}
7126 		public EnumDeclarationContext(ParserRuleContext parent, int invokingState) {
7127 			super(parent, invokingState);
7128 		}
7129 		@Override public int getRuleIndex() { return RULE_enumDeclaration; }
7130 		@Override
7131 		public void enterRule(ParseTreeListener listener) {
7132 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterEnumDeclaration(this);
7133 		}
7134 		@Override
7135 		public void exitRule(ParseTreeListener listener) {
7136 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitEnumDeclaration(this);
7137 		}
7138 	}
7139 
7140 	public final EnumDeclarationContext enumDeclaration() throws RecognitionException {
7141 		EnumDeclarationContext _localctx = new EnumDeclarationContext(_ctx, getState());
7142 		enterRule(_localctx, 206, RULE_enumDeclaration);
7143 		int _la;
7144 		try {
7145 			enterOuterAlt(_localctx, 1);
7146 			{
7147 			setState(1351);
7148 			_errHandler.sync(this);
7149 			_la = _input.LA(1);
7150 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) {
7151 				{
7152 				{
7153 				setState(1348);
7154 				classModifier();
7155 				}
7156 				}
7157 				setState(1353);
7158 				_errHandler.sync(this);
7159 				_la = _input.LA(1);
7160 			}
7161 			setState(1354);
7162 			match(ENUM);
7163 			setState(1355);
7164 			identifier();
7165 			setState(1357);
7166 			_errHandler.sync(this);
7167 			_la = _input.LA(1);
7168 			if (_la==IMPLEMENTS) {
7169 				{
7170 				setState(1356);
7171 				superinterfaces();
7172 				}
7173 			}
7174 
7175 			setState(1359);
7176 			enumBody();
7177 			}
7178 		}
7179 		catch (RecognitionException re) {
7180 			_localctx.exception = re;
7181 			_errHandler.reportError(this, re);
7182 			_errHandler.recover(this, re);
7183 		}
7184 		finally {
7185 			exitRule();
7186 		}
7187 		return _localctx;
7188 	}
7189 
7190 	public static class EnumBodyContext extends ParserRuleContext {
7191 		public EnumConstantListContext enumConstantList() {
7192 			return getRuleContext(EnumConstantListContext.class,0);
7193 		}
7194 		public EnumBodyDeclarationsContext enumBodyDeclarations() {
7195 			return getRuleContext(EnumBodyDeclarationsContext.class,0);
7196 		}
7197 		public EnumBodyContext(ParserRuleContext parent, int invokingState) {
7198 			super(parent, invokingState);
7199 		}
7200 		@Override public int getRuleIndex() { return RULE_enumBody; }
7201 		@Override
7202 		public void enterRule(ParseTreeListener listener) {
7203 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterEnumBody(this);
7204 		}
7205 		@Override
7206 		public void exitRule(ParseTreeListener listener) {
7207 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitEnumBody(this);
7208 		}
7209 	}
7210 
7211 	public final EnumBodyContext enumBody() throws RecognitionException {
7212 		EnumBodyContext _localctx = new EnumBodyContext(_ctx, getState());
7213 		enterRule(_localctx, 208, RULE_enumBody);
7214 		int _la;
7215 		try {
7216 			enterOuterAlt(_localctx, 1);
7217 			{
7218 			setState(1361);
7219 			match(LBRACE);
7220 			setState(1363);
7221 			_errHandler.sync(this);
7222 			_la = _input.LA(1);
7223 			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8))) != 0) || _la==AT || _la==Identifier) {
7224 				{
7225 				setState(1362);
7226 				enumConstantList();
7227 				}
7228 			}
7229 
7230 			setState(1366);
7231 			_errHandler.sync(this);
7232 			_la = _input.LA(1);
7233 			if (_la==COMMA) {
7234 				{
7235 				setState(1365);
7236 				match(COMMA);
7237 				}
7238 			}
7239 
7240 			setState(1369);
7241 			_errHandler.sync(this);
7242 			_la = _input.LA(1);
7243 			if (_la==SEMI) {
7244 				{
7245 				setState(1368);
7246 				enumBodyDeclarations();
7247 				}
7248 			}
7249 
7250 			setState(1371);
7251 			match(RBRACE);
7252 			}
7253 		}
7254 		catch (RecognitionException re) {
7255 			_localctx.exception = re;
7256 			_errHandler.reportError(this, re);
7257 			_errHandler.recover(this, re);
7258 		}
7259 		finally {
7260 			exitRule();
7261 		}
7262 		return _localctx;
7263 	}
7264 
7265 	public static class EnumConstantListContext extends ParserRuleContext {
7266 		public List<EnumConstantContext> enumConstant() {
7267 			return getRuleContexts(EnumConstantContext.class);
7268 		}
7269 		public EnumConstantContext enumConstant(int i) {
7270 			return getRuleContext(EnumConstantContext.class,i);
7271 		}
7272 		public EnumConstantListContext(ParserRuleContext parent, int invokingState) {
7273 			super(parent, invokingState);
7274 		}
7275 		@Override public int getRuleIndex() { return RULE_enumConstantList; }
7276 		@Override
7277 		public void enterRule(ParseTreeListener listener) {
7278 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterEnumConstantList(this);
7279 		}
7280 		@Override
7281 		public void exitRule(ParseTreeListener listener) {
7282 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitEnumConstantList(this);
7283 		}
7284 	}
7285 
7286 	public final EnumConstantListContext enumConstantList() throws RecognitionException {
7287 		EnumConstantListContext _localctx = new EnumConstantListContext(_ctx, getState());
7288 		enterRule(_localctx, 210, RULE_enumConstantList);
7289 		try {
7290 			int _alt;
7291 			enterOuterAlt(_localctx, 1);
7292 			{
7293 			setState(1373);
7294 			enumConstant();
7295 			setState(1378);
7296 			_errHandler.sync(this);
7297 			_alt = getInterpreter().adaptivePredict(_input,130,_ctx);
7298 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
7299 				if ( _alt==1 ) {
7300 					{
7301 					{
7302 					setState(1374);
7303 					match(COMMA);
7304 					setState(1375);
7305 					enumConstant();
7306 					}
7307 					} 
7308 				}
7309 				setState(1380);
7310 				_errHandler.sync(this);
7311 				_alt = getInterpreter().adaptivePredict(_input,130,_ctx);
7312 			}
7313 			}
7314 		}
7315 		catch (RecognitionException re) {
7316 			_localctx.exception = re;
7317 			_errHandler.reportError(this, re);
7318 			_errHandler.recover(this, re);
7319 		}
7320 		finally {
7321 			exitRule();
7322 		}
7323 		return _localctx;
7324 	}
7325 
7326 	public static class EnumConstantContext extends ParserRuleContext {
7327 		public IdentifierContext identifier() {
7328 			return getRuleContext(IdentifierContext.class,0);
7329 		}
7330 		public List<EnumConstantModifierContext> enumConstantModifier() {
7331 			return getRuleContexts(EnumConstantModifierContext.class);
7332 		}
7333 		public EnumConstantModifierContext enumConstantModifier(int i) {
7334 			return getRuleContext(EnumConstantModifierContext.class,i);
7335 		}
7336 		public ClassBodyContext classBody() {
7337 			return getRuleContext(ClassBodyContext.class,0);
7338 		}
7339 		public ArgumentListContext argumentList() {
7340 			return getRuleContext(ArgumentListContext.class,0);
7341 		}
7342 		public EnumConstantContext(ParserRuleContext parent, int invokingState) {
7343 			super(parent, invokingState);
7344 		}
7345 		@Override public int getRuleIndex() { return RULE_enumConstant; }
7346 		@Override
7347 		public void enterRule(ParseTreeListener listener) {
7348 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterEnumConstant(this);
7349 		}
7350 		@Override
7351 		public void exitRule(ParseTreeListener listener) {
7352 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitEnumConstant(this);
7353 		}
7354 	}
7355 
7356 	public final EnumConstantContext enumConstant() throws RecognitionException {
7357 		EnumConstantContext _localctx = new EnumConstantContext(_ctx, getState());
7358 		enterRule(_localctx, 212, RULE_enumConstant);
7359 		int _la;
7360 		try {
7361 			enterOuterAlt(_localctx, 1);
7362 			{
7363 			setState(1384);
7364 			_errHandler.sync(this);
7365 			_la = _input.LA(1);
7366 			while (_la==AT) {
7367 				{
7368 				{
7369 				setState(1381);
7370 				enumConstantModifier();
7371 				}
7372 				}
7373 				setState(1386);
7374 				_errHandler.sync(this);
7375 				_la = _input.LA(1);
7376 			}
7377 			setState(1387);
7378 			identifier();
7379 			setState(1393);
7380 			_errHandler.sync(this);
7381 			_la = _input.LA(1);
7382 			if (_la==LPAREN) {
7383 				{
7384 				setState(1388);
7385 				match(LPAREN);
7386 				setState(1390);
7387 				_errHandler.sync(this);
7388 				_la = _input.LA(1);
7389 				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << IntegerLiteral) | (1L << FloatingPointLiteral))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (BooleanLiteral - 64)) | (1L << (CharacterLiteral - 64)) | (1L << (StringLiteral - 64)) | (1L << (NullLiteral - 64)) | (1L << (LPAREN - 64)) | (1L << (AT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (Identifier - 64)))) != 0)) {
7390 					{
7391 					setState(1389);
7392 					argumentList();
7393 					}
7394 				}
7395 
7396 				setState(1392);
7397 				match(RPAREN);
7398 				}
7399 			}
7400 
7401 			setState(1396);
7402 			_errHandler.sync(this);
7403 			_la = _input.LA(1);
7404 			if (_la==LBRACE) {
7405 				{
7406 				setState(1395);
7407 				classBody();
7408 				}
7409 			}
7410 
7411 			}
7412 		}
7413 		catch (RecognitionException re) {
7414 			_localctx.exception = re;
7415 			_errHandler.reportError(this, re);
7416 			_errHandler.recover(this, re);
7417 		}
7418 		finally {
7419 			exitRule();
7420 		}
7421 		return _localctx;
7422 	}
7423 
7424 	public static class EnumConstantModifierContext extends ParserRuleContext {
7425 		public AnnotationContext annotation() {
7426 			return getRuleContext(AnnotationContext.class,0);
7427 		}
7428 		public EnumConstantModifierContext(ParserRuleContext parent, int invokingState) {
7429 			super(parent, invokingState);
7430 		}
7431 		@Override public int getRuleIndex() { return RULE_enumConstantModifier; }
7432 		@Override
7433 		public void enterRule(ParseTreeListener listener) {
7434 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterEnumConstantModifier(this);
7435 		}
7436 		@Override
7437 		public void exitRule(ParseTreeListener listener) {
7438 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitEnumConstantModifier(this);
7439 		}
7440 	}
7441 
7442 	public final EnumConstantModifierContext enumConstantModifier() throws RecognitionException {
7443 		EnumConstantModifierContext _localctx = new EnumConstantModifierContext(_ctx, getState());
7444 		enterRule(_localctx, 214, RULE_enumConstantModifier);
7445 		try {
7446 			enterOuterAlt(_localctx, 1);
7447 			{
7448 			setState(1398);
7449 			annotation();
7450 			}
7451 		}
7452 		catch (RecognitionException re) {
7453 			_localctx.exception = re;
7454 			_errHandler.reportError(this, re);
7455 			_errHandler.recover(this, re);
7456 		}
7457 		finally {
7458 			exitRule();
7459 		}
7460 		return _localctx;
7461 	}
7462 
7463 	public static class EnumBodyDeclarationsContext extends ParserRuleContext {
7464 		public List<ClassBodyDeclarationContext> classBodyDeclaration() {
7465 			return getRuleContexts(ClassBodyDeclarationContext.class);
7466 		}
7467 		public ClassBodyDeclarationContext classBodyDeclaration(int i) {
7468 			return getRuleContext(ClassBodyDeclarationContext.class,i);
7469 		}
7470 		public EnumBodyDeclarationsContext(ParserRuleContext parent, int invokingState) {
7471 			super(parent, invokingState);
7472 		}
7473 		@Override public int getRuleIndex() { return RULE_enumBodyDeclarations; }
7474 		@Override
7475 		public void enterRule(ParseTreeListener listener) {
7476 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterEnumBodyDeclarations(this);
7477 		}
7478 		@Override
7479 		public void exitRule(ParseTreeListener listener) {
7480 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitEnumBodyDeclarations(this);
7481 		}
7482 	}
7483 
7484 	public final EnumBodyDeclarationsContext enumBodyDeclarations() throws RecognitionException {
7485 		EnumBodyDeclarationsContext _localctx = new EnumBodyDeclarationsContext(_ctx, getState());
7486 		enterRule(_localctx, 216, RULE_enumBodyDeclarations);
7487 		int _la;
7488 		try {
7489 			enterOuterAlt(_localctx, 1);
7490 			{
7491 			setState(1400);
7492 			match(SEMI);
7493 			setState(1404);
7494 			_errHandler.sync(this);
7495 			_la = _input.LA(1);
7496 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << NATIVE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SYNCHRONIZED) | (1L << TRANSIENT) | (1L << VOID) | (1L << VOLATILE))) != 0) || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & ((1L << (LBRACE - 70)) | (1L << (SEMI - 70)) | (1L << (AT - 70)) | (1L << (LT - 70)) | (1L << (Identifier - 70)))) != 0)) {
7497 				{
7498 				{
7499 				setState(1401);
7500 				classBodyDeclaration();
7501 				}
7502 				}
7503 				setState(1406);
7504 				_errHandler.sync(this);
7505 				_la = _input.LA(1);
7506 			}
7507 			}
7508 		}
7509 		catch (RecognitionException re) {
7510 			_localctx.exception = re;
7511 			_errHandler.reportError(this, re);
7512 			_errHandler.recover(this, re);
7513 		}
7514 		finally {
7515 			exitRule();
7516 		}
7517 		return _localctx;
7518 	}
7519 
7520 	public static class InterfaceDeclarationContext extends ParserRuleContext {
7521 		public NormalInterfaceDeclarationContext normalInterfaceDeclaration() {
7522 			return getRuleContext(NormalInterfaceDeclarationContext.class,0);
7523 		}
7524 		public AnnotationTypeDeclarationContext annotationTypeDeclaration() {
7525 			return getRuleContext(AnnotationTypeDeclarationContext.class,0);
7526 		}
7527 		public InterfaceDeclarationContext(ParserRuleContext parent, int invokingState) {
7528 			super(parent, invokingState);
7529 		}
7530 		@Override public int getRuleIndex() { return RULE_interfaceDeclaration; }
7531 		@Override
7532 		public void enterRule(ParseTreeListener listener) {
7533 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInterfaceDeclaration(this);
7534 		}
7535 		@Override
7536 		public void exitRule(ParseTreeListener listener) {
7537 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInterfaceDeclaration(this);
7538 		}
7539 	}
7540 
7541 	public final InterfaceDeclarationContext interfaceDeclaration() throws RecognitionException {
7542 		InterfaceDeclarationContext _localctx = new InterfaceDeclarationContext(_ctx, getState());
7543 		enterRule(_localctx, 218, RULE_interfaceDeclaration);
7544 		try {
7545 			setState(1409);
7546 			_errHandler.sync(this);
7547 			switch ( getInterpreter().adaptivePredict(_input,136,_ctx) ) {
7548 			case 1:
7549 				enterOuterAlt(_localctx, 1);
7550 				{
7551 				setState(1407);
7552 				normalInterfaceDeclaration();
7553 				}
7554 				break;
7555 			case 2:
7556 				enterOuterAlt(_localctx, 2);
7557 				{
7558 				setState(1408);
7559 				annotationTypeDeclaration();
7560 				}
7561 				break;
7562 			}
7563 		}
7564 		catch (RecognitionException re) {
7565 			_localctx.exception = re;
7566 			_errHandler.reportError(this, re);
7567 			_errHandler.recover(this, re);
7568 		}
7569 		finally {
7570 			exitRule();
7571 		}
7572 		return _localctx;
7573 	}
7574 
7575 	public static class NormalInterfaceDeclarationContext extends ParserRuleContext {
7576 		public IdentifierContext identifier() {
7577 			return getRuleContext(IdentifierContext.class,0);
7578 		}
7579 		public InterfaceBodyContext interfaceBody() {
7580 			return getRuleContext(InterfaceBodyContext.class,0);
7581 		}
7582 		public List<InterfaceModifierContext> interfaceModifier() {
7583 			return getRuleContexts(InterfaceModifierContext.class);
7584 		}
7585 		public InterfaceModifierContext interfaceModifier(int i) {
7586 			return getRuleContext(InterfaceModifierContext.class,i);
7587 		}
7588 		public TypeParametersContext typeParameters() {
7589 			return getRuleContext(TypeParametersContext.class,0);
7590 		}
7591 		public ExtendsInterfacesContext extendsInterfaces() {
7592 			return getRuleContext(ExtendsInterfacesContext.class,0);
7593 		}
7594 		public NormalInterfaceDeclarationContext(ParserRuleContext parent, int invokingState) {
7595 			super(parent, invokingState);
7596 		}
7597 		@Override public int getRuleIndex() { return RULE_normalInterfaceDeclaration; }
7598 		@Override
7599 		public void enterRule(ParseTreeListener listener) {
7600 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterNormalInterfaceDeclaration(this);
7601 		}
7602 		@Override
7603 		public void exitRule(ParseTreeListener listener) {
7604 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitNormalInterfaceDeclaration(this);
7605 		}
7606 	}
7607 
7608 	public final NormalInterfaceDeclarationContext normalInterfaceDeclaration() throws RecognitionException {
7609 		NormalInterfaceDeclarationContext _localctx = new NormalInterfaceDeclarationContext(_ctx, getState());
7610 		enterRule(_localctx, 220, RULE_normalInterfaceDeclaration);
7611 		int _la;
7612 		try {
7613 			enterOuterAlt(_localctx, 1);
7614 			{
7615 			setState(1414);
7616 			_errHandler.sync(this);
7617 			_la = _input.LA(1);
7618 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) {
7619 				{
7620 				{
7621 				setState(1411);
7622 				interfaceModifier();
7623 				}
7624 				}
7625 				setState(1416);
7626 				_errHandler.sync(this);
7627 				_la = _input.LA(1);
7628 			}
7629 			setState(1417);
7630 			match(INTERFACE);
7631 			setState(1418);
7632 			identifier();
7633 			setState(1420);
7634 			_errHandler.sync(this);
7635 			_la = _input.LA(1);
7636 			if (_la==LT) {
7637 				{
7638 				setState(1419);
7639 				typeParameters();
7640 				}
7641 			}
7642 
7643 			setState(1423);
7644 			_errHandler.sync(this);
7645 			_la = _input.LA(1);
7646 			if (_la==EXTENDS) {
7647 				{
7648 				setState(1422);
7649 				extendsInterfaces();
7650 				}
7651 			}
7652 
7653 			setState(1425);
7654 			interfaceBody();
7655 			}
7656 		}
7657 		catch (RecognitionException re) {
7658 			_localctx.exception = re;
7659 			_errHandler.reportError(this, re);
7660 			_errHandler.recover(this, re);
7661 		}
7662 		finally {
7663 			exitRule();
7664 		}
7665 		return _localctx;
7666 	}
7667 
7668 	public static class InterfaceModifierContext extends ParserRuleContext {
7669 		public AnnotationContext annotation() {
7670 			return getRuleContext(AnnotationContext.class,0);
7671 		}
7672 		public InterfaceModifierContext(ParserRuleContext parent, int invokingState) {
7673 			super(parent, invokingState);
7674 		}
7675 		@Override public int getRuleIndex() { return RULE_interfaceModifier; }
7676 		@Override
7677 		public void enterRule(ParseTreeListener listener) {
7678 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInterfaceModifier(this);
7679 		}
7680 		@Override
7681 		public void exitRule(ParseTreeListener listener) {
7682 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInterfaceModifier(this);
7683 		}
7684 	}
7685 
7686 	public final InterfaceModifierContext interfaceModifier() throws RecognitionException {
7687 		InterfaceModifierContext _localctx = new InterfaceModifierContext(_ctx, getState());
7688 		enterRule(_localctx, 222, RULE_interfaceModifier);
7689 		try {
7690 			setState(1434);
7691 			_errHandler.sync(this);
7692 			switch (_input.LA(1)) {
7693 			case AT:
7694 				enterOuterAlt(_localctx, 1);
7695 				{
7696 				setState(1427);
7697 				annotation();
7698 				}
7699 				break;
7700 			case PUBLIC:
7701 				enterOuterAlt(_localctx, 2);
7702 				{
7703 				setState(1428);
7704 				match(PUBLIC);
7705 				}
7706 				break;
7707 			case PROTECTED:
7708 				enterOuterAlt(_localctx, 3);
7709 				{
7710 				setState(1429);
7711 				match(PROTECTED);
7712 				}
7713 				break;
7714 			case PRIVATE:
7715 				enterOuterAlt(_localctx, 4);
7716 				{
7717 				setState(1430);
7718 				match(PRIVATE);
7719 				}
7720 				break;
7721 			case ABSTRACT:
7722 				enterOuterAlt(_localctx, 5);
7723 				{
7724 				setState(1431);
7725 				match(ABSTRACT);
7726 				}
7727 				break;
7728 			case STATIC:
7729 				enterOuterAlt(_localctx, 6);
7730 				{
7731 				setState(1432);
7732 				match(STATIC);
7733 				}
7734 				break;
7735 			case STRICTFP:
7736 				enterOuterAlt(_localctx, 7);
7737 				{
7738 				setState(1433);
7739 				match(STRICTFP);
7740 				}
7741 				break;
7742 			default:
7743 				throw new NoViableAltException(this);
7744 			}
7745 		}
7746 		catch (RecognitionException re) {
7747 			_localctx.exception = re;
7748 			_errHandler.reportError(this, re);
7749 			_errHandler.recover(this, re);
7750 		}
7751 		finally {
7752 			exitRule();
7753 		}
7754 		return _localctx;
7755 	}
7756 
7757 	public static class ExtendsInterfacesContext extends ParserRuleContext {
7758 		public InterfaceTypeListContext interfaceTypeList() {
7759 			return getRuleContext(InterfaceTypeListContext.class,0);
7760 		}
7761 		public ExtendsInterfacesContext(ParserRuleContext parent, int invokingState) {
7762 			super(parent, invokingState);
7763 		}
7764 		@Override public int getRuleIndex() { return RULE_extendsInterfaces; }
7765 		@Override
7766 		public void enterRule(ParseTreeListener listener) {
7767 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterExtendsInterfaces(this);
7768 		}
7769 		@Override
7770 		public void exitRule(ParseTreeListener listener) {
7771 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitExtendsInterfaces(this);
7772 		}
7773 	}
7774 
7775 	public final ExtendsInterfacesContext extendsInterfaces() throws RecognitionException {
7776 		ExtendsInterfacesContext _localctx = new ExtendsInterfacesContext(_ctx, getState());
7777 		enterRule(_localctx, 224, RULE_extendsInterfaces);
7778 		try {
7779 			enterOuterAlt(_localctx, 1);
7780 			{
7781 			setState(1436);
7782 			match(EXTENDS);
7783 			setState(1437);
7784 			interfaceTypeList();
7785 			}
7786 		}
7787 		catch (RecognitionException re) {
7788 			_localctx.exception = re;
7789 			_errHandler.reportError(this, re);
7790 			_errHandler.recover(this, re);
7791 		}
7792 		finally {
7793 			exitRule();
7794 		}
7795 		return _localctx;
7796 	}
7797 
7798 	public static class InterfaceBodyContext extends ParserRuleContext {
7799 		public List<InterfaceMemberDeclarationContext> interfaceMemberDeclaration() {
7800 			return getRuleContexts(InterfaceMemberDeclarationContext.class);
7801 		}
7802 		public InterfaceMemberDeclarationContext interfaceMemberDeclaration(int i) {
7803 			return getRuleContext(InterfaceMemberDeclarationContext.class,i);
7804 		}
7805 		public InterfaceBodyContext(ParserRuleContext parent, int invokingState) {
7806 			super(parent, invokingState);
7807 		}
7808 		@Override public int getRuleIndex() { return RULE_interfaceBody; }
7809 		@Override
7810 		public void enterRule(ParseTreeListener listener) {
7811 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInterfaceBody(this);
7812 		}
7813 		@Override
7814 		public void exitRule(ParseTreeListener listener) {
7815 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInterfaceBody(this);
7816 		}
7817 	}
7818 
7819 	public final InterfaceBodyContext interfaceBody() throws RecognitionException {
7820 		InterfaceBodyContext _localctx = new InterfaceBodyContext(_ctx, getState());
7821 		enterRule(_localctx, 226, RULE_interfaceBody);
7822 		int _la;
7823 		try {
7824 			enterOuterAlt(_localctx, 1);
7825 			{
7826 			setState(1439);
7827 			match(LBRACE);
7828 			setState(1443);
7829 			_errHandler.sync(this);
7830 			_la = _input.LA(1);
7831 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DEFAULT) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << VOID))) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (SEMI - 74)) | (1L << (AT - 74)) | (1L << (LT - 74)) | (1L << (Identifier - 74)))) != 0)) {
7832 				{
7833 				{
7834 				setState(1440);
7835 				interfaceMemberDeclaration();
7836 				}
7837 				}
7838 				setState(1445);
7839 				_errHandler.sync(this);
7840 				_la = _input.LA(1);
7841 			}
7842 			setState(1446);
7843 			match(RBRACE);
7844 			}
7845 		}
7846 		catch (RecognitionException re) {
7847 			_localctx.exception = re;
7848 			_errHandler.reportError(this, re);
7849 			_errHandler.recover(this, re);
7850 		}
7851 		finally {
7852 			exitRule();
7853 		}
7854 		return _localctx;
7855 	}
7856 
7857 	public static class InterfaceMemberDeclarationContext extends ParserRuleContext {
7858 		public ConstantDeclarationContext constantDeclaration() {
7859 			return getRuleContext(ConstantDeclarationContext.class,0);
7860 		}
7861 		public InterfaceMethodDeclarationContext interfaceMethodDeclaration() {
7862 			return getRuleContext(InterfaceMethodDeclarationContext.class,0);
7863 		}
7864 		public ClassDeclarationContext classDeclaration() {
7865 			return getRuleContext(ClassDeclarationContext.class,0);
7866 		}
7867 		public InterfaceDeclarationContext interfaceDeclaration() {
7868 			return getRuleContext(InterfaceDeclarationContext.class,0);
7869 		}
7870 		public InterfaceMemberDeclarationContext(ParserRuleContext parent, int invokingState) {
7871 			super(parent, invokingState);
7872 		}
7873 		@Override public int getRuleIndex() { return RULE_interfaceMemberDeclaration; }
7874 		@Override
7875 		public void enterRule(ParseTreeListener listener) {
7876 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInterfaceMemberDeclaration(this);
7877 		}
7878 		@Override
7879 		public void exitRule(ParseTreeListener listener) {
7880 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInterfaceMemberDeclaration(this);
7881 		}
7882 	}
7883 
7884 	public final InterfaceMemberDeclarationContext interfaceMemberDeclaration() throws RecognitionException {
7885 		InterfaceMemberDeclarationContext _localctx = new InterfaceMemberDeclarationContext(_ctx, getState());
7886 		enterRule(_localctx, 228, RULE_interfaceMemberDeclaration);
7887 		try {
7888 			setState(1453);
7889 			_errHandler.sync(this);
7890 			switch ( getInterpreter().adaptivePredict(_input,142,_ctx) ) {
7891 			case 1:
7892 				enterOuterAlt(_localctx, 1);
7893 				{
7894 				setState(1448);
7895 				constantDeclaration();
7896 				}
7897 				break;
7898 			case 2:
7899 				enterOuterAlt(_localctx, 2);
7900 				{
7901 				setState(1449);
7902 				interfaceMethodDeclaration();
7903 				}
7904 				break;
7905 			case 3:
7906 				enterOuterAlt(_localctx, 3);
7907 				{
7908 				setState(1450);
7909 				classDeclaration();
7910 				}
7911 				break;
7912 			case 4:
7913 				enterOuterAlt(_localctx, 4);
7914 				{
7915 				setState(1451);
7916 				interfaceDeclaration();
7917 				}
7918 				break;
7919 			case 5:
7920 				enterOuterAlt(_localctx, 5);
7921 				{
7922 				setState(1452);
7923 				match(SEMI);
7924 				}
7925 				break;
7926 			}
7927 		}
7928 		catch (RecognitionException re) {
7929 			_localctx.exception = re;
7930 			_errHandler.reportError(this, re);
7931 			_errHandler.recover(this, re);
7932 		}
7933 		finally {
7934 			exitRule();
7935 		}
7936 		return _localctx;
7937 	}
7938 
7939 	public static class ConstantDeclarationContext extends ParserRuleContext {
7940 		public UnannTypeContext unannType() {
7941 			return getRuleContext(UnannTypeContext.class,0);
7942 		}
7943 		public VariableDeclaratorListContext variableDeclaratorList() {
7944 			return getRuleContext(VariableDeclaratorListContext.class,0);
7945 		}
7946 		public List<ConstantModifierContext> constantModifier() {
7947 			return getRuleContexts(ConstantModifierContext.class);
7948 		}
7949 		public ConstantModifierContext constantModifier(int i) {
7950 			return getRuleContext(ConstantModifierContext.class,i);
7951 		}
7952 		public ConstantDeclarationContext(ParserRuleContext parent, int invokingState) {
7953 			super(parent, invokingState);
7954 		}
7955 		@Override public int getRuleIndex() { return RULE_constantDeclaration; }
7956 		@Override
7957 		public void enterRule(ParseTreeListener listener) {
7958 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterConstantDeclaration(this);
7959 		}
7960 		@Override
7961 		public void exitRule(ParseTreeListener listener) {
7962 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitConstantDeclaration(this);
7963 		}
7964 	}
7965 
7966 	public final ConstantDeclarationContext constantDeclaration() throws RecognitionException {
7967 		ConstantDeclarationContext _localctx = new ConstantDeclarationContext(_ctx, getState());
7968 		enterRule(_localctx, 230, RULE_constantDeclaration);
7969 		int _la;
7970 		try {
7971 			enterOuterAlt(_localctx, 1);
7972 			{
7973 			setState(1458);
7974 			_errHandler.sync(this);
7975 			_la = _input.LA(1);
7976 			while (((((_la - 28)) & ~0x3f) == 0 && ((1L << (_la - 28)) & ((1L << (FINAL - 28)) | (1L << (PUBLIC - 28)) | (1L << (STATIC - 28)) | (1L << (AT - 28)))) != 0)) {
7977 				{
7978 				{
7979 				setState(1455);
7980 				constantModifier();
7981 				}
7982 				}
7983 				setState(1460);
7984 				_errHandler.sync(this);
7985 				_la = _input.LA(1);
7986 			}
7987 			setState(1461);
7988 			unannType();
7989 			setState(1462);
7990 			variableDeclaratorList();
7991 			setState(1463);
7992 			match(SEMI);
7993 			}
7994 		}
7995 		catch (RecognitionException re) {
7996 			_localctx.exception = re;
7997 			_errHandler.reportError(this, re);
7998 			_errHandler.recover(this, re);
7999 		}
8000 		finally {
8001 			exitRule();
8002 		}
8003 		return _localctx;
8004 	}
8005 
8006 	public static class ConstantModifierContext extends ParserRuleContext {
8007 		public AnnotationContext annotation() {
8008 			return getRuleContext(AnnotationContext.class,0);
8009 		}
8010 		public ConstantModifierContext(ParserRuleContext parent, int invokingState) {
8011 			super(parent, invokingState);
8012 		}
8013 		@Override public int getRuleIndex() { return RULE_constantModifier; }
8014 		@Override
8015 		public void enterRule(ParseTreeListener listener) {
8016 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterConstantModifier(this);
8017 		}
8018 		@Override
8019 		public void exitRule(ParseTreeListener listener) {
8020 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitConstantModifier(this);
8021 		}
8022 	}
8023 
8024 	public final ConstantModifierContext constantModifier() throws RecognitionException {
8025 		ConstantModifierContext _localctx = new ConstantModifierContext(_ctx, getState());
8026 		enterRule(_localctx, 232, RULE_constantModifier);
8027 		try {
8028 			setState(1469);
8029 			_errHandler.sync(this);
8030 			switch (_input.LA(1)) {
8031 			case AT:
8032 				enterOuterAlt(_localctx, 1);
8033 				{
8034 				setState(1465);
8035 				annotation();
8036 				}
8037 				break;
8038 			case PUBLIC:
8039 				enterOuterAlt(_localctx, 2);
8040 				{
8041 				setState(1466);
8042 				match(PUBLIC);
8043 				}
8044 				break;
8045 			case STATIC:
8046 				enterOuterAlt(_localctx, 3);
8047 				{
8048 				setState(1467);
8049 				match(STATIC);
8050 				}
8051 				break;
8052 			case FINAL:
8053 				enterOuterAlt(_localctx, 4);
8054 				{
8055 				setState(1468);
8056 				match(FINAL);
8057 				}
8058 				break;
8059 			default:
8060 				throw new NoViableAltException(this);
8061 			}
8062 		}
8063 		catch (RecognitionException re) {
8064 			_localctx.exception = re;
8065 			_errHandler.reportError(this, re);
8066 			_errHandler.recover(this, re);
8067 		}
8068 		finally {
8069 			exitRule();
8070 		}
8071 		return _localctx;
8072 	}
8073 
8074 	public static class InterfaceMethodDeclarationContext extends ParserRuleContext {
8075 		public MethodHeaderContext methodHeader() {
8076 			return getRuleContext(MethodHeaderContext.class,0);
8077 		}
8078 		public MethodBodyContext methodBody() {
8079 			return getRuleContext(MethodBodyContext.class,0);
8080 		}
8081 		public List<InterfaceMethodModifierContext> interfaceMethodModifier() {
8082 			return getRuleContexts(InterfaceMethodModifierContext.class);
8083 		}
8084 		public InterfaceMethodModifierContext interfaceMethodModifier(int i) {
8085 			return getRuleContext(InterfaceMethodModifierContext.class,i);
8086 		}
8087 		public InterfaceMethodDeclarationContext(ParserRuleContext parent, int invokingState) {
8088 			super(parent, invokingState);
8089 		}
8090 		@Override public int getRuleIndex() { return RULE_interfaceMethodDeclaration; }
8091 		@Override
8092 		public void enterRule(ParseTreeListener listener) {
8093 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInterfaceMethodDeclaration(this);
8094 		}
8095 		@Override
8096 		public void exitRule(ParseTreeListener listener) {
8097 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInterfaceMethodDeclaration(this);
8098 		}
8099 	}
8100 
8101 	public final InterfaceMethodDeclarationContext interfaceMethodDeclaration() throws RecognitionException {
8102 		InterfaceMethodDeclarationContext _localctx = new InterfaceMethodDeclarationContext(_ctx, getState());
8103 		enterRule(_localctx, 234, RULE_interfaceMethodDeclaration);
8104 		int _la;
8105 		try {
8106 			enterOuterAlt(_localctx, 1);
8107 			{
8108 			setState(1474);
8109 			_errHandler.sync(this);
8110 			_la = _input.LA(1);
8111 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << DEFAULT) | (1L << PRIVATE) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) {
8112 				{
8113 				{
8114 				setState(1471);
8115 				interfaceMethodModifier();
8116 				}
8117 				}
8118 				setState(1476);
8119 				_errHandler.sync(this);
8120 				_la = _input.LA(1);
8121 			}
8122 			setState(1477);
8123 			methodHeader();
8124 			setState(1478);
8125 			methodBody();
8126 			}
8127 		}
8128 		catch (RecognitionException re) {
8129 			_localctx.exception = re;
8130 			_errHandler.reportError(this, re);
8131 			_errHandler.recover(this, re);
8132 		}
8133 		finally {
8134 			exitRule();
8135 		}
8136 		return _localctx;
8137 	}
8138 
8139 	public static class InterfaceMethodModifierContext extends ParserRuleContext {
8140 		public AnnotationContext annotation() {
8141 			return getRuleContext(AnnotationContext.class,0);
8142 		}
8143 		public InterfaceMethodModifierContext(ParserRuleContext parent, int invokingState) {
8144 			super(parent, invokingState);
8145 		}
8146 		@Override public int getRuleIndex() { return RULE_interfaceMethodModifier; }
8147 		@Override
8148 		public void enterRule(ParseTreeListener listener) {
8149 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInterfaceMethodModifier(this);
8150 		}
8151 		@Override
8152 		public void exitRule(ParseTreeListener listener) {
8153 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInterfaceMethodModifier(this);
8154 		}
8155 	}
8156 
8157 	public final InterfaceMethodModifierContext interfaceMethodModifier() throws RecognitionException {
8158 		InterfaceMethodModifierContext _localctx = new InterfaceMethodModifierContext(_ctx, getState());
8159 		enterRule(_localctx, 236, RULE_interfaceMethodModifier);
8160 		try {
8161 			setState(1487);
8162 			_errHandler.sync(this);
8163 			switch (_input.LA(1)) {
8164 			case AT:
8165 				enterOuterAlt(_localctx, 1);
8166 				{
8167 				setState(1480);
8168 				annotation();
8169 				}
8170 				break;
8171 			case PUBLIC:
8172 				enterOuterAlt(_localctx, 2);
8173 				{
8174 				setState(1481);
8175 				match(PUBLIC);
8176 				}
8177 				break;
8178 			case PRIVATE:
8179 				enterOuterAlt(_localctx, 3);
8180 				{
8181 				setState(1482);
8182 				match(PRIVATE);
8183 				}
8184 				break;
8185 			case ABSTRACT:
8186 				enterOuterAlt(_localctx, 4);
8187 				{
8188 				setState(1483);
8189 				match(ABSTRACT);
8190 				}
8191 				break;
8192 			case DEFAULT:
8193 				enterOuterAlt(_localctx, 5);
8194 				{
8195 				setState(1484);
8196 				match(DEFAULT);
8197 				}
8198 				break;
8199 			case STATIC:
8200 				enterOuterAlt(_localctx, 6);
8201 				{
8202 				setState(1485);
8203 				match(STATIC);
8204 				}
8205 				break;
8206 			case STRICTFP:
8207 				enterOuterAlt(_localctx, 7);
8208 				{
8209 				setState(1486);
8210 				match(STRICTFP);
8211 				}
8212 				break;
8213 			default:
8214 				throw new NoViableAltException(this);
8215 			}
8216 		}
8217 		catch (RecognitionException re) {
8218 			_localctx.exception = re;
8219 			_errHandler.reportError(this, re);
8220 			_errHandler.recover(this, re);
8221 		}
8222 		finally {
8223 			exitRule();
8224 		}
8225 		return _localctx;
8226 	}
8227 
8228 	public static class AnnotationTypeDeclarationContext extends ParserRuleContext {
8229 		public IdentifierContext identifier() {
8230 			return getRuleContext(IdentifierContext.class,0);
8231 		}
8232 		public AnnotationTypeBodyContext annotationTypeBody() {
8233 			return getRuleContext(AnnotationTypeBodyContext.class,0);
8234 		}
8235 		public List<InterfaceModifierContext> interfaceModifier() {
8236 			return getRuleContexts(InterfaceModifierContext.class);
8237 		}
8238 		public InterfaceModifierContext interfaceModifier(int i) {
8239 			return getRuleContext(InterfaceModifierContext.class,i);
8240 		}
8241 		public AnnotationTypeDeclarationContext(ParserRuleContext parent, int invokingState) {
8242 			super(parent, invokingState);
8243 		}
8244 		@Override public int getRuleIndex() { return RULE_annotationTypeDeclaration; }
8245 		@Override
8246 		public void enterRule(ParseTreeListener listener) {
8247 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterAnnotationTypeDeclaration(this);
8248 		}
8249 		@Override
8250 		public void exitRule(ParseTreeListener listener) {
8251 			if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitAnnotationTypeDeclaration(this);
8252 		}
8253 	}
8254 
8255 	public final AnnotationTypeDeclarationContext annotationTypeDeclaration() throws RecognitionException {
8256 		AnnotationTypeDeclarationContext _localctx = new AnnotationTypeDeclarationContext(_ctx, getState());
8257 		enterRule(_localctx, 238, RULE_annotationTypeDeclaration);
8258 		try {
8259 			int _alt;
8260 			enterOuterAlt(_localctx, 1);
8261 			{
8262 			setState(1492);
8263 			_errHandler.sync(this);
8264 			_alt = getInterpreter().adaptivePredict(_input,147,_ctx);
8265 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
8266 				if ( _alt==1 ) {
8267 					{
8268 					{
8269 					setState(1489);
8270 					interfaceModifier();
8271 					}
8272 					} 
8273 				}
8274 				setState(1494);
8275 				_errHandler.sync(this);
8276 				_alt = getInterpreter().adaptivePredict(_input,147,_ctx);
8277 			}
8278 			setState(1495);
8279 			match(AT);
8280 			setState(1496);
8281 			match(INTERFACE);
8282 			setState(1497);
8283 			identifier();
8284 			setState(1498);
8285 			annotationTypeBody();
8286 			}
8287 		}
8288 		catch (RecognitionException re) {
8289 			_localctx.exception = re;
8290 			_errHandler.reportError(this, re);
8291 			_errHandler.recover(this, re);
8292 		}
8293 		finally {