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
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 {
8294 exitRule();
8295 }
8296 return _localctx;
8297 }
8298
8299 public static class AnnotationTypeBodyContext extends ParserRuleContext {
8300 public List<AnnotationTypeMemberDeclarationContext> annotationTypeMemberDeclaration() {
8301 return getRuleContexts(AnnotationTypeMemberDeclarationContext.class);
8302 }
8303 public AnnotationTypeMemberDeclarationContext annotationTypeMemberDeclaration(int i) {
8304 return getRuleContext(AnnotationTypeMemberDeclarationContext.class,i);
8305 }
8306 public AnnotationTypeBodyContext(ParserRuleContext parent, int invokingState) {
8307 super(parent, invokingState);
8308 }
8309 @Override public int getRuleIndex() { return RULE_annotationTypeBody; }
8310 @Override
8311 public void enterRule(ParseTreeListener listener) {
8312 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterAnnotationTypeBody(this);
8313 }
8314 @Override
8315 public void exitRule(ParseTreeListener listener) {
8316 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitAnnotationTypeBody(this);
8317 }
8318 }
8319
8320 public final AnnotationTypeBodyContext annotationTypeBody() throws RecognitionException {
8321 AnnotationTypeBodyContext _localctx = new AnnotationTypeBodyContext(_ctx, getState());
8322 enterRule(_localctx, 240, RULE_annotationTypeBody);
8323 int _la;
8324 try {
8325 enterOuterAlt(_localctx, 1);
8326 {
8327 setState(1500);
8328 match(LBRACE);
8329 setState(1504);
8330 _errHandler.sync(this);
8331 _la = _input.LA(1);
8332 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 << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP))) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (SEMI - 74)) | (1L << (AT - 74)) | (1L << (Identifier - 74)))) != 0)) {
8333 {
8334 {
8335 setState(1501);
8336 annotationTypeMemberDeclaration();
8337 }
8338 }
8339 setState(1506);
8340 _errHandler.sync(this);
8341 _la = _input.LA(1);
8342 }
8343 setState(1507);
8344 match(RBRACE);
8345 }
8346 }
8347 catch (RecognitionException re) {
8348 _localctx.exception = re;
8349 _errHandler.reportError(this, re);
8350 _errHandler.recover(this, re);
8351 }
8352 finally {
8353 exitRule();
8354 }
8355 return _localctx;
8356 }
8357
8358 public static class AnnotationTypeMemberDeclarationContext extends ParserRuleContext {
8359 public AnnotationTypeElementDeclarationContext annotationTypeElementDeclaration() {
8360 return getRuleContext(AnnotationTypeElementDeclarationContext.class,0);
8361 }
8362 public ConstantDeclarationContext constantDeclaration() {
8363 return getRuleContext(ConstantDeclarationContext.class,0);
8364 }
8365 public ClassDeclarationContext classDeclaration() {
8366 return getRuleContext(ClassDeclarationContext.class,0);
8367 }
8368 public InterfaceDeclarationContext interfaceDeclaration() {
8369 return getRuleContext(InterfaceDeclarationContext.class,0);
8370 }
8371 public AnnotationTypeMemberDeclarationContext(ParserRuleContext parent, int invokingState) {
8372 super(parent, invokingState);
8373 }
8374 @Override public int getRuleIndex() { return RULE_annotationTypeMemberDeclaration; }
8375 @Override
8376 public void enterRule(ParseTreeListener listener) {
8377 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterAnnotationTypeMemberDeclaration(this);
8378 }
8379 @Override
8380 public void exitRule(ParseTreeListener listener) {
8381 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitAnnotationTypeMemberDeclaration(this);
8382 }
8383 }
8384
8385 public final AnnotationTypeMemberDeclarationContext annotationTypeMemberDeclaration() throws RecognitionException {
8386 AnnotationTypeMemberDeclarationContext _localctx = new AnnotationTypeMemberDeclarationContext(_ctx, getState());
8387 enterRule(_localctx, 242, RULE_annotationTypeMemberDeclaration);
8388 try {
8389 setState(1514);
8390 _errHandler.sync(this);
8391 switch ( getInterpreter().adaptivePredict(_input,149,_ctx) ) {
8392 case 1:
8393 enterOuterAlt(_localctx, 1);
8394 {
8395 setState(1509);
8396 annotationTypeElementDeclaration();
8397 }
8398 break;
8399 case 2:
8400 enterOuterAlt(_localctx, 2);
8401 {
8402 setState(1510);
8403 constantDeclaration();
8404 }
8405 break;
8406 case 3:
8407 enterOuterAlt(_localctx, 3);
8408 {
8409 setState(1511);
8410 classDeclaration();
8411 }
8412 break;
8413 case 4:
8414 enterOuterAlt(_localctx, 4);
8415 {
8416 setState(1512);
8417 interfaceDeclaration();
8418 }
8419 break;
8420 case 5:
8421 enterOuterAlt(_localctx, 5);
8422 {
8423 setState(1513);
8424 match(SEMI);
8425 }
8426 break;
8427 }
8428 }
8429 catch (RecognitionException re) {
8430 _localctx.exception = re;
8431 _errHandler.reportError(this, re);
8432 _errHandler.recover(this, re);
8433 }
8434 finally {
8435 exitRule();
8436 }
8437 return _localctx;
8438 }
8439
8440 public static class AnnotationTypeElementDeclarationContext extends ParserRuleContext {
8441 public UnannTypeContext unannType() {
8442 return getRuleContext(UnannTypeContext.class,0);
8443 }
8444 public IdentifierContext identifier() {
8445 return getRuleContext(IdentifierContext.class,0);
8446 }
8447 public List<AnnotationTypeElementModifierContext> annotationTypeElementModifier() {
8448 return getRuleContexts(AnnotationTypeElementModifierContext.class);
8449 }
8450 public AnnotationTypeElementModifierContext annotationTypeElementModifier(int i) {
8451 return getRuleContext(AnnotationTypeElementModifierContext.class,i);
8452 }
8453 public DimsContext dims() {
8454 return getRuleContext(DimsContext.class,0);
8455 }
8456 public DefaultValueContext defaultValue() {
8457 return getRuleContext(DefaultValueContext.class,0);
8458 }
8459 public AnnotationTypeElementDeclarationContext(ParserRuleContext parent, int invokingState) {
8460 super(parent, invokingState);
8461 }
8462 @Override public int getRuleIndex() { return RULE_annotationTypeElementDeclaration; }
8463 @Override
8464 public void enterRule(ParseTreeListener listener) {
8465 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterAnnotationTypeElementDeclaration(this);
8466 }
8467 @Override
8468 public void exitRule(ParseTreeListener listener) {
8469 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitAnnotationTypeElementDeclaration(this);
8470 }
8471 }
8472
8473 public final AnnotationTypeElementDeclarationContext annotationTypeElementDeclaration() throws RecognitionException {
8474 AnnotationTypeElementDeclarationContext _localctx = new AnnotationTypeElementDeclarationContext(_ctx, getState());
8475 enterRule(_localctx, 244, RULE_annotationTypeElementDeclaration);
8476 int _la;
8477 try {
8478 enterOuterAlt(_localctx, 1);
8479 {
8480 setState(1519);
8481 _errHandler.sync(this);
8482 _la = _input.LA(1);
8483 while (_la==ABSTRACT || _la==PUBLIC || _la==AT) {
8484 {
8485 {
8486 setState(1516);
8487 annotationTypeElementModifier();
8488 }
8489 }
8490 setState(1521);
8491 _errHandler.sync(this);
8492 _la = _input.LA(1);
8493 }
8494 setState(1522);
8495 unannType();
8496 setState(1523);
8497 identifier();
8498 setState(1524);
8499 match(LPAREN);
8500 setState(1525);
8501 match(RPAREN);
8502 setState(1527);
8503 _errHandler.sync(this);
8504 _la = _input.LA(1);
8505 if (_la==LBRACK || _la==AT) {
8506 {
8507 setState(1526);
8508 dims();
8509 }
8510 }
8511
8512 setState(1530);
8513 _errHandler.sync(this);
8514 _la = _input.LA(1);
8515 if (_la==DEFAULT) {
8516 {
8517 setState(1529);
8518 defaultValue();
8519 }
8520 }
8521
8522 setState(1532);
8523 match(SEMI);
8524 }
8525 }
8526 catch (RecognitionException re) {
8527 _localctx.exception = re;
8528 _errHandler.reportError(this, re);
8529 _errHandler.recover(this, re);
8530 }
8531 finally {
8532 exitRule();
8533 }
8534 return _localctx;
8535 }
8536
8537 public static class AnnotationTypeElementModifierContext extends ParserRuleContext {
8538 public AnnotationContext annotation() {
8539 return getRuleContext(AnnotationContext.class,0);
8540 }
8541 public AnnotationTypeElementModifierContext(ParserRuleContext parent, int invokingState) {
8542 super(parent, invokingState);
8543 }
8544 @Override public int getRuleIndex() { return RULE_annotationTypeElementModifier; }
8545 @Override
8546 public void enterRule(ParseTreeListener listener) {
8547 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterAnnotationTypeElementModifier(this);
8548 }
8549 @Override
8550 public void exitRule(ParseTreeListener listener) {
8551 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitAnnotationTypeElementModifier(this);
8552 }
8553 }
8554
8555 public final AnnotationTypeElementModifierContext annotationTypeElementModifier() throws RecognitionException {
8556 AnnotationTypeElementModifierContext _localctx = new AnnotationTypeElementModifierContext(_ctx, getState());
8557 enterRule(_localctx, 246, RULE_annotationTypeElementModifier);
8558 try {
8559 setState(1537);
8560 _errHandler.sync(this);
8561 switch (_input.LA(1)) {
8562 case AT:
8563 enterOuterAlt(_localctx, 1);
8564 {
8565 setState(1534);
8566 annotation();
8567 }
8568 break;
8569 case PUBLIC:
8570 enterOuterAlt(_localctx, 2);
8571 {
8572 setState(1535);
8573 match(PUBLIC);
8574 }
8575 break;
8576 case ABSTRACT:
8577 enterOuterAlt(_localctx, 3);
8578 {
8579 setState(1536);
8580 match(ABSTRACT);
8581 }
8582 break;
8583 default:
8584 throw new NoViableAltException(this);
8585 }
8586 }
8587 catch (RecognitionException re) {
8588 _localctx.exception = re;
8589 _errHandler.reportError(this, re);
8590 _errHandler.recover(this, re);
8591 }
8592 finally {
8593 exitRule();
8594 }
8595 return _localctx;
8596 }
8597
8598 public static class DefaultValueContext extends ParserRuleContext {
8599 public ElementValueContext elementValue() {
8600 return getRuleContext(ElementValueContext.class,0);
8601 }
8602 public DefaultValueContext(ParserRuleContext parent, int invokingState) {
8603 super(parent, invokingState);
8604 }
8605 @Override public int getRuleIndex() { return RULE_defaultValue; }
8606 @Override
8607 public void enterRule(ParseTreeListener listener) {
8608 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterDefaultValue(this);
8609 }
8610 @Override
8611 public void exitRule(ParseTreeListener listener) {
8612 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitDefaultValue(this);
8613 }
8614 }
8615
8616 public final DefaultValueContext defaultValue() throws RecognitionException {
8617 DefaultValueContext _localctx = new DefaultValueContext(_ctx, getState());
8618 enterRule(_localctx, 248, RULE_defaultValue);
8619 try {
8620 enterOuterAlt(_localctx, 1);
8621 {
8622 setState(1539);
8623 match(DEFAULT);
8624 setState(1540);
8625 elementValue();
8626 }
8627 }
8628 catch (RecognitionException re) {
8629 _localctx.exception = re;
8630 _errHandler.reportError(this, re);
8631 _errHandler.recover(this, re);
8632 }
8633 finally {
8634 exitRule();
8635 }
8636 return _localctx;
8637 }
8638
8639 public static class AnnotationContext extends ParserRuleContext {
8640 public NormalAnnotationContext normalAnnotation() {
8641 return getRuleContext(NormalAnnotationContext.class,0);
8642 }
8643 public MarkerAnnotationContext markerAnnotation() {
8644 return getRuleContext(MarkerAnnotationContext.class,0);
8645 }
8646 public SingleElementAnnotationContext singleElementAnnotation() {
8647 return getRuleContext(SingleElementAnnotationContext.class,0);
8648 }
8649 public AnnotationContext(ParserRuleContext parent, int invokingState) {
8650 super(parent, invokingState);
8651 }
8652 @Override public int getRuleIndex() { return RULE_annotation; }
8653 @Override
8654 public void enterRule(ParseTreeListener listener) {
8655 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterAnnotation(this);
8656 }
8657 @Override
8658 public void exitRule(ParseTreeListener listener) {
8659 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitAnnotation(this);
8660 }
8661 }
8662
8663 public final AnnotationContext annotation() throws RecognitionException {
8664 AnnotationContext _localctx = new AnnotationContext(_ctx, getState());
8665 enterRule(_localctx, 250, RULE_annotation);
8666 try {
8667 setState(1545);
8668 _errHandler.sync(this);
8669 switch ( getInterpreter().adaptivePredict(_input,154,_ctx) ) {
8670 case 1:
8671 enterOuterAlt(_localctx, 1);
8672 {
8673 setState(1542);
8674 normalAnnotation();
8675 }
8676 break;
8677 case 2:
8678 enterOuterAlt(_localctx, 2);
8679 {
8680 setState(1543);
8681 markerAnnotation();
8682 }
8683 break;
8684 case 3:
8685 enterOuterAlt(_localctx, 3);
8686 {
8687 setState(1544);
8688 singleElementAnnotation();
8689 }
8690 break;
8691 }
8692 }
8693 catch (RecognitionException re) {
8694 _localctx.exception = re;
8695 _errHandler.reportError(this, re);
8696 _errHandler.recover(this, re);
8697 }
8698 finally {
8699 exitRule();
8700 }
8701 return _localctx;
8702 }
8703
8704 public static class NormalAnnotationContext extends ParserRuleContext {
8705 public TypeNameContext typeName() {
8706 return getRuleContext(TypeNameContext.class,0);
8707 }
8708 public ElementValuePairListContext elementValuePairList() {
8709 return getRuleContext(ElementValuePairListContext.class,0);
8710 }
8711 public NormalAnnotationContext(ParserRuleContext parent, int invokingState) {
8712 super(parent, invokingState);
8713 }
8714 @Override public int getRuleIndex() { return RULE_normalAnnotation; }
8715 @Override
8716 public void enterRule(ParseTreeListener listener) {
8717 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterNormalAnnotation(this);
8718 }
8719 @Override
8720 public void exitRule(ParseTreeListener listener) {
8721 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitNormalAnnotation(this);
8722 }
8723 }
8724
8725 public final NormalAnnotationContext normalAnnotation() throws RecognitionException {
8726 NormalAnnotationContext _localctx = new NormalAnnotationContext(_ctx, getState());
8727 enterRule(_localctx, 252, RULE_normalAnnotation);
8728 int _la;
8729 try {
8730 enterOuterAlt(_localctx, 1);
8731 {
8732 setState(1547);
8733 match(AT);
8734 setState(1548);
8735 typeName();
8736 setState(1549);
8737 match(LPAREN);
8738 setState(1551);
8739 _errHandler.sync(this);
8740 _la = _input.LA(1);
8741 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) {
8742 {
8743 setState(1550);
8744 elementValuePairList();
8745 }
8746 }
8747
8748 setState(1553);
8749 match(RPAREN);
8750 }
8751 }
8752 catch (RecognitionException re) {
8753 _localctx.exception = re;
8754 _errHandler.reportError(this, re);
8755 _errHandler.recover(this, re);
8756 }
8757 finally {
8758 exitRule();
8759 }
8760 return _localctx;
8761 }
8762
8763 public static class ElementValuePairListContext extends ParserRuleContext {
8764 public List<ElementValuePairContext> elementValuePair() {
8765 return getRuleContexts(ElementValuePairContext.class);
8766 }
8767 public ElementValuePairContext elementValuePair(int i) {
8768 return getRuleContext(ElementValuePairContext.class,i);
8769 }
8770 public ElementValuePairListContext(ParserRuleContext parent, int invokingState) {
8771 super(parent, invokingState);
8772 }
8773 @Override public int getRuleIndex() { return RULE_elementValuePairList; }
8774 @Override
8775 public void enterRule(ParseTreeListener listener) {
8776 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterElementValuePairList(this);
8777 }
8778 @Override
8779 public void exitRule(ParseTreeListener listener) {
8780 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitElementValuePairList(this);
8781 }
8782 }
8783
8784 public final ElementValuePairListContext elementValuePairList() throws RecognitionException {
8785 ElementValuePairListContext _localctx = new ElementValuePairListContext(_ctx, getState());
8786 enterRule(_localctx, 254, RULE_elementValuePairList);
8787 int _la;
8788 try {
8789 enterOuterAlt(_localctx, 1);
8790 {
8791 setState(1555);
8792 elementValuePair();
8793 setState(1560);
8794 _errHandler.sync(this);
8795 _la = _input.LA(1);
8796 while (_la==COMMA) {
8797 {
8798 {
8799 setState(1556);
8800 match(COMMA);
8801 setState(1557);
8802 elementValuePair();
8803 }
8804 }
8805 setState(1562);
8806 _errHandler.sync(this);
8807 _la = _input.LA(1);
8808 }
8809 }
8810 }
8811 catch (RecognitionException re) {
8812 _localctx.exception = re;
8813 _errHandler.reportError(this, re);
8814 _errHandler.recover(this, re);
8815 }
8816 finally {
8817 exitRule();
8818 }
8819 return _localctx;
8820 }
8821
8822 public static class ElementValuePairContext extends ParserRuleContext {
8823 public IdentifierContext identifier() {
8824 return getRuleContext(IdentifierContext.class,0);
8825 }
8826 public ElementValueContext elementValue() {
8827 return getRuleContext(ElementValueContext.class,0);
8828 }
8829 public ElementValuePairContext(ParserRuleContext parent, int invokingState) {
8830 super(parent, invokingState);
8831 }
8832 @Override public int getRuleIndex() { return RULE_elementValuePair; }
8833 @Override
8834 public void enterRule(ParseTreeListener listener) {
8835 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterElementValuePair(this);
8836 }
8837 @Override
8838 public void exitRule(ParseTreeListener listener) {
8839 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitElementValuePair(this);
8840 }
8841 }
8842
8843 public final ElementValuePairContext elementValuePair() throws RecognitionException {
8844 ElementValuePairContext _localctx = new ElementValuePairContext(_ctx, getState());
8845 enterRule(_localctx, 256, RULE_elementValuePair);
8846 try {
8847 enterOuterAlt(_localctx, 1);
8848 {
8849 setState(1563);
8850 identifier();
8851 setState(1564);
8852 match(ASSIGN);
8853 setState(1565);
8854 elementValue();
8855 }
8856 }
8857 catch (RecognitionException re) {
8858 _localctx.exception = re;
8859 _errHandler.reportError(this, re);
8860 _errHandler.recover(this, re);
8861 }
8862 finally {
8863 exitRule();
8864 }
8865 return _localctx;
8866 }
8867
8868 public static class ElementValueContext extends ParserRuleContext {
8869 public ConditionalExpressionContext conditionalExpression() {
8870 return getRuleContext(ConditionalExpressionContext.class,0);
8871 }
8872 public ElementValueArrayInitializerContext elementValueArrayInitializer() {
8873 return getRuleContext(ElementValueArrayInitializerContext.class,0);
8874 }
8875 public AnnotationContext annotation() {
8876 return getRuleContext(AnnotationContext.class,0);
8877 }
8878 public ElementValueContext(ParserRuleContext parent, int invokingState) {
8879 super(parent, invokingState);
8880 }
8881 @Override public int getRuleIndex() { return RULE_elementValue; }
8882 @Override
8883 public void enterRule(ParseTreeListener listener) {
8884 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterElementValue(this);
8885 }
8886 @Override
8887 public void exitRule(ParseTreeListener listener) {
8888 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitElementValue(this);
8889 }
8890 }
8891
8892 public final ElementValueContext elementValue() throws RecognitionException {
8893 ElementValueContext _localctx = new ElementValueContext(_ctx, getState());
8894 enterRule(_localctx, 258, RULE_elementValue);
8895 try {
8896 setState(1570);
8897 _errHandler.sync(this);
8898 switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) {
8899 case 1:
8900 enterOuterAlt(_localctx, 1);
8901 {
8902 setState(1567);
8903 conditionalExpression();
8904 }
8905 break;
8906 case 2:
8907 enterOuterAlt(_localctx, 2);
8908 {
8909 setState(1568);
8910 elementValueArrayInitializer();
8911 }
8912 break;
8913 case 3:
8914 enterOuterAlt(_localctx, 3);
8915 {
8916 setState(1569);
8917 annotation();
8918 }
8919 break;
8920 }
8921 }
8922 catch (RecognitionException re) {
8923 _localctx.exception = re;
8924 _errHandler.reportError(this, re);
8925 _errHandler.recover(this, re);
8926 }
8927 finally {
8928 exitRule();
8929 }
8930 return _localctx;
8931 }
8932
8933 public static class ElementValueArrayInitializerContext extends ParserRuleContext {
8934 public ElementValueListContext elementValueList() {
8935 return getRuleContext(ElementValueListContext.class,0);
8936 }
8937 public ElementValueArrayInitializerContext(ParserRuleContext parent, int invokingState) {
8938 super(parent, invokingState);
8939 }
8940 @Override public int getRuleIndex() { return RULE_elementValueArrayInitializer; }
8941 @Override
8942 public void enterRule(ParseTreeListener listener) {
8943 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterElementValueArrayInitializer(this);
8944 }
8945 @Override
8946 public void exitRule(ParseTreeListener listener) {
8947 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitElementValueArrayInitializer(this);
8948 }
8949 }
8950
8951 public final ElementValueArrayInitializerContext elementValueArrayInitializer() throws RecognitionException {
8952 ElementValueArrayInitializerContext _localctx = new ElementValueArrayInitializerContext(_ctx, getState());
8953 enterRule(_localctx, 260, RULE_elementValueArrayInitializer);
8954 int _la;
8955 try {
8956 enterOuterAlt(_localctx, 1);
8957 {
8958 setState(1572);
8959 match(LBRACE);
8960 setState(1574);
8961 _errHandler.sync(this);
8962 _la = _input.LA(1);
8963 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 << (LBRACE - 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)) {
8964 {
8965 setState(1573);
8966 elementValueList();
8967 }
8968 }
8969
8970 setState(1577);
8971 _errHandler.sync(this);
8972 _la = _input.LA(1);
8973 if (_la==COMMA) {
8974 {
8975 setState(1576);
8976 match(COMMA);
8977 }
8978 }
8979
8980 setState(1579);
8981 match(RBRACE);
8982 }
8983 }
8984 catch (RecognitionException re) {
8985 _localctx.exception = re;
8986 _errHandler.reportError(this, re);
8987 _errHandler.recover(this, re);
8988 }
8989 finally {
8990 exitRule();
8991 }
8992 return _localctx;
8993 }
8994
8995 public static class ElementValueListContext extends ParserRuleContext {
8996 public List<ElementValueContext> elementValue() {
8997 return getRuleContexts(ElementValueContext.class);
8998 }
8999 public ElementValueContext elementValue(int i) {
9000 return getRuleContext(ElementValueContext.class,i);
9001 }
9002 public ElementValueListContext(ParserRuleContext parent, int invokingState) {
9003 super(parent, invokingState);
9004 }
9005 @Override public int getRuleIndex() { return RULE_elementValueList; }
9006 @Override
9007 public void enterRule(ParseTreeListener listener) {
9008 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterElementValueList(this);
9009 }
9010 @Override
9011 public void exitRule(ParseTreeListener listener) {
9012 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitElementValueList(this);
9013 }
9014 }
9015
9016 public final ElementValueListContext elementValueList() throws RecognitionException {
9017 ElementValueListContext _localctx = new ElementValueListContext(_ctx, getState());
9018 enterRule(_localctx, 262, RULE_elementValueList);
9019 try {
9020 int _alt;
9021 enterOuterAlt(_localctx, 1);
9022 {
9023 setState(1581);
9024 elementValue();
9025 setState(1586);
9026 _errHandler.sync(this);
9027 _alt = getInterpreter().adaptivePredict(_input,160,_ctx);
9028 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
9029 if ( _alt==1 ) {
9030 {
9031 {
9032 setState(1582);
9033 match(COMMA);
9034 setState(1583);
9035 elementValue();
9036 }
9037 }
9038 }
9039 setState(1588);
9040 _errHandler.sync(this);
9041 _alt = getInterpreter().adaptivePredict(_input,160,_ctx);
9042 }
9043 }
9044 }
9045 catch (RecognitionException re) {
9046 _localctx.exception = re;
9047 _errHandler.reportError(this, re);
9048 _errHandler.recover(this, re);
9049 }
9050 finally {
9051 exitRule();
9052 }
9053 return _localctx;
9054 }
9055
9056 public static class MarkerAnnotationContext extends ParserRuleContext {
9057 public TypeNameContext typeName() {
9058 return getRuleContext(TypeNameContext.class,0);
9059 }
9060 public MarkerAnnotationContext(ParserRuleContext parent, int invokingState) {
9061 super(parent, invokingState);
9062 }
9063 @Override public int getRuleIndex() { return RULE_markerAnnotation; }
9064 @Override
9065 public void enterRule(ParseTreeListener listener) {
9066 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterMarkerAnnotation(this);
9067 }
9068 @Override
9069 public void exitRule(ParseTreeListener listener) {
9070 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitMarkerAnnotation(this);
9071 }
9072 }
9073
9074 public final MarkerAnnotationContext markerAnnotation() throws RecognitionException {
9075 MarkerAnnotationContext _localctx = new MarkerAnnotationContext(_ctx, getState());
9076 enterRule(_localctx, 264, RULE_markerAnnotation);
9077 try {
9078 enterOuterAlt(_localctx, 1);
9079 {
9080 setState(1589);
9081 match(AT);
9082 setState(1590);
9083 typeName();
9084 }
9085 }
9086 catch (RecognitionException re) {
9087 _localctx.exception = re;
9088 _errHandler.reportError(this, re);
9089 _errHandler.recover(this, re);
9090 }
9091 finally {
9092 exitRule();
9093 }
9094 return _localctx;
9095 }
9096
9097 public static class SingleElementAnnotationContext extends ParserRuleContext {
9098 public TypeNameContext typeName() {
9099 return getRuleContext(TypeNameContext.class,0);
9100 }
9101 public ElementValueContext elementValue() {
9102 return getRuleContext(ElementValueContext.class,0);
9103 }
9104 public SingleElementAnnotationContext(ParserRuleContext parent, int invokingState) {
9105 super(parent, invokingState);
9106 }
9107 @Override public int getRuleIndex() { return RULE_singleElementAnnotation; }
9108 @Override
9109 public void enterRule(ParseTreeListener listener) {
9110 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterSingleElementAnnotation(this);
9111 }
9112 @Override
9113 public void exitRule(ParseTreeListener listener) {
9114 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitSingleElementAnnotation(this);
9115 }
9116 }
9117
9118 public final SingleElementAnnotationContext singleElementAnnotation() throws RecognitionException {
9119 SingleElementAnnotationContext _localctx = new SingleElementAnnotationContext(_ctx, getState());
9120 enterRule(_localctx, 266, RULE_singleElementAnnotation);
9121 try {
9122 enterOuterAlt(_localctx, 1);
9123 {
9124 setState(1592);
9125 match(AT);
9126 setState(1593);
9127 typeName();
9128 setState(1594);
9129 match(LPAREN);
9130 setState(1595);
9131 elementValue();
9132 setState(1596);
9133 match(RPAREN);
9134 }
9135 }
9136 catch (RecognitionException re) {
9137 _localctx.exception = re;
9138 _errHandler.reportError(this, re);
9139 _errHandler.recover(this, re);
9140 }
9141 finally {
9142 exitRule();
9143 }
9144 return _localctx;
9145 }
9146
9147 public static class ArrayInitializerContext extends ParserRuleContext {
9148 public VariableInitializerListContext variableInitializerList() {
9149 return getRuleContext(VariableInitializerListContext.class,0);
9150 }
9151 public ArrayInitializerContext(ParserRuleContext parent, int invokingState) {
9152 super(parent, invokingState);
9153 }
9154 @Override public int getRuleIndex() { return RULE_arrayInitializer; }
9155 @Override
9156 public void enterRule(ParseTreeListener listener) {
9157 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterArrayInitializer(this);
9158 }
9159 @Override
9160 public void exitRule(ParseTreeListener listener) {
9161 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitArrayInitializer(this);
9162 }
9163 }
9164
9165 public final ArrayInitializerContext arrayInitializer() throws RecognitionException {
9166 ArrayInitializerContext _localctx = new ArrayInitializerContext(_ctx, getState());
9167 enterRule(_localctx, 268, RULE_arrayInitializer);
9168 int _la;
9169 try {
9170 enterOuterAlt(_localctx, 1);
9171 {
9172 setState(1598);
9173 match(LBRACE);
9174 setState(1600);
9175 _errHandler.sync(this);
9176 _la = _input.LA(1);
9177 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 << (LBRACE - 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)) {
9178 {
9179 setState(1599);
9180 variableInitializerList();
9181 }
9182 }
9183
9184 setState(1603);
9185 _errHandler.sync(this);
9186 _la = _input.LA(1);
9187 if (_la==COMMA) {
9188 {
9189 setState(1602);
9190 match(COMMA);
9191 }
9192 }
9193
9194 setState(1605);
9195 match(RBRACE);
9196 }
9197 }
9198 catch (RecognitionException re) {
9199 _localctx.exception = re;
9200 _errHandler.reportError(this, re);
9201 _errHandler.recover(this, re);
9202 }
9203 finally {
9204 exitRule();
9205 }
9206 return _localctx;
9207 }
9208
9209 public static class VariableInitializerListContext extends ParserRuleContext {
9210 public List<VariableInitializerContext> variableInitializer() {
9211 return getRuleContexts(VariableInitializerContext.class);
9212 }
9213 public VariableInitializerContext variableInitializer(int i) {
9214 return getRuleContext(VariableInitializerContext.class,i);
9215 }
9216 public VariableInitializerListContext(ParserRuleContext parent, int invokingState) {
9217 super(parent, invokingState);
9218 }
9219 @Override public int getRuleIndex() { return RULE_variableInitializerList; }
9220 @Override
9221 public void enterRule(ParseTreeListener listener) {
9222 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterVariableInitializerList(this);
9223 }
9224 @Override
9225 public void exitRule(ParseTreeListener listener) {
9226 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitVariableInitializerList(this);
9227 }
9228 }
9229
9230 public final VariableInitializerListContext variableInitializerList() throws RecognitionException {
9231 VariableInitializerListContext _localctx = new VariableInitializerListContext(_ctx, getState());
9232 enterRule(_localctx, 270, RULE_variableInitializerList);
9233 try {
9234 int _alt;
9235 enterOuterAlt(_localctx, 1);
9236 {
9237 setState(1607);
9238 variableInitializer();
9239 setState(1612);
9240 _errHandler.sync(this);
9241 _alt = getInterpreter().adaptivePredict(_input,163,_ctx);
9242 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
9243 if ( _alt==1 ) {
9244 {
9245 {
9246 setState(1608);
9247 match(COMMA);
9248 setState(1609);
9249 variableInitializer();
9250 }
9251 }
9252 }
9253 setState(1614);
9254 _errHandler.sync(this);
9255 _alt = getInterpreter().adaptivePredict(_input,163,_ctx);
9256 }
9257 }
9258 }
9259 catch (RecognitionException re) {
9260 _localctx.exception = re;
9261 _errHandler.reportError(this, re);
9262 _errHandler.recover(this, re);
9263 }
9264 finally {
9265 exitRule();
9266 }
9267 return _localctx;
9268 }
9269
9270 public static class BlockContext extends ParserRuleContext {
9271 public BlockStatementsContext blockStatements() {
9272 return getRuleContext(BlockStatementsContext.class,0);
9273 }
9274 public BlockContext(ParserRuleContext parent, int invokingState) {
9275 super(parent, invokingState);
9276 }
9277 @Override public int getRuleIndex() { return RULE_block; }
9278 @Override
9279 public void enterRule(ParseTreeListener listener) {
9280 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterBlock(this);
9281 }
9282 @Override
9283 public void exitRule(ParseTreeListener listener) {
9284 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitBlock(this);
9285 }
9286 }
9287
9288 public final BlockContext block() throws RecognitionException {
9289 BlockContext _localctx = new BlockContext(_ctx, getState());
9290 enterRule(_localctx, 272, RULE_block);
9291 int _la;
9292 try {
9293 enterOuterAlt(_localctx, 1);
9294 {
9295 setState(1615);
9296 match(LBRACE);
9297 setState(1617);
9298 _errHandler.sync(this);
9299 _la = _input.LA(1);
9300 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)) {
9301 {
9302 setState(1616);
9303 blockStatements();
9304 }
9305 }
9306
9307 setState(1619);
9308 match(RBRACE);
9309 }
9310 }
9311 catch (RecognitionException re) {
9312 _localctx.exception = re;
9313 _errHandler.reportError(this, re);
9314 _errHandler.recover(this, re);
9315 }
9316 finally {
9317 exitRule();
9318 }
9319 return _localctx;
9320 }
9321
9322 public static class BlockStatementsContext extends ParserRuleContext {
9323 public List<BlockStatementContext> blockStatement() {
9324 return getRuleContexts(BlockStatementContext.class);
9325 }
9326 public BlockStatementContext blockStatement(int i) {
9327 return getRuleContext(BlockStatementContext.class,i);
9328 }
9329 public BlockStatementsContext(ParserRuleContext parent, int invokingState) {
9330 super(parent, invokingState);
9331 }
9332 @Override public int getRuleIndex() { return RULE_blockStatements; }
9333 @Override
9334 public void enterRule(ParseTreeListener listener) {
9335 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterBlockStatements(this);
9336 }
9337 @Override
9338 public void exitRule(ParseTreeListener listener) {
9339 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitBlockStatements(this);
9340 }
9341 }
9342
9343 public final BlockStatementsContext blockStatements() throws RecognitionException {
9344 BlockStatementsContext _localctx = new BlockStatementsContext(_ctx, getState());
9345 enterRule(_localctx, 274, RULE_blockStatements);
9346 int _la;
9347 try {
9348 enterOuterAlt(_localctx, 1);
9349 {
9350 setState(1622);
9351 _errHandler.sync(this);
9352 _la = _input.LA(1);
9353 do {
9354 {
9355 {
9356 setState(1621);
9357 blockStatement();
9358 }
9359 }
9360 setState(1624);
9361 _errHandler.sync(this);
9362 _la = _input.LA(1);
9363 } 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 << 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) );
9364 }
9365 }
9366 catch (RecognitionException re) {
9367 _localctx.exception = re;
9368 _errHandler.reportError(this, re);
9369 _errHandler.recover(this, re);
9370 }
9371 finally {
9372 exitRule();
9373 }
9374 return _localctx;
9375 }
9376
9377 public static class BlockStatementContext extends ParserRuleContext {
9378 public LocalVariableDeclarationStatementContext localVariableDeclarationStatement() {
9379 return getRuleContext(LocalVariableDeclarationStatementContext.class,0);
9380 }
9381 public ClassDeclarationContext classDeclaration() {
9382 return getRuleContext(ClassDeclarationContext.class,0);
9383 }
9384 public StatementContext statement() {
9385 return getRuleContext(StatementContext.class,0);
9386 }
9387 public BlockStatementContext(ParserRuleContext parent, int invokingState) {
9388 super(parent, invokingState);
9389 }
9390 @Override public int getRuleIndex() { return RULE_blockStatement; }
9391 @Override
9392 public void enterRule(ParseTreeListener listener) {
9393 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterBlockStatement(this);
9394 }
9395 @Override
9396 public void exitRule(ParseTreeListener listener) {
9397 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitBlockStatement(this);
9398 }
9399 }
9400
9401 public final BlockStatementContext blockStatement() throws RecognitionException {
9402 BlockStatementContext _localctx = new BlockStatementContext(_ctx, getState());
9403 enterRule(_localctx, 276, RULE_blockStatement);
9404 try {
9405 setState(1629);
9406 _errHandler.sync(this);
9407 switch ( getInterpreter().adaptivePredict(_input,166,_ctx) ) {
9408 case 1:
9409 enterOuterAlt(_localctx, 1);
9410 {
9411 setState(1626);
9412 localVariableDeclarationStatement();
9413 }
9414 break;
9415 case 2:
9416 enterOuterAlt(_localctx, 2);
9417 {
9418 setState(1627);
9419 classDeclaration();
9420 }
9421 break;
9422 case 3:
9423 enterOuterAlt(_localctx, 3);
9424 {
9425 setState(1628);
9426 statement();
9427 }
9428 break;
9429 }
9430 }
9431 catch (RecognitionException re) {
9432 _localctx.exception = re;
9433 _errHandler.reportError(this, re);
9434 _errHandler.recover(this, re);
9435 }
9436 finally {
9437 exitRule();
9438 }
9439 return _localctx;
9440 }
9441
9442 public static class LocalVariableDeclarationStatementContext extends ParserRuleContext {
9443 public LocalVariableDeclarationContext localVariableDeclaration() {
9444 return getRuleContext(LocalVariableDeclarationContext.class,0);
9445 }
9446 public LocalVariableDeclarationStatementContext(ParserRuleContext parent, int invokingState) {
9447 super(parent, invokingState);
9448 }
9449 @Override public int getRuleIndex() { return RULE_localVariableDeclarationStatement; }
9450 @Override
9451 public void enterRule(ParseTreeListener listener) {
9452 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterLocalVariableDeclarationStatement(this);
9453 }
9454 @Override
9455 public void exitRule(ParseTreeListener listener) {
9456 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitLocalVariableDeclarationStatement(this);
9457 }
9458 }
9459
9460 public final LocalVariableDeclarationStatementContext localVariableDeclarationStatement() throws RecognitionException {
9461 LocalVariableDeclarationStatementContext _localctx = new LocalVariableDeclarationStatementContext(_ctx, getState());
9462 enterRule(_localctx, 278, RULE_localVariableDeclarationStatement);
9463 try {
9464 enterOuterAlt(_localctx, 1);
9465 {
9466 setState(1631);
9467 localVariableDeclaration();
9468 setState(1632);
9469 match(SEMI);
9470 }
9471 }
9472 catch (RecognitionException re) {
9473 _localctx.exception = re;
9474 _errHandler.reportError(this, re);
9475 _errHandler.recover(this, re);
9476 }
9477 finally {
9478 exitRule();
9479 }
9480 return _localctx;
9481 }
9482
9483 public static class LocalVariableDeclarationContext extends ParserRuleContext {
9484 public UnannTypeContext unannType() {
9485 return getRuleContext(UnannTypeContext.class,0);
9486 }
9487 public VariableDeclaratorListContext variableDeclaratorList() {
9488 return getRuleContext(VariableDeclaratorListContext.class,0);
9489 }
9490 public List<VariableModifierContext> variableModifier() {
9491 return getRuleContexts(VariableModifierContext.class);
9492 }
9493 public VariableModifierContext variableModifier(int i) {
9494 return getRuleContext(VariableModifierContext.class,i);
9495 }
9496 public LocalVariableDeclarationContext(ParserRuleContext parent, int invokingState) {
9497 super(parent, invokingState);
9498 }
9499 @Override public int getRuleIndex() { return RULE_localVariableDeclaration; }
9500 @Override
9501 public void enterRule(ParseTreeListener listener) {
9502 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterLocalVariableDeclaration(this);
9503 }
9504 @Override
9505 public void exitRule(ParseTreeListener listener) {
9506 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitLocalVariableDeclaration(this);
9507 }
9508 }
9509
9510 public final LocalVariableDeclarationContext localVariableDeclaration() throws RecognitionException {
9511 LocalVariableDeclarationContext _localctx = new LocalVariableDeclarationContext(_ctx, getState());
9512 enterRule(_localctx, 280, RULE_localVariableDeclaration);
9513 int _la;
9514 try {
9515 enterOuterAlt(_localctx, 1);
9516 {
9517 setState(1637);
9518 _errHandler.sync(this);
9519 _la = _input.LA(1);
9520 while (_la==FINAL || _la==AT) {
9521 {
9522 {
9523 setState(1634);
9524 variableModifier();
9525 }
9526 }
9527 setState(1639);
9528 _errHandler.sync(this);
9529 _la = _input.LA(1);
9530 }
9531 setState(1640);
9532 unannType();
9533 setState(1641);
9534 variableDeclaratorList();
9535 }
9536 }
9537 catch (RecognitionException re) {
9538 _localctx.exception = re;
9539 _errHandler.reportError(this, re);
9540 _errHandler.recover(this, re);
9541 }
9542 finally {
9543 exitRule();
9544 }
9545 return _localctx;
9546 }
9547
9548 public static class StatementContext extends ParserRuleContext {
9549 public StatementWithoutTrailingSubstatementContext statementWithoutTrailingSubstatement() {
9550 return getRuleContext(StatementWithoutTrailingSubstatementContext.class,0);
9551 }
9552 public LabeledStatementContext labeledStatement() {
9553 return getRuleContext(LabeledStatementContext.class,0);
9554 }
9555 public IfThenStatementContext ifThenStatement() {
9556 return getRuleContext(IfThenStatementContext.class,0);
9557 }
9558 public IfThenElseStatementContext ifThenElseStatement() {
9559 return getRuleContext(IfThenElseStatementContext.class,0);
9560 }
9561 public WhileStatementContext whileStatement() {
9562 return getRuleContext(WhileStatementContext.class,0);
9563 }
9564 public ForStatementContext forStatement() {
9565 return getRuleContext(ForStatementContext.class,0);
9566 }
9567 public StatementContext(ParserRuleContext parent, int invokingState) {
9568 super(parent, invokingState);
9569 }
9570 @Override public int getRuleIndex() { return RULE_statement; }
9571 @Override
9572 public void enterRule(ParseTreeListener listener) {
9573 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterStatement(this);
9574 }
9575 @Override
9576 public void exitRule(ParseTreeListener listener) {
9577 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitStatement(this);
9578 }
9579 }
9580
9581 public final StatementContext statement() throws RecognitionException {
9582 StatementContext _localctx = new StatementContext(_ctx, getState());
9583 enterRule(_localctx, 282, RULE_statement);
9584 try {
9585 setState(1649);
9586 _errHandler.sync(this);
9587 switch ( getInterpreter().adaptivePredict(_input,168,_ctx) ) {
9588 case 1:
9589 enterOuterAlt(_localctx, 1);
9590 {
9591 setState(1643);
9592 statementWithoutTrailingSubstatement();
9593 }
9594 break;
9595 case 2:
9596 enterOuterAlt(_localctx, 2);
9597 {
9598 setState(1644);
9599 labeledStatement();
9600 }
9601 break;
9602 case 3:
9603 enterOuterAlt(_localctx, 3);
9604 {
9605 setState(1645);
9606 ifThenStatement();
9607 }
9608 break;
9609 case 4:
9610 enterOuterAlt(_localctx, 4);
9611 {
9612 setState(1646);
9613 ifThenElseStatement();
9614 }
9615 break;
9616 case 5:
9617 enterOuterAlt(_localctx, 5);
9618 {
9619 setState(1647);
9620 whileStatement();
9621 }
9622 break;
9623 case 6:
9624 enterOuterAlt(_localctx, 6);
9625 {
9626 setState(1648);
9627 forStatement();
9628 }
9629 break;
9630 }
9631 }
9632 catch (RecognitionException re) {
9633 _localctx.exception = re;
9634 _errHandler.reportError(this, re);
9635 _errHandler.recover(this, re);
9636 }
9637 finally {
9638 exitRule();
9639 }
9640 return _localctx;
9641 }
9642
9643 public static class StatementNoShortIfContext extends ParserRuleContext {
9644 public StatementWithoutTrailingSubstatementContext statementWithoutTrailingSubstatement() {
9645 return getRuleContext(StatementWithoutTrailingSubstatementContext.class,0);
9646 }
9647 public LabeledStatementNoShortIfContext labeledStatementNoShortIf() {
9648 return getRuleContext(LabeledStatementNoShortIfContext.class,0);
9649 }
9650 public IfThenElseStatementNoShortIfContext ifThenElseStatementNoShortIf() {
9651 return getRuleContext(IfThenElseStatementNoShortIfContext.class,0);
9652 }
9653 public WhileStatementNoShortIfContext whileStatementNoShortIf() {
9654 return getRuleContext(WhileStatementNoShortIfContext.class,0);
9655 }
9656 public ForStatementNoShortIfContext forStatementNoShortIf() {
9657 return getRuleContext(ForStatementNoShortIfContext.class,0);
9658 }
9659 public StatementNoShortIfContext(ParserRuleContext parent, int invokingState) {
9660 super(parent, invokingState);
9661 }
9662 @Override public int getRuleIndex() { return RULE_statementNoShortIf; }
9663 @Override
9664 public void enterRule(ParseTreeListener listener) {
9665 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterStatementNoShortIf(this);
9666 }
9667 @Override
9668 public void exitRule(ParseTreeListener listener) {
9669 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitStatementNoShortIf(this);
9670 }
9671 }
9672
9673 public final StatementNoShortIfContext statementNoShortIf() throws RecognitionException {
9674 StatementNoShortIfContext _localctx = new StatementNoShortIfContext(_ctx, getState());
9675 enterRule(_localctx, 284, RULE_statementNoShortIf);
9676 try {
9677 setState(1656);
9678 _errHandler.sync(this);
9679 switch ( getInterpreter().adaptivePredict(_input,169,_ctx) ) {
9680 case 1:
9681 enterOuterAlt(_localctx, 1);
9682 {
9683 setState(1651);
9684 statementWithoutTrailingSubstatement();
9685 }
9686 break;
9687 case 2:
9688 enterOuterAlt(_localctx, 2);
9689 {
9690 setState(1652);
9691 labeledStatementNoShortIf();
9692 }
9693 break;
9694 case 3:
9695 enterOuterAlt(_localctx, 3);
9696 {
9697 setState(1653);
9698 ifThenElseStatementNoShortIf();
9699 }
9700 break;
9701 case 4:
9702 enterOuterAlt(_localctx, 4);
9703 {
9704 setState(1654);
9705 whileStatementNoShortIf();
9706 }
9707 break;
9708 case 5:
9709 enterOuterAlt(_localctx, 5);
9710 {
9711 setState(1655);
9712 forStatementNoShortIf();
9713 }
9714 break;
9715 }
9716 }
9717 catch (RecognitionException re) {
9718 _localctx.exception = re;
9719 _errHandler.reportError(this, re);
9720 _errHandler.recover(this, re);
9721 }
9722 finally {
9723 exitRule();
9724 }
9725 return _localctx;
9726 }
9727
9728 public static class StatementWithoutTrailingSubstatementContext extends ParserRuleContext {
9729 public BlockContext block() {
9730 return getRuleContext(BlockContext.class,0);
9731 }
9732 public EmptyStatementContext emptyStatement() {
9733 return getRuleContext(EmptyStatementContext.class,0);
9734 }
9735 public ExpressionStatementContext expressionStatement() {
9736 return getRuleContext(ExpressionStatementContext.class,0);
9737 }
9738 public AssertStatementContext assertStatement() {
9739 return getRuleContext(AssertStatementContext.class,0);
9740 }
9741 public SwitchStatementContext switchStatement() {
9742 return getRuleContext(SwitchStatementContext.class,0);
9743 }
9744 public DoStatementContext doStatement() {
9745 return getRuleContext(DoStatementContext.class,0);
9746 }
9747 public BreakStatementContext breakStatement() {
9748 return getRuleContext(BreakStatementContext.class,0);
9749 }
9750 public ContinueStatementContext continueStatement() {
9751 return getRuleContext(ContinueStatementContext.class,0);
9752 }
9753 public ReturnStatementContext returnStatement() {
9754 return getRuleContext(ReturnStatementContext.class,0);
9755 }
9756 public SynchronizedStatementContext synchronizedStatement() {
9757 return getRuleContext(SynchronizedStatementContext.class,0);
9758 }
9759 public ThrowStatementContext throwStatement() {
9760 return getRuleContext(ThrowStatementContext.class,0);
9761 }
9762 public TryStatementContext tryStatement() {
9763 return getRuleContext(TryStatementContext.class,0);
9764 }
9765 public StatementWithoutTrailingSubstatementContext(ParserRuleContext parent, int invokingState) {
9766 super(parent, invokingState);
9767 }
9768 @Override public int getRuleIndex() { return RULE_statementWithoutTrailingSubstatement; }
9769 @Override
9770 public void enterRule(ParseTreeListener listener) {
9771 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterStatementWithoutTrailingSubstatement(this);
9772 }
9773 @Override
9774 public void exitRule(ParseTreeListener listener) {
9775 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitStatementWithoutTrailingSubstatement(this);
9776 }
9777 }
9778
9779 public final StatementWithoutTrailingSubstatementContext statementWithoutTrailingSubstatement() throws RecognitionException {
9780 StatementWithoutTrailingSubstatementContext _localctx = new StatementWithoutTrailingSubstatementContext(_ctx, getState());
9781 enterRule(_localctx, 286, RULE_statementWithoutTrailingSubstatement);
9782 try {
9783 setState(1670);
9784 _errHandler.sync(this);
9785 switch (_input.LA(1)) {
9786 case LBRACE:
9787 enterOuterAlt(_localctx, 1);
9788 {
9789 setState(1658);
9790 block();
9791 }
9792 break;
9793 case SEMI:
9794 enterOuterAlt(_localctx, 2);
9795 {
9796 setState(1659);
9797 emptyStatement();
9798 }
9799 break;
9800 case T__0:
9801 case T__1:
9802 case T__2:
9803 case T__3:
9804 case T__4:
9805 case T__5:
9806 case T__6:
9807 case T__7:
9808 case T__8:
9809 case BOOLEAN:
9810 case BYTE:
9811 case CHAR:
9812 case DOUBLE:
9813 case FLOAT:
9814 case INT:
9815 case LONG:
9816 case NEW:
9817 case SHORT:
9818 case SUPER:
9819 case THIS:
9820 case VOID:
9821 case IntegerLiteral:
9822 case FloatingPointLiteral:
9823 case BooleanLiteral:
9824 case CharacterLiteral:
9825 case StringLiteral:
9826 case NullLiteral:
9827 case LPAREN:
9828 case AT:
9829 case INC:
9830 case DEC:
9831 case Identifier:
9832 enterOuterAlt(_localctx, 3);
9833 {
9834 setState(1660);
9835 expressionStatement();
9836 }
9837 break;
9838 case ASSERT:
9839 enterOuterAlt(_localctx, 4);
9840 {
9841 setState(1661);
9842 assertStatement();
9843 }
9844 break;
9845 case SWITCH:
9846 enterOuterAlt(_localctx, 5);
9847 {
9848 setState(1662);
9849 switchStatement();
9850 }
9851 break;
9852 case DO:
9853 enterOuterAlt(_localctx, 6);
9854 {
9855 setState(1663);
9856 doStatement();
9857 }
9858 break;
9859 case BREAK:
9860 enterOuterAlt(_localctx, 7);
9861 {
9862 setState(1664);
9863 breakStatement();
9864 }
9865 break;
9866 case CONTINUE:
9867 enterOuterAlt(_localctx, 8);
9868 {
9869 setState(1665);
9870 continueStatement();
9871 }
9872 break;
9873 case RETURN:
9874 enterOuterAlt(_localctx, 9);
9875 {
9876 setState(1666);
9877 returnStatement();
9878 }
9879 break;
9880 case SYNCHRONIZED:
9881 enterOuterAlt(_localctx, 10);
9882 {
9883 setState(1667);
9884 synchronizedStatement();
9885 }
9886 break;
9887 case THROW:
9888 enterOuterAlt(_localctx, 11);
9889 {
9890 setState(1668);
9891 throwStatement();
9892 }
9893 break;
9894 case TRY:
9895 enterOuterAlt(_localctx, 12);
9896 {
9897 setState(1669);
9898 tryStatement();
9899 }
9900 break;
9901 default:
9902 throw new NoViableAltException(this);
9903 }
9904 }
9905 catch (RecognitionException re) {
9906 _localctx.exception = re;
9907 _errHandler.reportError(this, re);
9908 _errHandler.recover(this, re);
9909 }
9910 finally {
9911 exitRule();
9912 }
9913 return _localctx;
9914 }
9915
9916 public static class EmptyStatementContext extends ParserRuleContext {
9917 public EmptyStatementContext(ParserRuleContext parent, int invokingState) {
9918 super(parent, invokingState);
9919 }
9920 @Override public int getRuleIndex() { return RULE_emptyStatement; }
9921 @Override
9922 public void enterRule(ParseTreeListener listener) {
9923 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterEmptyStatement(this);
9924 }
9925 @Override
9926 public void exitRule(ParseTreeListener listener) {
9927 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitEmptyStatement(this);
9928 }
9929 }
9930
9931 public final EmptyStatementContext emptyStatement() throws RecognitionException {
9932 EmptyStatementContext _localctx = new EmptyStatementContext(_ctx, getState());
9933 enterRule(_localctx, 288, RULE_emptyStatement);
9934 try {
9935 enterOuterAlt(_localctx, 1);
9936 {
9937 setState(1672);
9938 match(SEMI);
9939 }
9940 }
9941 catch (RecognitionException re) {
9942 _localctx.exception = re;
9943 _errHandler.reportError(this, re);
9944 _errHandler.recover(this, re);
9945 }
9946 finally {
9947 exitRule();
9948 }
9949 return _localctx;
9950 }
9951
9952 public static class LabeledStatementContext extends ParserRuleContext {
9953 public IdentifierContext identifier() {
9954 return getRuleContext(IdentifierContext.class,0);
9955 }
9956 public StatementContext statement() {
9957 return getRuleContext(StatementContext.class,0);
9958 }
9959 public LabeledStatementContext(ParserRuleContext parent, int invokingState) {
9960 super(parent, invokingState);
9961 }
9962 @Override public int getRuleIndex() { return RULE_labeledStatement; }
9963 @Override
9964 public void enterRule(ParseTreeListener listener) {
9965 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterLabeledStatement(this);
9966 }
9967 @Override
9968 public void exitRule(ParseTreeListener listener) {
9969 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitLabeledStatement(this);
9970 }
9971 }
9972
9973 public final LabeledStatementContext labeledStatement() throws RecognitionException {
9974 LabeledStatementContext _localctx = new LabeledStatementContext(_ctx, getState());
9975 enterRule(_localctx, 290, RULE_labeledStatement);
9976 try {
9977 enterOuterAlt(_localctx, 1);
9978 {
9979 setState(1674);
9980 identifier();
9981 setState(1675);
9982 match(COLON);
9983 setState(1676);
9984 statement();
9985 }
9986 }
9987 catch (RecognitionException re) {
9988 _localctx.exception = re;
9989 _errHandler.reportError(this, re);
9990 _errHandler.recover(this, re);
9991 }
9992 finally {
9993 exitRule();
9994 }
9995 return _localctx;
9996 }
9997
9998 public static class LabeledStatementNoShortIfContext extends ParserRuleContext {
9999 public IdentifierContext identifier() {
10000 return getRuleContext(IdentifierContext.class,0);
10001 }
10002 public StatementNoShortIfContext statementNoShortIf() {
10003 return getRuleContext(StatementNoShortIfContext.class,0);
10004 }
10005 public LabeledStatementNoShortIfContext(ParserRuleContext parent, int invokingState) {
10006 super(parent, invokingState);
10007 }
10008 @Override public int getRuleIndex() { return RULE_labeledStatementNoShortIf; }
10009 @Override
10010 public void enterRule(ParseTreeListener listener) {
10011 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterLabeledStatementNoShortIf(this);
10012 }
10013 @Override
10014 public void exitRule(ParseTreeListener listener) {
10015 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitLabeledStatementNoShortIf(this);
10016 }
10017 }
10018
10019 public final LabeledStatementNoShortIfContext labeledStatementNoShortIf() throws RecognitionException {
10020 LabeledStatementNoShortIfContext _localctx = new LabeledStatementNoShortIfContext(_ctx, getState());
10021 enterRule(_localctx, 292, RULE_labeledStatementNoShortIf);
10022 try {
10023 enterOuterAlt(_localctx, 1);
10024 {
10025 setState(1678);
10026 identifier();
10027 setState(1679);
10028 match(COLON);
10029 setState(1680);
10030 statementNoShortIf();
10031 }
10032 }
10033 catch (RecognitionException re) {
10034 _localctx.exception = re;
10035 _errHandler.reportError(this, re);
10036 _errHandler.recover(this, re);
10037 }
10038 finally {
10039 exitRule();
10040 }
10041 return _localctx;
10042 }
10043
10044 public static class ExpressionStatementContext extends ParserRuleContext {
10045 public StatementExpressionContext statementExpression() {
10046 return getRuleContext(StatementExpressionContext.class,0);
10047 }
10048 public ExpressionStatementContext(ParserRuleContext parent, int invokingState) {
10049 super(parent, invokingState);
10050 }
10051 @Override public int getRuleIndex() { return RULE_expressionStatement; }
10052 @Override
10053 public void enterRule(ParseTreeListener listener) {
10054 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterExpressionStatement(this);
10055 }
10056 @Override
10057 public void exitRule(ParseTreeListener listener) {
10058 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitExpressionStatement(this);
10059 }
10060 }
10061
10062 public final ExpressionStatementContext expressionStatement() throws RecognitionException {
10063 ExpressionStatementContext _localctx = new ExpressionStatementContext(_ctx, getState());
10064 enterRule(_localctx, 294, RULE_expressionStatement);
10065 try {
10066 enterOuterAlt(_localctx, 1);
10067 {
10068 setState(1682);
10069 statementExpression();
10070 setState(1683);
10071 match(SEMI);
10072 }
10073 }
10074 catch (RecognitionException re) {
10075 _localctx.exception = re;
10076 _errHandler.reportError(this, re);
10077 _errHandler.recover(this, re);
10078 }
10079 finally {
10080 exitRule();
10081 }
10082 return _localctx;
10083 }
10084
10085 public static class StatementExpressionContext extends ParserRuleContext {
10086 public AssignmentContext assignment() {
10087 return getRuleContext(AssignmentContext.class,0);
10088 }
10089 public PreIncrementExpressionContext preIncrementExpression() {
10090 return getRuleContext(PreIncrementExpressionContext.class,0);
10091 }
10092 public PreDecrementExpressionContext preDecrementExpression() {
10093 return getRuleContext(PreDecrementExpressionContext.class,0);
10094 }
10095 public PostIncrementExpressionContext postIncrementExpression() {
10096 return getRuleContext(PostIncrementExpressionContext.class,0);
10097 }
10098 public PostDecrementExpressionContext postDecrementExpression() {
10099 return getRuleContext(PostDecrementExpressionContext.class,0);
10100 }
10101 public MethodInvocationContext methodInvocation() {
10102 return getRuleContext(MethodInvocationContext.class,0);
10103 }
10104 public ClassInstanceCreationExpressionContext classInstanceCreationExpression() {
10105 return getRuleContext(ClassInstanceCreationExpressionContext.class,0);
10106 }
10107 public StatementExpressionContext(ParserRuleContext parent, int invokingState) {
10108 super(parent, invokingState);
10109 }
10110 @Override public int getRuleIndex() { return RULE_statementExpression; }
10111 @Override
10112 public void enterRule(ParseTreeListener listener) {
10113 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterStatementExpression(this);
10114 }
10115 @Override
10116 public void exitRule(ParseTreeListener listener) {
10117 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitStatementExpression(this);
10118 }
10119 }
10120
10121 public final StatementExpressionContext statementExpression() throws RecognitionException {
10122 StatementExpressionContext _localctx = new StatementExpressionContext(_ctx, getState());
10123 enterRule(_localctx, 296, RULE_statementExpression);
10124 try {
10125 setState(1692);
10126 _errHandler.sync(this);
10127 switch ( getInterpreter().adaptivePredict(_input,171,_ctx) ) {
10128 case 1:
10129 enterOuterAlt(_localctx, 1);
10130 {
10131 setState(1685);
10132 assignment();
10133 }
10134 break;
10135 case 2:
10136 enterOuterAlt(_localctx, 2);
10137 {
10138 setState(1686);
10139 preIncrementExpression();
10140 }
10141 break;
10142 case 3:
10143 enterOuterAlt(_localctx, 3);
10144 {
10145 setState(1687);
10146 preDecrementExpression();
10147 }
10148 break;
10149 case 4:
10150 enterOuterAlt(_localctx, 4);
10151 {
10152 setState(1688);
10153 postIncrementExpression();
10154 }
10155 break;
10156 case 5:
10157 enterOuterAlt(_localctx, 5);
10158 {
10159 setState(1689);
10160 postDecrementExpression();
10161 }
10162 break;
10163 case 6:
10164 enterOuterAlt(_localctx, 6);
10165 {
10166 setState(1690);
10167 methodInvocation();
10168 }
10169 break;
10170 case 7:
10171 enterOuterAlt(_localctx, 7);
10172 {
10173 setState(1691);
10174 classInstanceCreationExpression();
10175 }
10176 break;
10177 }
10178 }
10179 catch (RecognitionException re) {
10180 _localctx.exception = re;
10181 _errHandler.reportError(this, re);
10182 _errHandler.recover(this, re);
10183 }
10184 finally {
10185 exitRule();
10186 }
10187 return _localctx;
10188 }
10189
10190 public static class IfThenStatementContext extends ParserRuleContext {
10191 public ExpressionContext expression() {
10192 return getRuleContext(ExpressionContext.class,0);
10193 }
10194 public StatementContext statement() {
10195 return getRuleContext(StatementContext.class,0);
10196 }
10197 public IfThenStatementContext(ParserRuleContext parent, int invokingState) {
10198 super(parent, invokingState);
10199 }
10200 @Override public int getRuleIndex() { return RULE_ifThenStatement; }
10201 @Override
10202 public void enterRule(ParseTreeListener listener) {
10203 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterIfThenStatement(this);
10204 }
10205 @Override
10206 public void exitRule(ParseTreeListener listener) {
10207 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitIfThenStatement(this);
10208 }
10209 }
10210
10211 public final IfThenStatementContext ifThenStatement() throws RecognitionException {
10212 IfThenStatementContext _localctx = new IfThenStatementContext(_ctx, getState());
10213 enterRule(_localctx, 298, RULE_ifThenStatement);
10214 try {
10215 enterOuterAlt(_localctx, 1);
10216 {
10217 setState(1694);
10218 match(IF);
10219 setState(1695);
10220 match(LPAREN);
10221 setState(1696);
10222 expression();
10223 setState(1697);
10224 match(RPAREN);
10225 setState(1698);
10226 statement();
10227 }
10228 }
10229 catch (RecognitionException re) {
10230 _localctx.exception = re;
10231 _errHandler.reportError(this, re);
10232 _errHandler.recover(this, re);
10233 }
10234 finally {
10235 exitRule();
10236 }
10237 return _localctx;
10238 }
10239
10240 public static class IfThenElseStatementContext extends ParserRuleContext {
10241 public ExpressionContext expression() {
10242 return getRuleContext(ExpressionContext.class,0);
10243 }
10244 public StatementNoShortIfContext statementNoShortIf() {
10245 return getRuleContext(StatementNoShortIfContext.class,0);
10246 }
10247 public StatementContext statement() {
10248 return getRuleContext(StatementContext.class,0);
10249 }
10250 public IfThenElseStatementContext(ParserRuleContext parent, int invokingState) {
10251 super(parent, invokingState);
10252 }
10253 @Override public int getRuleIndex() { return RULE_ifThenElseStatement; }
10254 @Override
10255 public void enterRule(ParseTreeListener listener) {
10256 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterIfThenElseStatement(this);
10257 }
10258 @Override
10259 public void exitRule(ParseTreeListener listener) {
10260 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitIfThenElseStatement(this);
10261 }
10262 }
10263
10264 public final IfThenElseStatementContext ifThenElseStatement() throws RecognitionException {
10265 IfThenElseStatementContext _localctx = new IfThenElseStatementContext(_ctx, getState());
10266 enterRule(_localctx, 300, RULE_ifThenElseStatement);
10267 try {
10268 enterOuterAlt(_localctx, 1);
10269 {
10270 setState(1700);
10271 match(IF);
10272 setState(1701);
10273 match(LPAREN);
10274 setState(1702);
10275 expression();
10276 setState(1703);
10277 match(RPAREN);
10278 setState(1704);
10279 statementNoShortIf();
10280 setState(1705);
10281 match(ELSE);
10282 setState(1706);
10283 statement();
10284 }
10285 }
10286 catch (RecognitionException re) {
10287 _localctx.exception = re;
10288 _errHandler.reportError(this, re);
10289 _errHandler.recover(this, re);
10290 }
10291 finally {
10292 exitRule();
10293 }
10294 return _localctx;
10295 }
10296
10297 public static class IfThenElseStatementNoShortIfContext extends ParserRuleContext {
10298 public ExpressionContext expression() {
10299 return getRuleContext(ExpressionContext.class,0);
10300 }
10301 public List<StatementNoShortIfContext> statementNoShortIf() {
10302 return getRuleContexts(StatementNoShortIfContext.class);
10303 }
10304 public StatementNoShortIfContext statementNoShortIf(int i) {
10305 return getRuleContext(StatementNoShortIfContext.class,i);
10306 }
10307 public IfThenElseStatementNoShortIfContext(ParserRuleContext parent, int invokingState) {
10308 super(parent, invokingState);
10309 }
10310 @Override public int getRuleIndex() { return RULE_ifThenElseStatementNoShortIf; }
10311 @Override
10312 public void enterRule(ParseTreeListener listener) {
10313 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterIfThenElseStatementNoShortIf(this);
10314 }
10315 @Override
10316 public void exitRule(ParseTreeListener listener) {
10317 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitIfThenElseStatementNoShortIf(this);
10318 }
10319 }
10320
10321 public final IfThenElseStatementNoShortIfContext ifThenElseStatementNoShortIf() throws RecognitionException {
10322 IfThenElseStatementNoShortIfContext _localctx = new IfThenElseStatementNoShortIfContext(_ctx, getState());
10323 enterRule(_localctx, 302, RULE_ifThenElseStatementNoShortIf);
10324 try {
10325 enterOuterAlt(_localctx, 1);
10326 {
10327 setState(1708);
10328 match(IF);
10329 setState(1709);
10330 match(LPAREN);
10331 setState(1710);
10332 expression();
10333 setState(1711);
10334 match(RPAREN);
10335 setState(1712);
10336 statementNoShortIf();
10337 setState(1713);
10338 match(ELSE);
10339 setState(1714);
10340 statementNoShortIf();
10341 }
10342 }
10343 catch (RecognitionException re) {
10344 _localctx.exception = re;
10345 _errHandler.reportError(this, re);
10346 _errHandler.recover(this, re);
10347 }
10348 finally {
10349 exitRule();
10350 }
10351 return _localctx;
10352 }
10353
10354 public static class AssertStatementContext extends ParserRuleContext {
10355 public List<ExpressionContext> expression() {
10356 return getRuleContexts(ExpressionContext.class);
10357 }
10358 public ExpressionContext expression(int i) {
10359 return getRuleContext(ExpressionContext.class,i);
10360 }
10361 public AssertStatementContext(ParserRuleContext parent, int invokingState) {
10362 super(parent, invokingState);
10363 }
10364 @Override public int getRuleIndex() { return RULE_assertStatement; }
10365 @Override
10366 public void enterRule(ParseTreeListener listener) {
10367 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterAssertStatement(this);
10368 }
10369 @Override
10370 public void exitRule(ParseTreeListener listener) {
10371 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitAssertStatement(this);
10372 }
10373 }
10374
10375 public final AssertStatementContext assertStatement() throws RecognitionException {
10376 AssertStatementContext _localctx = new AssertStatementContext(_ctx, getState());
10377 enterRule(_localctx, 304, RULE_assertStatement);
10378 try {
10379 setState(1726);
10380 _errHandler.sync(this);
10381 switch ( getInterpreter().adaptivePredict(_input,172,_ctx) ) {
10382 case 1:
10383 enterOuterAlt(_localctx, 1);
10384 {
10385 setState(1716);
10386 match(ASSERT);
10387 setState(1717);
10388 expression();
10389 setState(1718);
10390 match(SEMI);
10391 }
10392 break;
10393 case 2:
10394 enterOuterAlt(_localctx, 2);
10395 {
10396 setState(1720);
10397 match(ASSERT);
10398 setState(1721);
10399 expression();
10400 setState(1722);
10401 match(COLON);
10402 setState(1723);
10403 expression();
10404 setState(1724);
10405 match(SEMI);
10406 }
10407 break;
10408 }
10409 }
10410 catch (RecognitionException re) {
10411 _localctx.exception = re;
10412 _errHandler.reportError(this, re);
10413 _errHandler.recover(this, re);
10414 }
10415 finally {
10416 exitRule();
10417 }
10418 return _localctx;
10419 }
10420
10421 public static class SwitchStatementContext extends ParserRuleContext {
10422 public ExpressionContext expression() {
10423 return getRuleContext(ExpressionContext.class,0);
10424 }
10425 public SwitchBlockContext switchBlock() {
10426 return getRuleContext(SwitchBlockContext.class,0);
10427 }
10428 public SwitchStatementContext(ParserRuleContext parent, int invokingState) {
10429 super(parent, invokingState);
10430 }
10431 @Override public int getRuleIndex() { return RULE_switchStatement; }
10432 @Override
10433 public void enterRule(ParseTreeListener listener) {
10434 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterSwitchStatement(this);
10435 }
10436 @Override
10437 public void exitRule(ParseTreeListener listener) {
10438 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitSwitchStatement(this);
10439 }
10440 }
10441
10442 public final SwitchStatementContext switchStatement() throws RecognitionException {
10443 SwitchStatementContext _localctx = new SwitchStatementContext(_ctx, getState());
10444 enterRule(_localctx, 306, RULE_switchStatement);
10445 try {
10446 enterOuterAlt(_localctx, 1);
10447 {
10448 setState(1728);
10449 match(SWITCH);
10450 setState(1729);
10451 match(LPAREN);
10452 setState(1730);
10453 expression();
10454 setState(1731);
10455 match(RPAREN);
10456 setState(1732);
10457 switchBlock();
10458 }
10459 }
10460 catch (RecognitionException re) {
10461 _localctx.exception = re;
10462 _errHandler.reportError(this, re);
10463 _errHandler.recover(this, re);
10464 }
10465 finally {
10466 exitRule();
10467 }
10468 return _localctx;
10469 }
10470
10471 public static class SwitchBlockContext extends ParserRuleContext {
10472 public List<SwitchBlockStatementGroupContext> switchBlockStatementGroup() {
10473 return getRuleContexts(SwitchBlockStatementGroupContext.class);
10474 }
10475 public SwitchBlockStatementGroupContext switchBlockStatementGroup(int i) {
10476 return getRuleContext(SwitchBlockStatementGroupContext.class,i);
10477 }
10478 public List<SwitchLabelContext> switchLabel() {
10479 return getRuleContexts(SwitchLabelContext.class);
10480 }
10481 public SwitchLabelContext switchLabel(int i) {
10482 return getRuleContext(SwitchLabelContext.class,i);
10483 }
10484 public SwitchBlockContext(ParserRuleContext parent, int invokingState) {
10485 super(parent, invokingState);
10486 }
10487 @Override public int getRuleIndex() { return RULE_switchBlock; }
10488 @Override
10489 public void enterRule(ParseTreeListener listener) {
10490 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterSwitchBlock(this);
10491 }
10492 @Override
10493 public void exitRule(ParseTreeListener listener) {
10494 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitSwitchBlock(this);
10495 }
10496 }
10497
10498 public final SwitchBlockContext switchBlock() throws RecognitionException {
10499 SwitchBlockContext _localctx = new SwitchBlockContext(_ctx, getState());
10500 enterRule(_localctx, 308, RULE_switchBlock);
10501 int _la;
10502 try {
10503 int _alt;
10504 enterOuterAlt(_localctx, 1);
10505 {
10506 setState(1734);
10507 match(LBRACE);
10508 setState(1738);
10509 _errHandler.sync(this);
10510 _alt = getInterpreter().adaptivePredict(_input,173,_ctx);
10511 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
10512 if ( _alt==1 ) {
10513 {
10514 {
10515 setState(1735);
10516 switchBlockStatementGroup();
10517 }
10518 }
10519 }
10520 setState(1740);
10521 _errHandler.sync(this);
10522 _alt = getInterpreter().adaptivePredict(_input,173,_ctx);
10523 }
10524 setState(1744);
10525 _errHandler.sync(this);
10526 _la = _input.LA(1);
10527 while (_la==CASE || _la==DEFAULT) {
10528 {
10529 {
10530 setState(1741);
10531 switchLabel();
10532 }
10533 }
10534 setState(1746);
10535 _errHandler.sync(this);
10536 _la = _input.LA(1);
10537 }
10538 setState(1747);
10539 match(RBRACE);
10540 }
10541 }
10542 catch (RecognitionException re) {
10543 _localctx.exception = re;
10544 _errHandler.reportError(this, re);
10545 _errHandler.recover(this, re);
10546 }
10547 finally {
10548 exitRule();
10549 }
10550 return _localctx;
10551 }
10552
10553 public static class SwitchBlockStatementGroupContext extends ParserRuleContext {
10554 public SwitchLabelsContext switchLabels() {
10555 return getRuleContext(SwitchLabelsContext.class,0);
10556 }
10557 public BlockStatementsContext blockStatements() {
10558 return getRuleContext(BlockStatementsContext.class,0);
10559 }
10560 public SwitchBlockStatementGroupContext(ParserRuleContext parent, int invokingState) {
10561 super(parent, invokingState);
10562 }
10563 @Override public int getRuleIndex() { return RULE_switchBlockStatementGroup; }
10564 @Override
10565 public void enterRule(ParseTreeListener listener) {
10566 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterSwitchBlockStatementGroup(this);
10567 }
10568 @Override
10569 public void exitRule(ParseTreeListener listener) {
10570 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitSwitchBlockStatementGroup(this);
10571 }
10572 }
10573
10574 public final SwitchBlockStatementGroupContext switchBlockStatementGroup() throws RecognitionException {
10575 SwitchBlockStatementGroupContext _localctx = new SwitchBlockStatementGroupContext(_ctx, getState());
10576 enterRule(_localctx, 310, RULE_switchBlockStatementGroup);
10577 try {
10578 enterOuterAlt(_localctx, 1);
10579 {
10580 setState(1749);
10581 switchLabels();
10582 setState(1750);
10583 blockStatements();
10584 }
10585 }
10586 catch (RecognitionException re) {
10587 _localctx.exception = re;
10588 _errHandler.reportError(this, re);
10589 _errHandler.recover(this, re);
10590 }
10591 finally {
10592 exitRule();
10593 }
10594 return _localctx;
10595 }
10596
10597 public static class SwitchLabelsContext extends ParserRuleContext {
10598 public List<SwitchLabelContext> switchLabel() {
10599 return getRuleContexts(SwitchLabelContext.class);
10600 }
10601 public SwitchLabelContext switchLabel(int i) {
10602 return getRuleContext(SwitchLabelContext.class,i);
10603 }
10604 public SwitchLabelsContext(ParserRuleContext parent, int invokingState) {
10605 super(parent, invokingState);
10606 }
10607 @Override public int getRuleIndex() { return RULE_switchLabels; }
10608 @Override
10609 public void enterRule(ParseTreeListener listener) {
10610 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterSwitchLabels(this);
10611 }
10612 @Override
10613 public void exitRule(ParseTreeListener listener) {
10614 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitSwitchLabels(this);
10615 }
10616 }
10617
10618 public final SwitchLabelsContext switchLabels() throws RecognitionException {
10619 SwitchLabelsContext _localctx = new SwitchLabelsContext(_ctx, getState());
10620 enterRule(_localctx, 312, RULE_switchLabels);
10621 int _la;
10622 try {
10623 enterOuterAlt(_localctx, 1);
10624 {
10625 setState(1753);
10626 _errHandler.sync(this);
10627 _la = _input.LA(1);
10628 do {
10629 {
10630 {
10631 setState(1752);
10632 switchLabel();
10633 }
10634 }
10635 setState(1755);
10636 _errHandler.sync(this);
10637 _la = _input.LA(1);
10638 } while ( _la==CASE || _la==DEFAULT );
10639 }
10640 }
10641 catch (RecognitionException re) {
10642 _localctx.exception = re;
10643 _errHandler.reportError(this, re);
10644 _errHandler.recover(this, re);
10645 }
10646 finally {
10647 exitRule();
10648 }
10649 return _localctx;
10650 }
10651
10652 public static class SwitchLabelContext extends ParserRuleContext {
10653 public ConstantExpressionContext constantExpression() {
10654 return getRuleContext(ConstantExpressionContext.class,0);
10655 }
10656 public EnumConstantNameContext enumConstantName() {
10657 return getRuleContext(EnumConstantNameContext.class,0);
10658 }
10659 public SwitchLabelContext(ParserRuleContext parent, int invokingState) {
10660 super(parent, invokingState);
10661 }
10662 @Override public int getRuleIndex() { return RULE_switchLabel; }
10663 @Override
10664 public void enterRule(ParseTreeListener listener) {
10665 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterSwitchLabel(this);
10666 }
10667 @Override
10668 public void exitRule(ParseTreeListener listener) {
10669 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitSwitchLabel(this);
10670 }
10671 }
10672
10673 public final SwitchLabelContext switchLabel() throws RecognitionException {
10674 SwitchLabelContext _localctx = new SwitchLabelContext(_ctx, getState());
10675 enterRule(_localctx, 314, RULE_switchLabel);
10676 try {
10677 setState(1767);
10678 _errHandler.sync(this);
10679 switch ( getInterpreter().adaptivePredict(_input,176,_ctx) ) {
10680 case 1:
10681 enterOuterAlt(_localctx, 1);
10682 {
10683 setState(1757);
10684 match(CASE);
10685 setState(1758);
10686 constantExpression();
10687 setState(1759);
10688 match(COLON);
10689 }
10690 break;
10691 case 2:
10692 enterOuterAlt(_localctx, 2);
10693 {
10694 setState(1761);
10695 match(CASE);
10696 setState(1762);
10697 enumConstantName();
10698 setState(1763);
10699 match(COLON);
10700 }
10701 break;
10702 case 3:
10703 enterOuterAlt(_localctx, 3);
10704 {
10705 setState(1765);
10706 match(DEFAULT);
10707 setState(1766);
10708 match(COLON);
10709 }
10710 break;
10711 }
10712 }
10713 catch (RecognitionException re) {
10714 _localctx.exception = re;
10715 _errHandler.reportError(this, re);
10716 _errHandler.recover(this, re);
10717 }
10718 finally {
10719 exitRule();
10720 }
10721 return _localctx;
10722 }
10723
10724 public static class EnumConstantNameContext extends ParserRuleContext {
10725 public IdentifierContext identifier() {
10726 return getRuleContext(IdentifierContext.class,0);
10727 }
10728 public EnumConstantNameContext(ParserRuleContext parent, int invokingState) {
10729 super(parent, invokingState);
10730 }
10731 @Override public int getRuleIndex() { return RULE_enumConstantName; }
10732 @Override
10733 public void enterRule(ParseTreeListener listener) {
10734 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterEnumConstantName(this);
10735 }
10736 @Override
10737 public void exitRule(ParseTreeListener listener) {
10738 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitEnumConstantName(this);
10739 }
10740 }
10741
10742 public final EnumConstantNameContext enumConstantName() throws RecognitionException {
10743 EnumConstantNameContext _localctx = new EnumConstantNameContext(_ctx, getState());
10744 enterRule(_localctx, 316, RULE_enumConstantName);
10745 try {
10746 enterOuterAlt(_localctx, 1);
10747 {
10748 setState(1769);
10749 identifier();
10750 }
10751 }
10752 catch (RecognitionException re) {
10753 _localctx.exception = re;
10754 _errHandler.reportError(this, re);
10755 _errHandler.recover(this, re);
10756 }
10757 finally {
10758 exitRule();
10759 }
10760 return _localctx;
10761 }
10762
10763 public static class WhileStatementContext extends ParserRuleContext {
10764 public ExpressionContext expression() {
10765 return getRuleContext(ExpressionContext.class,0);
10766 }
10767 public StatementContext statement() {
10768 return getRuleContext(StatementContext.class,0);
10769 }
10770 public WhileStatementContext(ParserRuleContext parent, int invokingState) {
10771 super(parent, invokingState);
10772 }
10773 @Override public int getRuleIndex() { return RULE_whileStatement; }
10774 @Override
10775 public void enterRule(ParseTreeListener listener) {
10776 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterWhileStatement(this);
10777 }
10778 @Override
10779 public void exitRule(ParseTreeListener listener) {
10780 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitWhileStatement(this);
10781 }
10782 }
10783
10784 public final WhileStatementContext whileStatement() throws RecognitionException {
10785 WhileStatementContext _localctx = new WhileStatementContext(_ctx, getState());
10786 enterRule(_localctx, 318, RULE_whileStatement);
10787 try {
10788 enterOuterAlt(_localctx, 1);
10789 {
10790 setState(1771);
10791 match(WHILE);
10792 setState(1772);
10793 match(LPAREN);
10794 setState(1773);
10795 expression();
10796 setState(1774);
10797 match(RPAREN);
10798 setState(1775);
10799 statement();
10800 }
10801 }
10802 catch (RecognitionException re) {
10803 _localctx.exception = re;
10804 _errHandler.reportError(this, re);
10805 _errHandler.recover(this, re);
10806 }
10807 finally {
10808 exitRule();
10809 }
10810 return _localctx;
10811 }
10812
10813 public static class WhileStatementNoShortIfContext extends ParserRuleContext {
10814 public ExpressionContext expression() {
10815 return getRuleContext(ExpressionContext.class,0);
10816 }
10817 public StatementNoShortIfContext statementNoShortIf() {
10818 return getRuleContext(StatementNoShortIfContext.class,0);
10819 }
10820 public WhileStatementNoShortIfContext(ParserRuleContext parent, int invokingState) {
10821 super(parent, invokingState);
10822 }
10823 @Override public int getRuleIndex() { return RULE_whileStatementNoShortIf; }
10824 @Override
10825 public void enterRule(ParseTreeListener listener) {
10826 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterWhileStatementNoShortIf(this);
10827 }
10828 @Override
10829 public void exitRule(ParseTreeListener listener) {
10830 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitWhileStatementNoShortIf(this);
10831 }
10832 }
10833
10834 public final WhileStatementNoShortIfContext whileStatementNoShortIf() throws RecognitionException {
10835 WhileStatementNoShortIfContext _localctx = new WhileStatementNoShortIfContext(_ctx, getState());
10836 enterRule(_localctx, 320, RULE_whileStatementNoShortIf);
10837 try {
10838 enterOuterAlt(_localctx, 1);
10839 {
10840 setState(1777);
10841 match(WHILE);
10842 setState(1778);
10843 match(LPAREN);
10844 setState(1779);
10845 expression();
10846 setState(1780);
10847 match(RPAREN);
10848 setState(1781);
10849 statementNoShortIf();
10850 }
10851 }
10852 catch (RecognitionException re) {
10853 _localctx.exception = re;
10854 _errHandler.reportError(this, re);
10855 _errHandler.recover(this, re);
10856 }
10857 finally {
10858 exitRule();
10859 }
10860 return _localctx;
10861 }
10862
10863 public static class DoStatementContext extends ParserRuleContext {
10864 public StatementContext statement() {
10865 return getRuleContext(StatementContext.class,0);
10866 }
10867 public ExpressionContext expression() {
10868 return getRuleContext(ExpressionContext.class,0);
10869 }
10870 public DoStatementContext(ParserRuleContext parent, int invokingState) {
10871 super(parent, invokingState);
10872 }
10873 @Override public int getRuleIndex() { return RULE_doStatement; }
10874 @Override
10875 public void enterRule(ParseTreeListener listener) {
10876 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterDoStatement(this);
10877 }
10878 @Override
10879 public void exitRule(ParseTreeListener listener) {
10880 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitDoStatement(this);
10881 }
10882 }
10883
10884 public final DoStatementContext doStatement() throws RecognitionException {
10885 DoStatementContext _localctx = new DoStatementContext(_ctx, getState());
10886 enterRule(_localctx, 322, RULE_doStatement);
10887 try {
10888 enterOuterAlt(_localctx, 1);
10889 {
10890 setState(1783);
10891 match(DO);
10892 setState(1784);
10893 statement();
10894 setState(1785);
10895 match(WHILE);
10896 setState(1786);
10897 match(LPAREN);
10898 setState(1787);
10899 expression();
10900 setState(1788);
10901 match(RPAREN);
10902 setState(1789);
10903 match(SEMI);
10904 }
10905 }
10906 catch (RecognitionException re) {
10907 _localctx.exception = re;
10908 _errHandler.reportError(this, re);
10909 _errHandler.recover(this, re);
10910 }
10911 finally {
10912 exitRule();
10913 }
10914 return _localctx;
10915 }
10916
10917 public static class ForStatementContext extends ParserRuleContext {
10918 public BasicForStatementContext basicForStatement() {
10919 return getRuleContext(BasicForStatementContext.class,0);
10920 }
10921 public EnhancedForStatementContext enhancedForStatement() {
10922 return getRuleContext(EnhancedForStatementContext.class,0);
10923 }
10924 public ForStatementContext(ParserRuleContext parent, int invokingState) {
10925 super(parent, invokingState);
10926 }
10927 @Override public int getRuleIndex() { return RULE_forStatement; }
10928 @Override
10929 public void enterRule(ParseTreeListener listener) {
10930 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterForStatement(this);
10931 }
10932 @Override
10933 public void exitRule(ParseTreeListener listener) {
10934 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitForStatement(this);
10935 }
10936 }
10937
10938 public final ForStatementContext forStatement() throws RecognitionException {
10939 ForStatementContext _localctx = new ForStatementContext(_ctx, getState());
10940 enterRule(_localctx, 324, RULE_forStatement);
10941 try {
10942 setState(1793);
10943 _errHandler.sync(this);
10944 switch ( getInterpreter().adaptivePredict(_input,177,_ctx) ) {
10945 case 1:
10946 enterOuterAlt(_localctx, 1);
10947 {
10948 setState(1791);
10949 basicForStatement();
10950 }
10951 break;
10952 case 2:
10953 enterOuterAlt(_localctx, 2);
10954 {
10955 setState(1792);
10956 enhancedForStatement();
10957 }
10958 break;
10959 }
10960 }
10961 catch (RecognitionException re) {
10962 _localctx.exception = re;
10963 _errHandler.reportError(this, re);
10964 _errHandler.recover(this, re);
10965 }
10966 finally {
10967 exitRule();
10968 }
10969 return _localctx;
10970 }
10971
10972 public static class ForStatementNoShortIfContext extends ParserRuleContext {
10973 public BasicForStatementNoShortIfContext basicForStatementNoShortIf() {
10974 return getRuleContext(BasicForStatementNoShortIfContext.class,0);
10975 }
10976 public EnhancedForStatementNoShortIfContext enhancedForStatementNoShortIf() {
10977 return getRuleContext(EnhancedForStatementNoShortIfContext.class,0);
10978 }
10979 public ForStatementNoShortIfContext(ParserRuleContext parent, int invokingState) {
10980 super(parent, invokingState);
10981 }
10982 @Override public int getRuleIndex() { return RULE_forStatementNoShortIf; }
10983 @Override
10984 public void enterRule(ParseTreeListener listener) {
10985 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterForStatementNoShortIf(this);
10986 }
10987 @Override
10988 public void exitRule(ParseTreeListener listener) {
10989 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitForStatementNoShortIf(this);
10990 }
10991 }
10992
10993 public final ForStatementNoShortIfContext forStatementNoShortIf() throws RecognitionException {
10994 ForStatementNoShortIfContext _localctx = new ForStatementNoShortIfContext(_ctx, getState());
10995 enterRule(_localctx, 326, RULE_forStatementNoShortIf);
10996 try {
10997 setState(1797);
10998 _errHandler.sync(this);
10999 switch ( getInterpreter().adaptivePredict(_input,178,_ctx) ) {
11000 case 1:
11001 enterOuterAlt(_localctx, 1);
11002 {
11003 setState(1795);
11004 basicForStatementNoShortIf();
11005 }
11006 break;
11007 case 2:
11008 enterOuterAlt(_localctx, 2);
11009 {
11010 setState(1796);
11011 enhancedForStatementNoShortIf();
11012 }
11013 break;
11014 }
11015 }
11016 catch (RecognitionException re) {
11017 _localctx.exception = re;
11018 _errHandler.reportError(this, re);
11019 _errHandler.recover(this, re);
11020 }
11021 finally {
11022 exitRule();
11023 }
11024 return _localctx;
11025 }
11026
11027 public static class BasicForStatementContext extends ParserRuleContext {
11028 public StatementContext statement() {
11029 return getRuleContext(StatementContext.class,0);
11030 }
11031 public ForInitContext forInit() {
11032 return getRuleContext(ForInitContext.class,0);
11033 }
11034 public ExpressionContext expression() {
11035 return getRuleContext(ExpressionContext.class,0);
11036 }
11037 public ForUpdateContext forUpdate() {
11038 return getRuleContext(ForUpdateContext.class,0);
11039 }
11040 public BasicForStatementContext(ParserRuleContext parent, int invokingState) {
11041 super(parent, invokingState);
11042 }
11043 @Override public int getRuleIndex() { return RULE_basicForStatement; }
11044 @Override
11045 public void enterRule(ParseTreeListener listener) {
11046 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterBasicForStatement(this);
11047 }
11048 @Override
11049 public void exitRule(ParseTreeListener listener) {
11050 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitBasicForStatement(this);
11051 }
11052 }
11053
11054 public final BasicForStatementContext basicForStatement() throws RecognitionException {
11055 BasicForStatementContext _localctx = new BasicForStatementContext(_ctx, getState());
11056 enterRule(_localctx, 328, RULE_basicForStatement);
11057 int _la;
11058 try {
11059 enterOuterAlt(_localctx, 1);
11060 {
11061 setState(1799);
11062 match(FOR);
11063 setState(1800);
11064 match(LPAREN);
11065 setState(1802);
11066 _errHandler.sync(this);
11067 _la = _input.LA(1);
11068 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 << 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 << (INC - 64)) | (1L << (DEC - 64)) | (1L << (Identifier - 64)))) != 0)) {
11069 {
11070 setState(1801);
11071 forInit();
11072 }
11073 }
11074
11075 setState(1804);
11076 match(SEMI);
11077 setState(1806);
11078 _errHandler.sync(this);
11079 _la = _input.LA(1);
11080 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)) {
11081 {
11082 setState(1805);
11083 expression();
11084 }
11085 }
11086
11087 setState(1808);
11088 match(SEMI);
11089 setState(1810);
11090 _errHandler.sync(this);
11091 _la = _input.LA(1);
11092 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 << (INC - 64)) | (1L << (DEC - 64)) | (1L << (Identifier - 64)))) != 0)) {
11093 {
11094 setState(1809);
11095 forUpdate();
11096 }
11097 }
11098
11099 setState(1812);
11100 match(RPAREN);
11101 setState(1813);
11102 statement();
11103 }
11104 }
11105 catch (RecognitionException re) {
11106 _localctx.exception = re;
11107 _errHandler.reportError(this, re);
11108 _errHandler.recover(this, re);
11109 }
11110 finally {
11111 exitRule();
11112 }
11113 return _localctx;
11114 }
11115
11116 public static class BasicForStatementNoShortIfContext extends ParserRuleContext {
11117 public StatementNoShortIfContext statementNoShortIf() {
11118 return getRuleContext(StatementNoShortIfContext.class,0);
11119 }
11120 public ForInitContext forInit() {
11121 return getRuleContext(ForInitContext.class,0);
11122 }
11123 public ExpressionContext expression() {
11124 return getRuleContext(ExpressionContext.class,0);
11125 }
11126 public ForUpdateContext forUpdate() {
11127 return getRuleContext(ForUpdateContext.class,0);
11128 }
11129 public BasicForStatementNoShortIfContext(ParserRuleContext parent, int invokingState) {
11130 super(parent, invokingState);
11131 }
11132 @Override public int getRuleIndex() { return RULE_basicForStatementNoShortIf; }
11133 @Override
11134 public void enterRule(ParseTreeListener listener) {
11135 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterBasicForStatementNoShortIf(this);
11136 }
11137 @Override
11138 public void exitRule(ParseTreeListener listener) {
11139 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitBasicForStatementNoShortIf(this);
11140 }
11141 }
11142
11143 public final BasicForStatementNoShortIfContext basicForStatementNoShortIf() throws RecognitionException {
11144 BasicForStatementNoShortIfContext _localctx = new BasicForStatementNoShortIfContext(_ctx, getState());
11145 enterRule(_localctx, 330, RULE_basicForStatementNoShortIf);
11146 int _la;
11147 try {
11148 enterOuterAlt(_localctx, 1);
11149 {
11150 setState(1815);
11151 match(FOR);
11152 setState(1816);
11153 match(LPAREN);
11154 setState(1818);
11155 _errHandler.sync(this);
11156 _la = _input.LA(1);
11157 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 << 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 << (INC - 64)) | (1L << (DEC - 64)) | (1L << (Identifier - 64)))) != 0)) {
11158 {
11159 setState(1817);
11160 forInit();
11161 }
11162 }
11163
11164 setState(1820);
11165 match(SEMI);
11166 setState(1822);
11167 _errHandler.sync(this);
11168 _la = _input.LA(1);
11169 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)) {
11170 {
11171 setState(1821);
11172 expression();
11173 }
11174 }
11175
11176 setState(1824);
11177 match(SEMI);
11178 setState(1826);
11179 _errHandler.sync(this);
11180 _la = _input.LA(1);
11181 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 << (INC - 64)) | (1L << (DEC - 64)) | (1L << (Identifier - 64)))) != 0)) {
11182 {
11183 setState(1825);
11184 forUpdate();
11185 }
11186 }
11187
11188 setState(1828);
11189 match(RPAREN);
11190 setState(1829);
11191 statementNoShortIf();
11192 }
11193 }
11194 catch (RecognitionException re) {
11195 _localctx.exception = re;
11196 _errHandler.reportError(this, re);
11197 _errHandler.recover(this, re);
11198 }
11199 finally {
11200 exitRule();
11201 }
11202 return _localctx;
11203 }
11204
11205 public static class ForInitContext extends ParserRuleContext {
11206 public StatementExpressionListContext statementExpressionList() {
11207 return getRuleContext(StatementExpressionListContext.class,0);
11208 }
11209 public LocalVariableDeclarationContext localVariableDeclaration() {
11210 return getRuleContext(LocalVariableDeclarationContext.class,0);
11211 }
11212 public ForInitContext(ParserRuleContext parent, int invokingState) {
11213 super(parent, invokingState);
11214 }
11215 @Override public int getRuleIndex() { return RULE_forInit; }
11216 @Override
11217 public void enterRule(ParseTreeListener listener) {
11218 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterForInit(this);
11219 }
11220 @Override
11221 public void exitRule(ParseTreeListener listener) {
11222 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitForInit(this);
11223 }
11224 }
11225
11226 public final ForInitContext forInit() throws RecognitionException {
11227 ForInitContext _localctx = new ForInitContext(_ctx, getState());
11228 enterRule(_localctx, 332, RULE_forInit);
11229 try {
11230 setState(1833);
11231 _errHandler.sync(this);
11232 switch ( getInterpreter().adaptivePredict(_input,185,_ctx) ) {
11233 case 1:
11234 enterOuterAlt(_localctx, 1);
11235 {
11236 setState(1831);
11237 statementExpressionList();
11238 }
11239 break;
11240 case 2:
11241 enterOuterAlt(_localctx, 2);
11242 {
11243 setState(1832);
11244 localVariableDeclaration();
11245 }
11246 break;
11247 }
11248 }
11249 catch (RecognitionException re) {
11250 _localctx.exception = re;
11251 _errHandler.reportError(this, re);
11252 _errHandler.recover(this, re);
11253 }
11254 finally {
11255 exitRule();
11256 }
11257 return _localctx;
11258 }
11259
11260 public static class ForUpdateContext extends ParserRuleContext {
11261 public StatementExpressionListContext statementExpressionList() {
11262 return getRuleContext(StatementExpressionListContext.class,0);
11263 }
11264 public ForUpdateContext(ParserRuleContext parent, int invokingState) {
11265 super(parent, invokingState);
11266 }
11267 @Override public int getRuleIndex() { return RULE_forUpdate; }
11268 @Override
11269 public void enterRule(ParseTreeListener listener) {
11270 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterForUpdate(this);
11271 }
11272 @Override
11273 public void exitRule(ParseTreeListener listener) {
11274 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitForUpdate(this);
11275 }
11276 }
11277
11278 public final ForUpdateContext forUpdate() throws RecognitionException {
11279 ForUpdateContext _localctx = new ForUpdateContext(_ctx, getState());
11280 enterRule(_localctx, 334, RULE_forUpdate);
11281 try {
11282 enterOuterAlt(_localctx, 1);
11283 {
11284 setState(1835);
11285 statementExpressionList();
11286 }
11287 }
11288 catch (RecognitionException re) {
11289 _localctx.exception = re;
11290 _errHandler.reportError(this, re);
11291 _errHandler.recover(this, re);
11292 }
11293 finally {
11294 exitRule();
11295 }
11296 return _localctx;
11297 }
11298
11299 public static class StatementExpressionListContext extends ParserRuleContext {
11300 public List<StatementExpressionContext> statementExpression() {
11301 return getRuleContexts(StatementExpressionContext.class);
11302 }
11303 public StatementExpressionContext statementExpression(int i) {
11304 return getRuleContext(StatementExpressionContext.class,i);
11305 }
11306 public StatementExpressionListContext(ParserRuleContext parent, int invokingState) {
11307 super(parent, invokingState);
11308 }
11309 @Override public int getRuleIndex() { return RULE_statementExpressionList; }
11310 @Override
11311 public void enterRule(ParseTreeListener listener) {
11312 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterStatementExpressionList(this);
11313 }
11314 @Override
11315 public void exitRule(ParseTreeListener listener) {
11316 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitStatementExpressionList(this);
11317 }
11318 }
11319
11320 public final StatementExpressionListContext statementExpressionList() throws RecognitionException {
11321 StatementExpressionListContext _localctx = new StatementExpressionListContext(_ctx, getState());
11322 enterRule(_localctx, 336, RULE_statementExpressionList);
11323 int _la;
11324 try {
11325 enterOuterAlt(_localctx, 1);
11326 {
11327 setState(1837);
11328 statementExpression();
11329 setState(1842);
11330 _errHandler.sync(this);
11331 _la = _input.LA(1);
11332 while (_la==COMMA) {
11333 {
11334 {
11335 setState(1838);
11336 match(COMMA);
11337 setState(1839);
11338 statementExpression();
11339 }
11340 }
11341 setState(1844);
11342 _errHandler.sync(this);
11343 _la = _input.LA(1);
11344 }
11345 }
11346 }
11347 catch (RecognitionException re) {
11348 _localctx.exception = re;
11349 _errHandler.reportError(this, re);
11350 _errHandler.recover(this, re);
11351 }
11352 finally {
11353 exitRule();
11354 }
11355 return _localctx;
11356 }
11357
11358 public static class EnhancedForStatementContext extends ParserRuleContext {
11359 public UnannTypeContext unannType() {
11360 return getRuleContext(UnannTypeContext.class,0);
11361 }
11362 public VariableDeclaratorIdContext variableDeclaratorId() {
11363 return getRuleContext(VariableDeclaratorIdContext.class,0);
11364 }
11365 public ExpressionContext expression() {
11366 return getRuleContext(ExpressionContext.class,0);
11367 }
11368 public StatementContext statement() {
11369 return getRuleContext(StatementContext.class,0);
11370 }
11371 public List<VariableModifierContext> variableModifier() {
11372 return getRuleContexts(VariableModifierContext.class);
11373 }
11374 public VariableModifierContext variableModifier(int i) {
11375 return getRuleContext(VariableModifierContext.class,i);
11376 }
11377 public EnhancedForStatementContext(ParserRuleContext parent, int invokingState) {
11378 super(parent, invokingState);
11379 }
11380 @Override public int getRuleIndex() { return RULE_enhancedForStatement; }
11381 @Override
11382 public void enterRule(ParseTreeListener listener) {
11383 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterEnhancedForStatement(this);
11384 }
11385 @Override
11386 public void exitRule(ParseTreeListener listener) {
11387 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitEnhancedForStatement(this);
11388 }
11389 }
11390
11391 public final EnhancedForStatementContext enhancedForStatement() throws RecognitionException {
11392 EnhancedForStatementContext _localctx = new EnhancedForStatementContext(_ctx, getState());
11393 enterRule(_localctx, 338, RULE_enhancedForStatement);
11394 int _la;
11395 try {
11396 enterOuterAlt(_localctx, 1);
11397 {
11398 setState(1845);
11399 match(FOR);
11400 setState(1846);
11401 match(LPAREN);
11402 setState(1850);
11403 _errHandler.sync(this);
11404 _la = _input.LA(1);
11405 while (_la==FINAL || _la==AT) {
11406 {
11407 {
11408 setState(1847);
11409 variableModifier();
11410 }
11411 }
11412 setState(1852);
11413 _errHandler.sync(this);
11414 _la = _input.LA(1);
11415 }
11416 setState(1853);
11417 unannType();
11418 setState(1854);
11419 variableDeclaratorId();
11420 setState(1855);
11421 match(COLON);
11422 setState(1856);
11423 expression();
11424 setState(1857);
11425 match(RPAREN);
11426 setState(1858);
11427 statement();
11428 }
11429 }
11430 catch (RecognitionException re) {
11431 _localctx.exception = re;
11432 _errHandler.reportError(this, re);
11433 _errHandler.recover(this, re);
11434 }
11435 finally {
11436 exitRule();
11437 }
11438 return _localctx;
11439 }
11440
11441 public static class EnhancedForStatementNoShortIfContext extends ParserRuleContext {
11442 public UnannTypeContext unannType() {
11443 return getRuleContext(UnannTypeContext.class,0);
11444 }
11445 public VariableDeclaratorIdContext variableDeclaratorId() {
11446 return getRuleContext(VariableDeclaratorIdContext.class,0);
11447 }
11448 public ExpressionContext expression() {
11449 return getRuleContext(ExpressionContext.class,0);
11450 }
11451 public StatementNoShortIfContext statementNoShortIf() {
11452 return getRuleContext(StatementNoShortIfContext.class,0);
11453 }
11454 public List<VariableModifierContext> variableModifier() {
11455 return getRuleContexts(VariableModifierContext.class);
11456 }
11457 public VariableModifierContext variableModifier(int i) {
11458 return getRuleContext(VariableModifierContext.class,i);
11459 }
11460 public EnhancedForStatementNoShortIfContext(ParserRuleContext parent, int invokingState) {
11461 super(parent, invokingState);
11462 }
11463 @Override public int getRuleIndex() { return RULE_enhancedForStatementNoShortIf; }
11464 @Override
11465 public void enterRule(ParseTreeListener listener) {
11466 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterEnhancedForStatementNoShortIf(this);
11467 }
11468 @Override
11469 public void exitRule(ParseTreeListener listener) {
11470 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitEnhancedForStatementNoShortIf(this);
11471 }
11472 }
11473
11474 public final EnhancedForStatementNoShortIfContext enhancedForStatementNoShortIf() throws RecognitionException {
11475 EnhancedForStatementNoShortIfContext _localctx = new EnhancedForStatementNoShortIfContext(_ctx, getState());
11476 enterRule(_localctx, 340, RULE_enhancedForStatementNoShortIf);
11477 int _la;
11478 try {
11479 enterOuterAlt(_localctx, 1);
11480 {
11481 setState(1860);
11482 match(FOR);
11483 setState(1861);
11484 match(LPAREN);
11485 setState(1865);
11486 _errHandler.sync(this);
11487 _la = _input.LA(1);
11488 while (_la==FINAL || _la==AT) {
11489 {
11490 {
11491 setState(1862);
11492 variableModifier();
11493 }
11494 }
11495 setState(1867);
11496 _errHandler.sync(this);
11497 _la = _input.LA(1);
11498 }
11499 setState(1868);
11500 unannType();
11501 setState(1869);
11502 variableDeclaratorId();
11503 setState(1870);
11504 match(COLON);
11505 setState(1871);
11506 expression();
11507 setState(1872);
11508 match(RPAREN);
11509 setState(1873);
11510 statementNoShortIf();
11511 }
11512 }
11513 catch (RecognitionException re) {
11514 _localctx.exception = re;
11515 _errHandler.reportError(this, re);
11516 _errHandler.recover(this, re);
11517 }
11518 finally {
11519 exitRule();
11520 }
11521 return _localctx;
11522 }
11523
11524 public static class BreakStatementContext extends ParserRuleContext {
11525 public IdentifierContext identifier() {
11526 return getRuleContext(IdentifierContext.class,0);
11527 }
11528 public BreakStatementContext(ParserRuleContext parent, int invokingState) {
11529 super(parent, invokingState);
11530 }
11531 @Override public int getRuleIndex() { return RULE_breakStatement; }
11532 @Override
11533 public void enterRule(ParseTreeListener listener) {
11534 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterBreakStatement(this);
11535 }
11536 @Override
11537 public void exitRule(ParseTreeListener listener) {
11538 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitBreakStatement(this);
11539 }
11540 }
11541
11542 public final BreakStatementContext breakStatement() throws RecognitionException {
11543 BreakStatementContext _localctx = new BreakStatementContext(_ctx, getState());
11544 enterRule(_localctx, 342, RULE_breakStatement);
11545 int _la;
11546 try {
11547 enterOuterAlt(_localctx, 1);
11548 {
11549 setState(1875);
11550 match(BREAK);
11551 setState(1877);
11552 _errHandler.sync(this);
11553 _la = _input.LA(1);
11554 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) {
11555 {
11556 setState(1876);
11557 identifier();
11558 }
11559 }
11560
11561 setState(1879);
11562 match(SEMI);
11563 }
11564 }
11565 catch (RecognitionException re) {
11566 _localctx.exception = re;
11567 _errHandler.reportError(this, re);
11568 _errHandler.recover(this, re);
11569 }
11570 finally {
11571 exitRule();
11572 }
11573 return _localctx;
11574 }
11575
11576 public static class ContinueStatementContext extends ParserRuleContext {
11577 public IdentifierContext identifier() {
11578 return getRuleContext(IdentifierContext.class,0);
11579 }
11580 public ContinueStatementContext(ParserRuleContext parent, int invokingState) {
11581 super(parent, invokingState);
11582 }
11583 @Override public int getRuleIndex() { return RULE_continueStatement; }
11584 @Override
11585 public void enterRule(ParseTreeListener listener) {
11586 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterContinueStatement(this);
11587 }
11588 @Override
11589 public void exitRule(ParseTreeListener listener) {
11590 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitContinueStatement(this);
11591 }
11592 }
11593
11594 public final ContinueStatementContext continueStatement() throws RecognitionException {
11595 ContinueStatementContext _localctx = new ContinueStatementContext(_ctx, getState());
11596 enterRule(_localctx, 344, RULE_continueStatement);
11597 int _la;
11598 try {
11599 enterOuterAlt(_localctx, 1);
11600 {
11601 setState(1881);
11602 match(CONTINUE);
11603 setState(1883);
11604 _errHandler.sync(this);
11605 _la = _input.LA(1);
11606 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) {
11607 {
11608 setState(1882);
11609 identifier();
11610 }
11611 }
11612
11613 setState(1885);
11614 match(SEMI);
11615 }
11616 }
11617 catch (RecognitionException re) {
11618 _localctx.exception = re;
11619 _errHandler.reportError(this, re);
11620 _errHandler.recover(this, re);
11621 }
11622 finally {
11623 exitRule();
11624 }
11625 return _localctx;
11626 }
11627
11628 public static class ReturnStatementContext extends ParserRuleContext {
11629 public ExpressionContext expression() {
11630 return getRuleContext(ExpressionContext.class,0);
11631 }
11632 public ReturnStatementContext(ParserRuleContext parent, int invokingState) {
11633 super(parent, invokingState);
11634 }
11635 @Override public int getRuleIndex() { return RULE_returnStatement; }
11636 @Override
11637 public void enterRule(ParseTreeListener listener) {
11638 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterReturnStatement(this);
11639 }
11640 @Override
11641 public void exitRule(ParseTreeListener listener) {
11642 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitReturnStatement(this);
11643 }
11644 }
11645
11646 public final ReturnStatementContext returnStatement() throws RecognitionException {
11647 ReturnStatementContext _localctx = new ReturnStatementContext(_ctx, getState());
11648 enterRule(_localctx, 346, RULE_returnStatement);
11649 int _la;
11650 try {
11651 enterOuterAlt(_localctx, 1);
11652 {
11653 setState(1887);
11654 match(RETURN);
11655 setState(1889);
11656 _errHandler.sync(this);
11657 _la = _input.LA(1);
11658 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)) {
11659 {
11660 setState(1888);
11661 expression();
11662 }
11663 }
11664
11665 setState(1891);
11666 match(SEMI);
11667 }
11668 }
11669 catch (RecognitionException re) {
11670 _localctx.exception = re;
11671 _errHandler.reportError(this, re);
11672 _errHandler.recover(this, re);
11673 }
11674 finally {
11675 exitRule();
11676 }
11677 return _localctx;
11678 }
11679
11680 public static class ThrowStatementContext extends ParserRuleContext {
11681 public ExpressionContext expression() {
11682 return getRuleContext(ExpressionContext.class,0);
11683 }
11684 public ThrowStatementContext(ParserRuleContext parent, int invokingState) {
11685 super(parent, invokingState);
11686 }
11687 @Override public int getRuleIndex() { return RULE_throwStatement; }
11688 @Override
11689 public void enterRule(ParseTreeListener listener) {
11690 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterThrowStatement(this);
11691 }
11692 @Override
11693 public void exitRule(ParseTreeListener listener) {
11694 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitThrowStatement(this);
11695 }
11696 }
11697
11698 public final ThrowStatementContext throwStatement() throws RecognitionException {
11699 ThrowStatementContext _localctx = new ThrowStatementContext(_ctx, getState());
11700 enterRule(_localctx, 348, RULE_throwStatement);
11701 try {
11702 enterOuterAlt(_localctx, 1);
11703 {
11704 setState(1893);
11705 match(THROW);
11706 setState(1894);
11707 expression();
11708 setState(1895);
11709 match(SEMI);
11710 }
11711 }
11712 catch (RecognitionException re) {
11713 _localctx.exception = re;
11714 _errHandler.reportError(this, re);
11715 _errHandler.recover(this, re);
11716 }
11717 finally {
11718 exitRule();
11719 }
11720 return _localctx;
11721 }
11722
11723 public static class SynchronizedStatementContext extends ParserRuleContext {
11724 public ExpressionContext expression() {
11725 return getRuleContext(ExpressionContext.class,0);
11726 }
11727 public BlockContext block() {
11728 return getRuleContext(BlockContext.class,0);
11729 }
11730 public SynchronizedStatementContext(ParserRuleContext parent, int invokingState) {
11731 super(parent, invokingState);
11732 }
11733 @Override public int getRuleIndex() { return RULE_synchronizedStatement; }
11734 @Override
11735 public void enterRule(ParseTreeListener listener) {
11736 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterSynchronizedStatement(this);
11737 }
11738 @Override
11739 public void exitRule(ParseTreeListener listener) {
11740 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitSynchronizedStatement(this);
11741 }
11742 }
11743
11744 public final SynchronizedStatementContext synchronizedStatement() throws RecognitionException {
11745 SynchronizedStatementContext _localctx = new SynchronizedStatementContext(_ctx, getState());
11746 enterRule(_localctx, 350, RULE_synchronizedStatement);
11747 try {
11748 enterOuterAlt(_localctx, 1);
11749 {
11750 setState(1897);
11751 match(SYNCHRONIZED);
11752 setState(1898);
11753 match(LPAREN);
11754 setState(1899);
11755 expression();
11756 setState(1900);
11757 match(RPAREN);
11758 setState(1901);
11759 block();
11760 }
11761 }
11762 catch (RecognitionException re) {
11763 _localctx.exception = re;
11764 _errHandler.reportError(this, re);
11765 _errHandler.recover(this, re);
11766 }
11767 finally {
11768 exitRule();
11769 }
11770 return _localctx;
11771 }
11772
11773 public static class TryStatementContext extends ParserRuleContext {
11774 public BlockContext block() {
11775 return getRuleContext(BlockContext.class,0);
11776 }
11777 public CatchesContext catches() {
11778 return getRuleContext(CatchesContext.class,0);
11779 }
11780 public Finally_Context finally_() {
11781 return getRuleContext(Finally_Context.class,0);
11782 }
11783 public TryWithResourcesStatementContext tryWithResourcesStatement() {
11784 return getRuleContext(TryWithResourcesStatementContext.class,0);
11785 }
11786 public TryStatementContext(ParserRuleContext parent, int invokingState) {
11787 super(parent, invokingState);
11788 }
11789 @Override public int getRuleIndex() { return RULE_tryStatement; }
11790 @Override
11791 public void enterRule(ParseTreeListener listener) {
11792 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTryStatement(this);
11793 }
11794 @Override
11795 public void exitRule(ParseTreeListener listener) {
11796 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTryStatement(this);
11797 }
11798 }
11799
11800 public final TryStatementContext tryStatement() throws RecognitionException {
11801 TryStatementContext _localctx = new TryStatementContext(_ctx, getState());
11802 enterRule(_localctx, 352, RULE_tryStatement);
11803 int _la;
11804 try {
11805 setState(1915);
11806 _errHandler.sync(this);
11807 switch ( getInterpreter().adaptivePredict(_input,193,_ctx) ) {
11808 case 1:
11809 enterOuterAlt(_localctx, 1);
11810 {
11811 setState(1903);
11812 match(TRY);
11813 setState(1904);
11814 block();
11815 setState(1905);
11816 catches();
11817 }
11818 break;
11819 case 2:
11820 enterOuterAlt(_localctx, 2);
11821 {
11822 setState(1907);
11823 match(TRY);
11824 setState(1908);
11825 block();
11826 setState(1910);
11827 _errHandler.sync(this);
11828 _la = _input.LA(1);
11829 if (_la==CATCH) {
11830 {
11831 setState(1909);
11832 catches();
11833 }
11834 }
11835
11836 setState(1912);
11837 finally_();
11838 }
11839 break;
11840 case 3:
11841 enterOuterAlt(_localctx, 3);
11842 {
11843 setState(1914);
11844 tryWithResourcesStatement();
11845 }
11846 break;
11847 }
11848 }
11849 catch (RecognitionException re) {
11850 _localctx.exception = re;
11851 _errHandler.reportError(this, re);
11852 _errHandler.recover(this, re);
11853 }
11854 finally {
11855 exitRule();
11856 }
11857 return _localctx;
11858 }
11859
11860 public static class CatchesContext extends ParserRuleContext {
11861 public List<CatchClauseContext> catchClause() {
11862 return getRuleContexts(CatchClauseContext.class);
11863 }
11864 public CatchClauseContext catchClause(int i) {
11865 return getRuleContext(CatchClauseContext.class,i);
11866 }
11867 public CatchesContext(ParserRuleContext parent, int invokingState) {
11868 super(parent, invokingState);
11869 }
11870 @Override public int getRuleIndex() { return RULE_catches; }
11871 @Override
11872 public void enterRule(ParseTreeListener listener) {
11873 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterCatches(this);
11874 }
11875 @Override
11876 public void exitRule(ParseTreeListener listener) {
11877 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitCatches(this);
11878 }
11879 }
11880
11881 public final CatchesContext catches() throws RecognitionException {
11882 CatchesContext _localctx = new CatchesContext(_ctx, getState());
11883 enterRule(_localctx, 354, RULE_catches);
11884 int _la;
11885 try {
11886 enterOuterAlt(_localctx, 1);
11887 {
11888 setState(1918);
11889 _errHandler.sync(this);
11890 _la = _input.LA(1);
11891 do {
11892 {
11893 {
11894 setState(1917);
11895 catchClause();
11896 }
11897 }
11898 setState(1920);
11899 _errHandler.sync(this);
11900 _la = _input.LA(1);
11901 } while ( _la==CATCH );
11902 }
11903 }
11904 catch (RecognitionException re) {
11905 _localctx.exception = re;
11906 _errHandler.reportError(this, re);
11907 _errHandler.recover(this, re);
11908 }
11909 finally {
11910 exitRule();
11911 }
11912 return _localctx;
11913 }
11914
11915 public static class CatchClauseContext extends ParserRuleContext {
11916 public CatchFormalParameterContext catchFormalParameter() {
11917 return getRuleContext(CatchFormalParameterContext.class,0);
11918 }
11919 public BlockContext block() {
11920 return getRuleContext(BlockContext.class,0);
11921 }
11922 public CatchClauseContext(ParserRuleContext parent, int invokingState) {
11923 super(parent, invokingState);
11924 }
11925 @Override public int getRuleIndex() { return RULE_catchClause; }
11926 @Override
11927 public void enterRule(ParseTreeListener listener) {
11928 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterCatchClause(this);
11929 }
11930 @Override
11931 public void exitRule(ParseTreeListener listener) {
11932 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitCatchClause(this);
11933 }
11934 }
11935
11936 public final CatchClauseContext catchClause() throws RecognitionException {
11937 CatchClauseContext _localctx = new CatchClauseContext(_ctx, getState());
11938 enterRule(_localctx, 356, RULE_catchClause);
11939 try {
11940 enterOuterAlt(_localctx, 1);
11941 {
11942 setState(1922);
11943 match(CATCH);
11944 setState(1923);
11945 match(LPAREN);
11946 setState(1924);
11947 catchFormalParameter();
11948 setState(1925);
11949 match(RPAREN);
11950 setState(1926);
11951 block();
11952 }
11953 }
11954 catch (RecognitionException re) {
11955 _localctx.exception = re;
11956 _errHandler.reportError(this, re);
11957 _errHandler.recover(this, re);
11958 }
11959 finally {
11960 exitRule();
11961 }
11962 return _localctx;
11963 }
11964
11965 public static class CatchFormalParameterContext extends ParserRuleContext {
11966 public CatchTypeContext catchType() {
11967 return getRuleContext(CatchTypeContext.class,0);
11968 }
11969 public VariableDeclaratorIdContext variableDeclaratorId() {
11970 return getRuleContext(VariableDeclaratorIdContext.class,0);
11971 }
11972 public List<VariableModifierContext> variableModifier() {
11973 return getRuleContexts(VariableModifierContext.class);
11974 }
11975 public VariableModifierContext variableModifier(int i) {
11976 return getRuleContext(VariableModifierContext.class,i);
11977 }
11978 public CatchFormalParameterContext(ParserRuleContext parent, int invokingState) {
11979 super(parent, invokingState);
11980 }
11981 @Override public int getRuleIndex() { return RULE_catchFormalParameter; }
11982 @Override
11983 public void enterRule(ParseTreeListener listener) {
11984 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterCatchFormalParameter(this);
11985 }
11986 @Override
11987 public void exitRule(ParseTreeListener listener) {
11988 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitCatchFormalParameter(this);
11989 }
11990 }
11991
11992 public final CatchFormalParameterContext catchFormalParameter() throws RecognitionException {
11993 CatchFormalParameterContext _localctx = new CatchFormalParameterContext(_ctx, getState());
11994 enterRule(_localctx, 358, RULE_catchFormalParameter);
11995 int _la;
11996 try {
11997 enterOuterAlt(_localctx, 1);
11998 {
11999 setState(1931);
12000 _errHandler.sync(this);
12001 _la = _input.LA(1);
12002 while (_la==FINAL || _la==AT) {
12003 {
12004 {
12005 setState(1928);
12006 variableModifier();
12007 }
12008 }
12009 setState(1933);
12010 _errHandler.sync(this);
12011 _la = _input.LA(1);
12012 }
12013 setState(1934);
12014 catchType();
12015 setState(1935);
12016 variableDeclaratorId();
12017 }
12018 }
12019 catch (RecognitionException re) {
12020 _localctx.exception = re;
12021 _errHandler.reportError(this, re);
12022 _errHandler.recover(this, re);
12023 }
12024 finally {
12025 exitRule();
12026 }
12027 return _localctx;
12028 }
12029
12030 public static class CatchTypeContext extends ParserRuleContext {
12031 public UnannClassTypeContext unannClassType() {
12032 return getRuleContext(UnannClassTypeContext.class,0);
12033 }
12034 public List<ClassTypeContext> classType() {
12035 return getRuleContexts(ClassTypeContext.class);
12036 }
12037 public ClassTypeContext classType(int i) {
12038 return getRuleContext(ClassTypeContext.class,i);
12039 }
12040 public CatchTypeContext(ParserRuleContext parent, int invokingState) {
12041 super(parent, invokingState);
12042 }
12043 @Override public int getRuleIndex() { return RULE_catchType; }
12044 @Override
12045 public void enterRule(ParseTreeListener listener) {
12046 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterCatchType(this);
12047 }
12048 @Override
12049 public void exitRule(ParseTreeListener listener) {
12050 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitCatchType(this);
12051 }
12052 }
12053
12054 public final CatchTypeContext catchType() throws RecognitionException {
12055 CatchTypeContext _localctx = new CatchTypeContext(_ctx, getState());
12056 enterRule(_localctx, 360, RULE_catchType);
12057 int _la;
12058 try {
12059 enterOuterAlt(_localctx, 1);
12060 {
12061 setState(1937);
12062 unannClassType();
12063 setState(1942);
12064 _errHandler.sync(this);
12065 _la = _input.LA(1);
12066 while (_la==BITOR) {
12067 {
12068 {
12069 setState(1938);
12070 match(BITOR);
12071 setState(1939);
12072 classType();
12073 }
12074 }
12075 setState(1944);
12076 _errHandler.sync(this);
12077 _la = _input.LA(1);
12078 }
12079 }
12080 }
12081 catch (RecognitionException re) {
12082 _localctx.exception = re;
12083 _errHandler.reportError(this, re);
12084 _errHandler.recover(this, re);
12085 }
12086 finally {
12087 exitRule();
12088 }
12089 return _localctx;
12090 }
12091
12092 public static class Finally_Context extends ParserRuleContext {
12093 public BlockContext block() {
12094 return getRuleContext(BlockContext.class,0);
12095 }
12096 public Finally_Context(ParserRuleContext parent, int invokingState) {
12097 super(parent, invokingState);
12098 }
12099 @Override public int getRuleIndex() { return RULE_finally_; }
12100 @Override
12101 public void enterRule(ParseTreeListener listener) {
12102 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterFinally_(this);
12103 }
12104 @Override
12105 public void exitRule(ParseTreeListener listener) {
12106 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitFinally_(this);
12107 }
12108 }
12109
12110 public final Finally_Context finally_() throws RecognitionException {
12111 Finally_Context _localctx = new Finally_Context(_ctx, getState());
12112 enterRule(_localctx, 362, RULE_finally_);
12113 try {
12114 enterOuterAlt(_localctx, 1);
12115 {
12116 setState(1945);
12117 match(FINALLY);
12118 setState(1946);
12119 block();
12120 }
12121 }
12122 catch (RecognitionException re) {
12123 _localctx.exception = re;
12124 _errHandler.reportError(this, re);
12125 _errHandler.recover(this, re);
12126 }
12127 finally {
12128 exitRule();
12129 }
12130 return _localctx;
12131 }
12132
12133 public static class TryWithResourcesStatementContext extends ParserRuleContext {
12134 public ResourceSpecificationContext resourceSpecification() {
12135 return getRuleContext(ResourceSpecificationContext.class,0);
12136 }
12137 public BlockContext block() {
12138 return getRuleContext(BlockContext.class,0);
12139 }
12140 public CatchesContext catches() {
12141 return getRuleContext(CatchesContext.class,0);
12142 }
12143 public Finally_Context finally_() {
12144 return getRuleContext(Finally_Context.class,0);
12145 }
12146 public TryWithResourcesStatementContext(ParserRuleContext parent, int invokingState) {
12147 super(parent, invokingState);
12148 }
12149 @Override public int getRuleIndex() { return RULE_tryWithResourcesStatement; }
12150 @Override
12151 public void enterRule(ParseTreeListener listener) {
12152 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTryWithResourcesStatement(this);
12153 }
12154 @Override
12155 public void exitRule(ParseTreeListener listener) {
12156 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTryWithResourcesStatement(this);
12157 }
12158 }
12159
12160 public final TryWithResourcesStatementContext tryWithResourcesStatement() throws RecognitionException {
12161 TryWithResourcesStatementContext _localctx = new TryWithResourcesStatementContext(_ctx, getState());
12162 enterRule(_localctx, 364, RULE_tryWithResourcesStatement);
12163 int _la;
12164 try {
12165 enterOuterAlt(_localctx, 1);
12166 {
12167 setState(1948);
12168 match(TRY);
12169 setState(1949);
12170 resourceSpecification();
12171 setState(1950);
12172 block();
12173 setState(1952);
12174 _errHandler.sync(this);
12175 _la = _input.LA(1);
12176 if (_la==CATCH) {
12177 {
12178 setState(1951);
12179 catches();
12180 }
12181 }
12182
12183 setState(1955);
12184 _errHandler.sync(this);
12185 _la = _input.LA(1);
12186 if (_la==FINALLY) {
12187 {
12188 setState(1954);
12189 finally_();
12190 }
12191 }
12192
12193 }
12194 }
12195 catch (RecognitionException re) {
12196 _localctx.exception = re;
12197 _errHandler.reportError(this, re);
12198 _errHandler.recover(this, re);
12199 }
12200 finally {
12201 exitRule();
12202 }
12203 return _localctx;
12204 }
12205
12206 public static class ResourceSpecificationContext extends ParserRuleContext {
12207 public ResourceListContext resourceList() {
12208 return getRuleContext(ResourceListContext.class,0);
12209 }
12210 public ResourceSpecificationContext(ParserRuleContext parent, int invokingState) {
12211 super(parent, invokingState);
12212 }
12213 @Override public int getRuleIndex() { return RULE_resourceSpecification; }
12214 @Override
12215 public void enterRule(ParseTreeListener listener) {
12216 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterResourceSpecification(this);
12217 }
12218 @Override
12219 public void exitRule(ParseTreeListener listener) {
12220 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitResourceSpecification(this);
12221 }
12222 }
12223
12224 public final ResourceSpecificationContext resourceSpecification() throws RecognitionException {
12225 ResourceSpecificationContext _localctx = new ResourceSpecificationContext(_ctx, getState());
12226 enterRule(_localctx, 366, RULE_resourceSpecification);
12227 int _la;
12228 try {
12229 enterOuterAlt(_localctx, 1);
12230 {
12231 setState(1957);
12232 match(LPAREN);
12233 setState(1958);
12234 resourceList();
12235 setState(1960);
12236 _errHandler.sync(this);
12237 _la = _input.LA(1);
12238 if (_la==SEMI) {
12239 {
12240 setState(1959);
12241 match(SEMI);
12242 }
12243 }
12244
12245 setState(1962);
12246 match(RPAREN);
12247 }
12248 }
12249 catch (RecognitionException re) {
12250 _localctx.exception = re;
12251 _errHandler.reportError(this, re);
12252 _errHandler.recover(this, re);
12253 }
12254 finally {
12255 exitRule();
12256 }
12257 return _localctx;
12258 }
12259
12260 public static class ResourceListContext extends ParserRuleContext {
12261 public List<ResourceContext> resource() {
12262 return getRuleContexts(ResourceContext.class);
12263 }
12264 public ResourceContext resource(int i) {
12265 return getRuleContext(ResourceContext.class,i);
12266 }
12267 public ResourceListContext(ParserRuleContext parent, int invokingState) {
12268 super(parent, invokingState);
12269 }
12270 @Override public int getRuleIndex() { return RULE_resourceList; }
12271 @Override
12272 public void enterRule(ParseTreeListener listener) {
12273 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterResourceList(this);
12274 }
12275 @Override
12276 public void exitRule(ParseTreeListener listener) {
12277 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitResourceList(this);
12278 }
12279 }
12280
12281 public final ResourceListContext resourceList() throws RecognitionException {
12282 ResourceListContext _localctx = new ResourceListContext(_ctx, getState());
12283 enterRule(_localctx, 368, RULE_resourceList);
12284 try {
12285 int _alt;
12286 enterOuterAlt(_localctx, 1);
12287 {
12288 setState(1964);
12289 resource();
12290 setState(1969);
12291 _errHandler.sync(this);
12292 _alt = getInterpreter().adaptivePredict(_input,200,_ctx);
12293 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
12294 if ( _alt==1 ) {
12295 {
12296 {
12297 setState(1965);
12298 match(SEMI);
12299 setState(1966);
12300 resource();
12301 }
12302 }
12303 }
12304 setState(1971);
12305 _errHandler.sync(this);
12306 _alt = getInterpreter().adaptivePredict(_input,200,_ctx);
12307 }
12308 }
12309 }
12310 catch (RecognitionException re) {
12311 _localctx.exception = re;
12312 _errHandler.reportError(this, re);
12313 _errHandler.recover(this, re);
12314 }
12315 finally {
12316 exitRule();
12317 }
12318 return _localctx;
12319 }
12320
12321 public static class ResourceContext extends ParserRuleContext {
12322 public UnannTypeContext unannType() {
12323 return getRuleContext(UnannTypeContext.class,0);
12324 }
12325 public VariableDeclaratorIdContext variableDeclaratorId() {
12326 return getRuleContext(VariableDeclaratorIdContext.class,0);
12327 }
12328 public ExpressionContext expression() {
12329 return getRuleContext(ExpressionContext.class,0);
12330 }
12331 public List<VariableModifierContext> variableModifier() {
12332 return getRuleContexts(VariableModifierContext.class);
12333 }
12334 public VariableModifierContext variableModifier(int i) {
12335 return getRuleContext(VariableModifierContext.class,i);
12336 }
12337 public VariableAccessContext variableAccess() {
12338 return getRuleContext(VariableAccessContext.class,0);
12339 }
12340 public ResourceContext(ParserRuleContext parent, int invokingState) {
12341 super(parent, invokingState);
12342 }
12343 @Override public int getRuleIndex() { return RULE_resource; }
12344 @Override
12345 public void enterRule(ParseTreeListener listener) {
12346 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterResource(this);
12347 }
12348 @Override
12349 public void exitRule(ParseTreeListener listener) {
12350 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitResource(this);
12351 }
12352 }
12353
12354 public final ResourceContext resource() throws RecognitionException {
12355 ResourceContext _localctx = new ResourceContext(_ctx, getState());
12356 enterRule(_localctx, 370, RULE_resource);
12357 int _la;
12358 try {
12359 setState(1984);
12360 _errHandler.sync(this);
12361 switch ( getInterpreter().adaptivePredict(_input,202,_ctx) ) {
12362 case 1:
12363 enterOuterAlt(_localctx, 1);
12364 {
12365 setState(1975);
12366 _errHandler.sync(this);
12367 _la = _input.LA(1);
12368 while (_la==FINAL || _la==AT) {
12369 {
12370 {
12371 setState(1972);
12372 variableModifier();
12373 }
12374 }
12375 setState(1977);
12376 _errHandler.sync(this);
12377 _la = _input.LA(1);
12378 }
12379 setState(1978);
12380 unannType();
12381 setState(1979);
12382 variableDeclaratorId();
12383 setState(1980);
12384 match(ASSIGN);
12385 setState(1981);
12386 expression();
12387 }
12388 break;
12389 case 2:
12390 enterOuterAlt(_localctx, 2);
12391 {
12392 setState(1983);
12393 variableAccess();
12394 }
12395 break;
12396 }
12397 }
12398 catch (RecognitionException re) {
12399 _localctx.exception = re;
12400 _errHandler.reportError(this, re);
12401 _errHandler.recover(this, re);
12402 }
12403 finally {
12404 exitRule();
12405 }
12406 return _localctx;
12407 }
12408
12409 public static class VariableAccessContext extends ParserRuleContext {
12410 public ExpressionNameContext expressionName() {
12411 return getRuleContext(ExpressionNameContext.class,0);
12412 }
12413 public FieldAccessContext fieldAccess() {
12414 return getRuleContext(FieldAccessContext.class,0);
12415 }
12416 public VariableAccessContext(ParserRuleContext parent, int invokingState) {
12417 super(parent, invokingState);
12418 }
12419 @Override public int getRuleIndex() { return RULE_variableAccess; }
12420 @Override
12421 public void enterRule(ParseTreeListener listener) {
12422 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterVariableAccess(this);
12423 }
12424 @Override
12425 public void exitRule(ParseTreeListener listener) {
12426 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitVariableAccess(this);
12427 }
12428 }
12429
12430 public final VariableAccessContext variableAccess() throws RecognitionException {
12431 VariableAccessContext _localctx = new VariableAccessContext(_ctx, getState());
12432 enterRule(_localctx, 372, RULE_variableAccess);
12433 try {
12434 setState(1988);
12435 _errHandler.sync(this);
12436 switch ( getInterpreter().adaptivePredict(_input,203,_ctx) ) {
12437 case 1:
12438 enterOuterAlt(_localctx, 1);
12439 {
12440 setState(1986);
12441 expressionName();
12442 }
12443 break;
12444 case 2:
12445 enterOuterAlt(_localctx, 2);
12446 {
12447 setState(1987);
12448 fieldAccess();
12449 }
12450 break;
12451 }
12452 }
12453 catch (RecognitionException re) {
12454 _localctx.exception = re;
12455 _errHandler.reportError(this, re);
12456 _errHandler.recover(this, re);
12457 }
12458 finally {
12459 exitRule();
12460 }
12461 return _localctx;
12462 }
12463
12464 public static class PrimaryContext extends ParserRuleContext {
12465 public PrimaryNoNewArray_lfno_primaryContext primaryNoNewArray_lfno_primary() {
12466 return getRuleContext(PrimaryNoNewArray_lfno_primaryContext.class,0);
12467 }
12468 public ArrayCreationExpressionContext arrayCreationExpression() {
12469 return getRuleContext(ArrayCreationExpressionContext.class,0);
12470 }
12471 public List<PrimaryNoNewArray_lf_primaryContext> primaryNoNewArray_lf_primary() {
12472 return getRuleContexts(PrimaryNoNewArray_lf_primaryContext.class);
12473 }
12474 public PrimaryNoNewArray_lf_primaryContext primaryNoNewArray_lf_primary(int i) {
12475 return getRuleContext(PrimaryNoNewArray_lf_primaryContext.class,i);
12476 }
12477 public PrimaryContext(ParserRuleContext parent, int invokingState) {
12478 super(parent, invokingState);
12479 }
12480 @Override public int getRuleIndex() { return RULE_primary; }
12481 @Override
12482 public void enterRule(ParseTreeListener listener) {
12483 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPrimary(this);
12484 }
12485 @Override
12486 public void exitRule(ParseTreeListener listener) {
12487 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPrimary(this);
12488 }
12489 }
12490
12491 public final PrimaryContext primary() throws RecognitionException {
12492 PrimaryContext _localctx = new PrimaryContext(_ctx, getState());
12493 enterRule(_localctx, 374, RULE_primary);
12494 try {
12495 int _alt;
12496 enterOuterAlt(_localctx, 1);
12497 {
12498 setState(1992);
12499 _errHandler.sync(this);
12500 switch ( getInterpreter().adaptivePredict(_input,204,_ctx) ) {
12501 case 1:
12502 {
12503 setState(1990);
12504 primaryNoNewArray_lfno_primary();
12505 }
12506 break;
12507 case 2:
12508 {
12509 setState(1991);
12510 arrayCreationExpression();
12511 }
12512 break;
12513 }
12514 setState(1997);
12515 _errHandler.sync(this);
12516 _alt = getInterpreter().adaptivePredict(_input,205,_ctx);
12517 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
12518 if ( _alt==1 ) {
12519 {
12520 {
12521 setState(1994);
12522 primaryNoNewArray_lf_primary();
12523 }
12524 }
12525 }
12526 setState(1999);
12527 _errHandler.sync(this);
12528 _alt = getInterpreter().adaptivePredict(_input,205,_ctx);
12529 }
12530 }
12531 }
12532 catch (RecognitionException re) {
12533 _localctx.exception = re;
12534 _errHandler.reportError(this, re);
12535 _errHandler.recover(this, re);
12536 }
12537 finally {
12538 exitRule();
12539 }
12540 return _localctx;
12541 }
12542
12543 public static class PrimaryNoNewArrayContext extends ParserRuleContext {
12544 public LiteralContext literal() {
12545 return getRuleContext(LiteralContext.class,0);
12546 }
12547 public ClassLiteralContext classLiteral() {
12548 return getRuleContext(ClassLiteralContext.class,0);
12549 }
12550 public TypeNameContext typeName() {
12551 return getRuleContext(TypeNameContext.class,0);
12552 }
12553 public ExpressionContext expression() {
12554 return getRuleContext(ExpressionContext.class,0);
12555 }
12556 public ClassInstanceCreationExpressionContext classInstanceCreationExpression() {
12557 return getRuleContext(ClassInstanceCreationExpressionContext.class,0);
12558 }
12559 public FieldAccessContext fieldAccess() {
12560 return getRuleContext(FieldAccessContext.class,0);
12561 }
12562 public ArrayAccessContext arrayAccess() {
12563 return getRuleContext(ArrayAccessContext.class,0);
12564 }
12565 public MethodInvocationContext methodInvocation() {
12566 return getRuleContext(MethodInvocationContext.class,0);
12567 }
12568 public MethodReferenceContext methodReference() {
12569 return getRuleContext(MethodReferenceContext.class,0);
12570 }
12571 public PrimaryNoNewArrayContext(ParserRuleContext parent, int invokingState) {
12572 super(parent, invokingState);
12573 }
12574 @Override public int getRuleIndex() { return RULE_primaryNoNewArray; }
12575 @Override
12576 public void enterRule(ParseTreeListener listener) {
12577 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPrimaryNoNewArray(this);
12578 }
12579 @Override
12580 public void exitRule(ParseTreeListener listener) {
12581 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPrimaryNoNewArray(this);
12582 }
12583 }
12584
12585 public final PrimaryNoNewArrayContext primaryNoNewArray() throws RecognitionException {
12586 PrimaryNoNewArrayContext _localctx = new PrimaryNoNewArrayContext(_ctx, getState());
12587 enterRule(_localctx, 376, RULE_primaryNoNewArray);
12588 try {
12589 setState(2016);
12590 _errHandler.sync(this);
12591 switch ( getInterpreter().adaptivePredict(_input,206,_ctx) ) {
12592 case 1:
12593 enterOuterAlt(_localctx, 1);
12594 {
12595 setState(2000);
12596 literal();
12597 }
12598 break;
12599 case 2:
12600 enterOuterAlt(_localctx, 2);
12601 {
12602 setState(2001);
12603 classLiteral();
12604 }
12605 break;
12606 case 3:
12607 enterOuterAlt(_localctx, 3);
12608 {
12609 setState(2002);
12610 match(THIS);
12611 }
12612 break;
12613 case 4:
12614 enterOuterAlt(_localctx, 4);
12615 {
12616 setState(2003);
12617 typeName();
12618 setState(2004);
12619 match(DOT);
12620 setState(2005);
12621 match(THIS);
12622 }
12623 break;
12624 case 5:
12625 enterOuterAlt(_localctx, 5);
12626 {
12627 setState(2007);
12628 match(LPAREN);
12629 setState(2008);
12630 expression();
12631 setState(2009);
12632 match(RPAREN);
12633 }
12634 break;
12635 case 6:
12636 enterOuterAlt(_localctx, 6);
12637 {
12638 setState(2011);
12639 classInstanceCreationExpression();
12640 }
12641 break;
12642 case 7:
12643 enterOuterAlt(_localctx, 7);
12644 {
12645 setState(2012);
12646 fieldAccess();
12647 }
12648 break;
12649 case 8:
12650 enterOuterAlt(_localctx, 8);
12651 {
12652 setState(2013);
12653 arrayAccess();
12654 }
12655 break;
12656 case 9:
12657 enterOuterAlt(_localctx, 9);
12658 {
12659 setState(2014);
12660 methodInvocation();
12661 }
12662 break;
12663 case 10:
12664 enterOuterAlt(_localctx, 10);
12665 {
12666 setState(2015);
12667 methodReference();
12668 }
12669 break;
12670 }
12671 }
12672 catch (RecognitionException re) {
12673 _localctx.exception = re;
12674 _errHandler.reportError(this, re);
12675 _errHandler.recover(this, re);
12676 }
12677 finally {
12678 exitRule();
12679 }
12680 return _localctx;
12681 }
12682
12683 public static class PrimaryNoNewArray_lf_arrayAccessContext extends ParserRuleContext {
12684 public PrimaryNoNewArray_lf_arrayAccessContext(ParserRuleContext parent, int invokingState) {
12685 super(parent, invokingState);
12686 }
12687 @Override public int getRuleIndex() { return RULE_primaryNoNewArray_lf_arrayAccess; }
12688 @Override
12689 public void enterRule(ParseTreeListener listener) {
12690 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPrimaryNoNewArray_lf_arrayAccess(this);
12691 }
12692 @Override
12693 public void exitRule(ParseTreeListener listener) {
12694 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPrimaryNoNewArray_lf_arrayAccess(this);
12695 }
12696 }
12697
12698 public final PrimaryNoNewArray_lf_arrayAccessContext primaryNoNewArray_lf_arrayAccess() throws RecognitionException {
12699 PrimaryNoNewArray_lf_arrayAccessContext _localctx = new PrimaryNoNewArray_lf_arrayAccessContext(_ctx, getState());
12700 enterRule(_localctx, 378, RULE_primaryNoNewArray_lf_arrayAccess);
12701 try {
12702 enterOuterAlt(_localctx, 1);
12703 {
12704 }
12705 }
12706 catch (RecognitionException re) {
12707 _localctx.exception = re;
12708 _errHandler.reportError(this, re);
12709 _errHandler.recover(this, re);
12710 }
12711 finally {
12712 exitRule();
12713 }
12714 return _localctx;
12715 }
12716
12717 public static class PrimaryNoNewArray_lfno_arrayAccessContext extends ParserRuleContext {
12718 public LiteralContext literal() {
12719 return getRuleContext(LiteralContext.class,0);
12720 }
12721 public TypeNameContext typeName() {
12722 return getRuleContext(TypeNameContext.class,0);
12723 }
12724 public ExpressionContext expression() {
12725 return getRuleContext(ExpressionContext.class,0);
12726 }
12727 public ClassInstanceCreationExpressionContext classInstanceCreationExpression() {
12728 return getRuleContext(ClassInstanceCreationExpressionContext.class,0);
12729 }
12730 public FieldAccessContext fieldAccess() {
12731 return getRuleContext(FieldAccessContext.class,0);
12732 }
12733 public MethodInvocationContext methodInvocation() {
12734 return getRuleContext(MethodInvocationContext.class,0);
12735 }
12736 public MethodReferenceContext methodReference() {
12737 return getRuleContext(MethodReferenceContext.class,0);
12738 }
12739 public PrimaryNoNewArray_lfno_arrayAccessContext(ParserRuleContext parent, int invokingState) {
12740 super(parent, invokingState);
12741 }
12742 @Override public int getRuleIndex() { return RULE_primaryNoNewArray_lfno_arrayAccess; }
12743 @Override
12744 public void enterRule(ParseTreeListener listener) {
12745 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPrimaryNoNewArray_lfno_arrayAccess(this);
12746 }
12747 @Override
12748 public void exitRule(ParseTreeListener listener) {
12749 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPrimaryNoNewArray_lfno_arrayAccess(this);
12750 }
12751 }
12752
12753 public final PrimaryNoNewArray_lfno_arrayAccessContext primaryNoNewArray_lfno_arrayAccess() throws RecognitionException {
12754 PrimaryNoNewArray_lfno_arrayAccessContext _localctx = new PrimaryNoNewArray_lfno_arrayAccessContext(_ctx, getState());
12755 enterRule(_localctx, 380, RULE_primaryNoNewArray_lfno_arrayAccess);
12756 int _la;
12757 try {
12758 setState(2048);
12759 _errHandler.sync(this);
12760 switch ( getInterpreter().adaptivePredict(_input,208,_ctx) ) {
12761 case 1:
12762 enterOuterAlt(_localctx, 1);
12763 {
12764 setState(2020);
12765 literal();
12766 }
12767 break;
12768 case 2:
12769 enterOuterAlt(_localctx, 2);
12770 {
12771 setState(2021);
12772 typeName();
12773 setState(2026);
12774 _errHandler.sync(this);
12775 _la = _input.LA(1);
12776 while (_la==LBRACK) {
12777 {
12778 {
12779 setState(2022);
12780 match(LBRACK);
12781 setState(2023);
12782 match(RBRACK);
12783 }
12784 }
12785 setState(2028);
12786 _errHandler.sync(this);
12787 _la = _input.LA(1);
12788 }
12789 setState(2029);
12790 match(DOT);
12791 setState(2030);
12792 match(CLASS);
12793 }
12794 break;
12795 case 3:
12796 enterOuterAlt(_localctx, 3);
12797 {
12798 setState(2032);
12799 match(VOID);
12800 setState(2033);
12801 match(DOT);
12802 setState(2034);
12803 match(CLASS);
12804 }
12805 break;
12806 case 4:
12807 enterOuterAlt(_localctx, 4);
12808 {
12809 setState(2035);
12810 match(THIS);
12811 }
12812 break;
12813 case 5:
12814 enterOuterAlt(_localctx, 5);
12815 {
12816 setState(2036);
12817 typeName();
12818 setState(2037);
12819 match(DOT);
12820 setState(2038);
12821 match(THIS);
12822 }
12823 break;
12824 case 6:
12825 enterOuterAlt(_localctx, 6);
12826 {
12827 setState(2040);
12828 match(LPAREN);
12829 setState(2041);
12830 expression();
12831 setState(2042);
12832 match(RPAREN);
12833 }
12834 break;
12835 case 7:
12836 enterOuterAlt(_localctx, 7);
12837 {
12838 setState(2044);
12839 classInstanceCreationExpression();
12840 }
12841 break;
12842 case 8:
12843 enterOuterAlt(_localctx, 8);
12844 {
12845 setState(2045);
12846 fieldAccess();
12847 }
12848 break;
12849 case 9:
12850 enterOuterAlt(_localctx, 9);
12851 {
12852 setState(2046);
12853 methodInvocation();
12854 }
12855 break;
12856 case 10:
12857 enterOuterAlt(_localctx, 10);
12858 {
12859 setState(2047);
12860 methodReference();
12861 }
12862 break;
12863 }
12864 }
12865 catch (RecognitionException re) {
12866 _localctx.exception = re;
12867 _errHandler.reportError(this, re);
12868 _errHandler.recover(this, re);
12869 }
12870 finally {
12871 exitRule();
12872 }
12873 return _localctx;
12874 }
12875
12876 public static class PrimaryNoNewArray_lf_primaryContext extends ParserRuleContext {
12877 public ClassInstanceCreationExpression_lf_primaryContext classInstanceCreationExpression_lf_primary() {
12878 return getRuleContext(ClassInstanceCreationExpression_lf_primaryContext.class,0);
12879 }
12880 public FieldAccess_lf_primaryContext fieldAccess_lf_primary() {
12881 return getRuleContext(FieldAccess_lf_primaryContext.class,0);
12882 }
12883 public ArrayAccess_lf_primaryContext arrayAccess_lf_primary() {
12884 return getRuleContext(ArrayAccess_lf_primaryContext.class,0);
12885 }
12886 public MethodInvocation_lf_primaryContext methodInvocation_lf_primary() {
12887 return getRuleContext(MethodInvocation_lf_primaryContext.class,0);
12888 }
12889 public MethodReference_lf_primaryContext methodReference_lf_primary() {
12890 return getRuleContext(MethodReference_lf_primaryContext.class,0);
12891 }
12892 public PrimaryNoNewArray_lf_primaryContext(ParserRuleContext parent, int invokingState) {
12893 super(parent, invokingState);
12894 }
12895 @Override public int getRuleIndex() { return RULE_primaryNoNewArray_lf_primary; }
12896 @Override
12897 public void enterRule(ParseTreeListener listener) {
12898 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPrimaryNoNewArray_lf_primary(this);
12899 }
12900 @Override
12901 public void exitRule(ParseTreeListener listener) {
12902 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPrimaryNoNewArray_lf_primary(this);
12903 }
12904 }
12905
12906 public final PrimaryNoNewArray_lf_primaryContext primaryNoNewArray_lf_primary() throws RecognitionException {
12907 PrimaryNoNewArray_lf_primaryContext _localctx = new PrimaryNoNewArray_lf_primaryContext(_ctx, getState());
12908 enterRule(_localctx, 382, RULE_primaryNoNewArray_lf_primary);
12909 try {
12910 setState(2055);
12911 _errHandler.sync(this);
12912 switch ( getInterpreter().adaptivePredict(_input,209,_ctx) ) {
12913 case 1:
12914 enterOuterAlt(_localctx, 1);
12915 {
12916 setState(2050);
12917 classInstanceCreationExpression_lf_primary();
12918 }
12919 break;
12920 case 2:
12921 enterOuterAlt(_localctx, 2);
12922 {
12923 setState(2051);
12924 fieldAccess_lf_primary();
12925 }
12926 break;
12927 case 3:
12928 enterOuterAlt(_localctx, 3);
12929 {
12930 setState(2052);
12931 arrayAccess_lf_primary();
12932 }
12933 break;
12934 case 4:
12935 enterOuterAlt(_localctx, 4);
12936 {
12937 setState(2053);
12938 methodInvocation_lf_primary();
12939 }
12940 break;
12941 case 5:
12942 enterOuterAlt(_localctx, 5);
12943 {
12944 setState(2054);
12945 methodReference_lf_primary();
12946 }
12947 break;
12948 }
12949 }
12950 catch (RecognitionException re) {
12951 _localctx.exception = re;
12952 _errHandler.reportError(this, re);
12953 _errHandler.recover(this, re);
12954 }
12955 finally {
12956 exitRule();
12957 }
12958 return _localctx;
12959 }
12960
12961 public static class PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext extends ParserRuleContext {
12962 public PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext(ParserRuleContext parent, int invokingState) {
12963 super(parent, invokingState);
12964 }
12965 @Override public int getRuleIndex() { return RULE_primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary; }
12966 @Override
12967 public void enterRule(ParseTreeListener listener) {
12968 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary(this);
12969 }
12970 @Override
12971 public void exitRule(ParseTreeListener listener) {
12972 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary(this);
12973 }
12974 }
12975
12976 public final PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary() throws RecognitionException {
12977 PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext _localctx = new PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext(_ctx, getState());
12978 enterRule(_localctx, 384, RULE_primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary);
12979 try {
12980 enterOuterAlt(_localctx, 1);
12981 {
12982 }
12983 }
12984 catch (RecognitionException re) {
12985 _localctx.exception = re;
12986 _errHandler.reportError(this, re);
12987 _errHandler.recover(this, re);
12988 }
12989 finally {
12990 exitRule();
12991 }
12992 return _localctx;
12993 }
12994
12995 public static class PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext extends ParserRuleContext {
12996 public ClassInstanceCreationExpression_lf_primaryContext classInstanceCreationExpression_lf_primary() {
12997 return getRuleContext(ClassInstanceCreationExpression_lf_primaryContext.class,0);
12998 }
12999 public FieldAccess_lf_primaryContext fieldAccess_lf_primary() {
13000 return getRuleContext(FieldAccess_lf_primaryContext.class,0);
13001 }
13002 public MethodInvocation_lf_primaryContext methodInvocation_lf_primary() {
13003 return getRuleContext(MethodInvocation_lf_primaryContext.class,0);
13004 }
13005 public MethodReference_lf_primaryContext methodReference_lf_primary() {
13006 return getRuleContext(MethodReference_lf_primaryContext.class,0);
13007 }
13008 public PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext(ParserRuleContext parent, int invokingState) {
13009 super(parent, invokingState);
13010 }
13011 @Override public int getRuleIndex() { return RULE_primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary; }
13012 @Override
13013 public void enterRule(ParseTreeListener listener) {
13014 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary(this);
13015 }
13016 @Override
13017 public void exitRule(ParseTreeListener listener) {
13018 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary(this);
13019 }
13020 }
13021
13022 public final PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary() throws RecognitionException {
13023 PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext _localctx = new PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext(_ctx, getState());
13024 enterRule(_localctx, 386, RULE_primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary);
13025 try {
13026 setState(2063);
13027 _errHandler.sync(this);
13028 switch ( getInterpreter().adaptivePredict(_input,210,_ctx) ) {
13029 case 1:
13030 enterOuterAlt(_localctx, 1);
13031 {
13032 setState(2059);
13033 classInstanceCreationExpression_lf_primary();
13034 }
13035 break;
13036 case 2:
13037 enterOuterAlt(_localctx, 2);
13038 {
13039 setState(2060);
13040 fieldAccess_lf_primary();
13041 }
13042 break;
13043 case 3:
13044 enterOuterAlt(_localctx, 3);
13045 {
13046 setState(2061);
13047 methodInvocation_lf_primary();
13048 }
13049 break;
13050 case 4:
13051 enterOuterAlt(_localctx, 4);
13052 {
13053 setState(2062);
13054 methodReference_lf_primary();
13055 }
13056 break;
13057 }
13058 }
13059 catch (RecognitionException re) {
13060 _localctx.exception = re;
13061 _errHandler.reportError(this, re);
13062 _errHandler.recover(this, re);
13063 }
13064 finally {
13065 exitRule();
13066 }
13067 return _localctx;
13068 }
13069
13070 public static class PrimaryNoNewArray_lfno_primaryContext extends ParserRuleContext {
13071 public LiteralContext literal() {
13072 return getRuleContext(LiteralContext.class,0);
13073 }
13074 public TypeNameContext typeName() {
13075 return getRuleContext(TypeNameContext.class,0);
13076 }
13077 public UnannPrimitiveTypeContext unannPrimitiveType() {
13078 return getRuleContext(UnannPrimitiveTypeContext.class,0);
13079 }
13080 public ExpressionContext expression() {
13081 return getRuleContext(ExpressionContext.class,0);
13082 }
13083 public ClassInstanceCreationExpression_lfno_primaryContext classInstanceCreationExpression_lfno_primary() {
13084 return getRuleContext(ClassInstanceCreationExpression_lfno_primaryContext.class,0);
13085 }
13086 public FieldAccess_lfno_primaryContext fieldAccess_lfno_primary() {
13087 return getRuleContext(FieldAccess_lfno_primaryContext.class,0);
13088 }
13089 public ArrayAccess_lfno_primaryContext arrayAccess_lfno_primary() {
13090 return getRuleContext(ArrayAccess_lfno_primaryContext.class,0);
13091 }
13092 public MethodInvocation_lfno_primaryContext methodInvocation_lfno_primary() {
13093 return getRuleContext(MethodInvocation_lfno_primaryContext.class,0);
13094 }
13095 public MethodReference_lfno_primaryContext methodReference_lfno_primary() {
13096 return getRuleContext(MethodReference_lfno_primaryContext.class,0);
13097 }
13098 public PrimaryNoNewArray_lfno_primaryContext(ParserRuleContext parent, int invokingState) {
13099 super(parent, invokingState);
13100 }
13101 @Override public int getRuleIndex() { return RULE_primaryNoNewArray_lfno_primary; }
13102 @Override
13103 public void enterRule(ParseTreeListener listener) {
13104 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPrimaryNoNewArray_lfno_primary(this);
13105 }
13106 @Override
13107 public void exitRule(ParseTreeListener listener) {
13108 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPrimaryNoNewArray_lfno_primary(this);
13109 }
13110 }
13111
13112 public final PrimaryNoNewArray_lfno_primaryContext primaryNoNewArray_lfno_primary() throws RecognitionException {
13113 PrimaryNoNewArray_lfno_primaryContext _localctx = new PrimaryNoNewArray_lfno_primaryContext(_ctx, getState());
13114 enterRule(_localctx, 388, RULE_primaryNoNewArray_lfno_primary);
13115 int _la;
13116 try {
13117 setState(2105);
13118 _errHandler.sync(this);
13119 switch ( getInterpreter().adaptivePredict(_input,213,_ctx) ) {
13120 case 1:
13121 enterOuterAlt(_localctx, 1);
13122 {
13123 setState(2065);
13124 literal();
13125 }
13126 break;
13127 case 2:
13128 enterOuterAlt(_localctx, 2);
13129 {
13130 setState(2066);
13131 typeName();
13132 setState(2071);
13133 _errHandler.sync(this);
13134 _la = _input.LA(1);
13135 while (_la==LBRACK) {
13136 {
13137 {
13138 setState(2067);
13139 match(LBRACK);
13140 setState(2068);
13141 match(RBRACK);
13142 }
13143 }
13144 setState(2073);
13145 _errHandler.sync(this);
13146 _la = _input.LA(1);
13147 }
13148 setState(2074);
13149 match(DOT);
13150 setState(2075);
13151 match(CLASS);
13152 }
13153 break;
13154 case 3:
13155 enterOuterAlt(_localctx, 3);
13156 {
13157 setState(2077);
13158 unannPrimitiveType();
13159 setState(2082);
13160 _errHandler.sync(this);
13161 _la = _input.LA(1);
13162 while (_la==LBRACK) {
13163 {
13164 {
13165 setState(2078);
13166 match(LBRACK);
13167 setState(2079);
13168 match(RBRACK);
13169 }
13170 }
13171 setState(2084);
13172 _errHandler.sync(this);
13173 _la = _input.LA(1);
13174 }
13175 setState(2085);
13176 match(DOT);
13177 setState(2086);
13178 match(CLASS);
13179 }
13180 break;
13181 case 4:
13182 enterOuterAlt(_localctx, 4);
13183 {
13184 setState(2088);
13185 match(VOID);
13186 setState(2089);
13187 match(DOT);
13188 setState(2090);
13189 match(CLASS);
13190 }
13191 break;
13192 case 5:
13193 enterOuterAlt(_localctx, 5);
13194 {
13195 setState(2091);
13196 match(THIS);
13197 }
13198 break;
13199 case 6:
13200 enterOuterAlt(_localctx, 6);
13201 {
13202 setState(2092);
13203 typeName();
13204 setState(2093);
13205 match(DOT);
13206 setState(2094);
13207 match(THIS);
13208 }
13209 break;
13210 case 7:
13211 enterOuterAlt(_localctx, 7);
13212 {
13213 setState(2096);
13214 match(LPAREN);
13215 setState(2097);
13216 expression();
13217 setState(2098);
13218 match(RPAREN);
13219 }
13220 break;
13221 case 8:
13222 enterOuterAlt(_localctx, 8);
13223 {
13224 setState(2100);
13225 classInstanceCreationExpression_lfno_primary();
13226 }
13227 break;
13228 case 9:
13229 enterOuterAlt(_localctx, 9);
13230 {
13231 setState(2101);
13232 fieldAccess_lfno_primary();
13233 }
13234 break;
13235 case 10:
13236 enterOuterAlt(_localctx, 10);
13237 {
13238 setState(2102);
13239 arrayAccess_lfno_primary();
13240 }
13241 break;
13242 case 11:
13243 enterOuterAlt(_localctx, 11);
13244 {
13245 setState(2103);
13246 methodInvocation_lfno_primary();
13247 }
13248 break;
13249 case 12:
13250 enterOuterAlt(_localctx, 12);
13251 {
13252 setState(2104);
13253 methodReference_lfno_primary();
13254 }
13255 break;
13256 }
13257 }
13258 catch (RecognitionException re) {
13259 _localctx.exception = re;
13260 _errHandler.reportError(this, re);
13261 _errHandler.recover(this, re);
13262 }
13263 finally {
13264 exitRule();
13265 }
13266 return _localctx;
13267 }
13268
13269 public static class PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext extends ParserRuleContext {
13270 public PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext(ParserRuleContext parent, int invokingState) {
13271 super(parent, invokingState);
13272 }
13273 @Override public int getRuleIndex() { return RULE_primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary; }
13274 @Override
13275 public void enterRule(ParseTreeListener listener) {
13276 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary(this);
13277 }
13278 @Override
13279 public void exitRule(ParseTreeListener listener) {
13280 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary(this);
13281 }
13282 }
13283
13284 public final PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary() throws RecognitionException {
13285 PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext _localctx = new PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext(_ctx, getState());
13286 enterRule(_localctx, 390, RULE_primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary);
13287 try {
13288 enterOuterAlt(_localctx, 1);
13289 {
13290 }
13291 }
13292 catch (RecognitionException re) {
13293 _localctx.exception = re;
13294 _errHandler.reportError(this, re);
13295 _errHandler.recover(this, re);
13296 }
13297 finally {
13298 exitRule();
13299 }
13300 return _localctx;
13301 }
13302
13303 public static class PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext extends ParserRuleContext {
13304 public LiteralContext literal() {
13305 return getRuleContext(LiteralContext.class,0);
13306 }
13307 public TypeNameContext typeName() {
13308 return getRuleContext(TypeNameContext.class,0);
13309 }
13310 public UnannPrimitiveTypeContext unannPrimitiveType() {
13311 return getRuleContext(UnannPrimitiveTypeContext.class,0);
13312 }
13313 public ExpressionContext expression() {
13314 return getRuleContext(ExpressionContext.class,0);
13315 }
13316 public ClassInstanceCreationExpression_lfno_primaryContext classInstanceCreationExpression_lfno_primary() {
13317 return getRuleContext(ClassInstanceCreationExpression_lfno_primaryContext.class,0);
13318 }
13319 public FieldAccess_lfno_primaryContext fieldAccess_lfno_primary() {
13320 return getRuleContext(FieldAccess_lfno_primaryContext.class,0);
13321 }
13322 public MethodInvocation_lfno_primaryContext methodInvocation_lfno_primary() {
13323 return getRuleContext(MethodInvocation_lfno_primaryContext.class,0);
13324 }
13325 public MethodReference_lfno_primaryContext methodReference_lfno_primary() {
13326 return getRuleContext(MethodReference_lfno_primaryContext.class,0);
13327 }
13328 public PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext(ParserRuleContext parent, int invokingState) {
13329 super(parent, invokingState);
13330 }
13331 @Override public int getRuleIndex() { return RULE_primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary; }
13332 @Override
13333 public void enterRule(ParseTreeListener listener) {
13334 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary(this);
13335 }
13336 @Override
13337 public void exitRule(ParseTreeListener listener) {
13338 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary(this);
13339 }
13340 }
13341
13342 public final PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary() throws RecognitionException {
13343 PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext _localctx = new PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext(_ctx, getState());
13344 enterRule(_localctx, 392, RULE_primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary);
13345 int _la;
13346 try {
13347 setState(2148);
13348 _errHandler.sync(this);
13349 switch ( getInterpreter().adaptivePredict(_input,216,_ctx) ) {
13350 case 1:
13351 enterOuterAlt(_localctx, 1);
13352 {
13353 setState(2109);
13354 literal();
13355 }
13356 break;
13357 case 2:
13358 enterOuterAlt(_localctx, 2);
13359 {
13360 setState(2110);
13361 typeName();
13362 setState(2115);
13363 _errHandler.sync(this);
13364 _la = _input.LA(1);
13365 while (_la==LBRACK) {
13366 {
13367 {
13368 setState(2111);
13369 match(LBRACK);
13370 setState(2112);
13371 match(RBRACK);
13372 }
13373 }
13374 setState(2117);
13375 _errHandler.sync(this);
13376 _la = _input.LA(1);
13377 }
13378 setState(2118);
13379 match(DOT);
13380 setState(2119);
13381 match(CLASS);
13382 }
13383 break;
13384 case 3:
13385 enterOuterAlt(_localctx, 3);
13386 {
13387 setState(2121);
13388 unannPrimitiveType();
13389 setState(2126);
13390 _errHandler.sync(this);
13391 _la = _input.LA(1);
13392 while (_la==LBRACK) {
13393 {
13394 {
13395 setState(2122);
13396 match(LBRACK);
13397 setState(2123);
13398 match(RBRACK);
13399 }
13400 }
13401 setState(2128);
13402 _errHandler.sync(this);
13403 _la = _input.LA(1);
13404 }
13405 setState(2129);
13406 match(DOT);
13407 setState(2130);
13408 match(CLASS);
13409 }
13410 break;
13411 case 4:
13412 enterOuterAlt(_localctx, 4);
13413 {
13414 setState(2132);
13415 match(VOID);
13416 setState(2133);
13417 match(DOT);
13418 setState(2134);
13419 match(CLASS);
13420 }
13421 break;
13422 case 5:
13423 enterOuterAlt(_localctx, 5);
13424 {
13425 setState(2135);
13426 match(THIS);
13427 }
13428 break;
13429 case 6:
13430 enterOuterAlt(_localctx, 6);
13431 {
13432 setState(2136);
13433 typeName();
13434 setState(2137);
13435 match(DOT);
13436 setState(2138);
13437 match(THIS);
13438 }
13439 break;
13440 case 7:
13441 enterOuterAlt(_localctx, 7);
13442 {
13443 setState(2140);
13444 match(LPAREN);
13445 setState(2141);
13446 expression();
13447 setState(2142);
13448 match(RPAREN);
13449 }
13450 break;
13451 case 8:
13452 enterOuterAlt(_localctx, 8);
13453 {
13454 setState(2144);
13455 classInstanceCreationExpression_lfno_primary();
13456 }
13457 break;
13458 case 9:
13459 enterOuterAlt(_localctx, 9);
13460 {
13461 setState(2145);
13462 fieldAccess_lfno_primary();
13463 }
13464 break;
13465 case 10:
13466 enterOuterAlt(_localctx, 10);
13467 {
13468 setState(2146);
13469 methodInvocation_lfno_primary();
13470 }
13471 break;
13472 case 11:
13473 enterOuterAlt(_localctx, 11);
13474 {
13475 setState(2147);
13476 methodReference_lfno_primary();
13477 }
13478 break;
13479 }
13480 }
13481 catch (RecognitionException re) {
13482 _localctx.exception = re;
13483 _errHandler.reportError(this, re);
13484 _errHandler.recover(this, re);
13485 }
13486 finally {
13487 exitRule();
13488 }
13489 return _localctx;
13490 }
13491
13492 public static class ClassLiteralContext extends ParserRuleContext {
13493 public TypeNameContext typeName() {
13494 return getRuleContext(TypeNameContext.class,0);
13495 }
13496 public NumericTypeContext numericType() {
13497 return getRuleContext(NumericTypeContext.class,0);
13498 }
13499 public ClassLiteralContext(ParserRuleContext parent, int invokingState) {
13500 super(parent, invokingState);
13501 }
13502 @Override public int getRuleIndex() { return RULE_classLiteral; }
13503 @Override
13504 public void enterRule(ParseTreeListener listener) {
13505 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterClassLiteral(this);
13506 }
13507 @Override
13508 public void exitRule(ParseTreeListener listener) {
13509 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitClassLiteral(this);
13510 }
13511 }
13512
13513 public final ClassLiteralContext classLiteral() throws RecognitionException {
13514 ClassLiteralContext _localctx = new ClassLiteralContext(_ctx, getState());
13515 enterRule(_localctx, 394, RULE_classLiteral);
13516 int _la;
13517 try {
13518 setState(2167);
13519 _errHandler.sync(this);
13520 switch (_input.LA(1)) {
13521 case T__0:
13522 case T__1:
13523 case T__2:
13524 case T__3:
13525 case T__4:
13526 case T__5:
13527 case T__6:
13528 case T__7:
13529 case T__8:
13530 case BOOLEAN:
13531 case BYTE:
13532 case CHAR:
13533 case DOUBLE:
13534 case FLOAT:
13535 case INT:
13536 case LONG:
13537 case SHORT:
13538 case Identifier:
13539 enterOuterAlt(_localctx, 1);
13540 {
13541 setState(2153);
13542 _errHandler.sync(this);
13543 switch (_input.LA(1)) {
13544 case T__0:
13545 case T__1:
13546 case T__2:
13547 case T__3:
13548 case T__4:
13549 case T__5:
13550 case T__6:
13551 case T__7:
13552 case T__8:
13553 case Identifier:
13554 {
13555 setState(2150);
13556 typeName();
13557 }
13558 break;
13559 case BYTE:
13560 case CHAR:
13561 case DOUBLE:
13562 case FLOAT:
13563 case INT:
13564 case LONG:
13565 case SHORT:
13566 {
13567 setState(2151);
13568 numericType();
13569 }
13570 break;
13571 case BOOLEAN:
13572 {
13573 setState(2152);
13574 match(BOOLEAN);
13575 }
13576 break;
13577 default:
13578 throw new NoViableAltException(this);
13579 }
13580 setState(2159);
13581 _errHandler.sync(this);
13582 _la = _input.LA(1);
13583 while (_la==LBRACK) {
13584 {
13585 {
13586 setState(2155);
13587 match(LBRACK);
13588 setState(2156);
13589 match(RBRACK);
13590 }
13591 }
13592 setState(2161);
13593 _errHandler.sync(this);
13594 _la = _input.LA(1);
13595 }
13596 setState(2162);
13597 match(DOT);
13598 setState(2163);
13599 match(CLASS);
13600 }
13601 break;
13602 case VOID:
13603 enterOuterAlt(_localctx, 2);
13604 {
13605 setState(2164);
13606 match(VOID);
13607 setState(2165);
13608 match(DOT);
13609 setState(2166);
13610 match(CLASS);
13611 }
13612 break;
13613 default:
13614 throw new NoViableAltException(this);
13615 }
13616 }
13617 catch (RecognitionException re) {
13618 _localctx.exception = re;
13619 _errHandler.reportError(this, re);
13620 _errHandler.recover(this, re);
13621 }
13622 finally {
13623 exitRule();
13624 }
13625 return _localctx;
13626 }
13627
13628 public static class ClassInstanceCreationExpressionContext extends ParserRuleContext {
13629 public List<IdentifierContext> identifier() {
13630 return getRuleContexts(IdentifierContext.class);
13631 }
13632 public IdentifierContext identifier(int i) {
13633 return getRuleContext(IdentifierContext.class,i);
13634 }
13635 public TypeArgumentsContext typeArguments() {
13636 return getRuleContext(TypeArgumentsContext.class,0);
13637 }
13638 public List<AnnotationContext> annotation() {
13639 return getRuleContexts(AnnotationContext.class);
13640 }
13641 public AnnotationContext annotation(int i) {
13642 return getRuleContext(AnnotationContext.class,i);
13643 }
13644 public TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() {
13645 return getRuleContext(TypeArgumentsOrDiamondContext.class,0);
13646 }
13647 public ArgumentListContext argumentList() {
13648 return getRuleContext(ArgumentListContext.class,0);
13649 }
13650 public ClassBodyContext classBody() {
13651 return getRuleContext(ClassBodyContext.class,0);
13652 }
13653 public ExpressionNameContext expressionName() {
13654 return getRuleContext(ExpressionNameContext.class,0);
13655 }
13656 public PrimaryContext primary() {
13657 return getRuleContext(PrimaryContext.class,0);
13658 }
13659 public ClassInstanceCreationExpressionContext(ParserRuleContext parent, int invokingState) {
13660 super(parent, invokingState);
13661 }
13662 @Override public int getRuleIndex() { return RULE_classInstanceCreationExpression; }
13663 @Override
13664 public void enterRule(ParseTreeListener listener) {
13665 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterClassInstanceCreationExpression(this);
13666 }
13667 @Override
13668 public void exitRule(ParseTreeListener listener) {
13669 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitClassInstanceCreationExpression(this);
13670 }
13671 }
13672
13673 public final ClassInstanceCreationExpressionContext classInstanceCreationExpression() throws RecognitionException {
13674 ClassInstanceCreationExpressionContext _localctx = new ClassInstanceCreationExpressionContext(_ctx, getState());
13675 enterRule(_localctx, 396, RULE_classInstanceCreationExpression);
13676 int _la;
13677 try {
13678 setState(2252);
13679 _errHandler.sync(this);
13680 switch ( getInterpreter().adaptivePredict(_input,237,_ctx) ) {
13681 case 1:
13682 enterOuterAlt(_localctx, 1);
13683 {
13684 setState(2169);
13685 match(NEW);
13686 setState(2171);
13687 _errHandler.sync(this);
13688 _la = _input.LA(1);
13689 if (_la==LT) {
13690 {
13691 setState(2170);
13692 typeArguments();
13693 }
13694 }
13695
13696 setState(2176);
13697 _errHandler.sync(this);
13698 _la = _input.LA(1);
13699 while (_la==AT) {
13700 {
13701 {
13702 setState(2173);
13703 annotation();
13704 }
13705 }
13706 setState(2178);
13707 _errHandler.sync(this);
13708 _la = _input.LA(1);
13709 }
13710 setState(2179);
13711 identifier();
13712 setState(2190);
13713 _errHandler.sync(this);
13714 _la = _input.LA(1);
13715 while (_la==DOT) {
13716 {
13717 {
13718 setState(2180);
13719 match(DOT);
13720 setState(2184);
13721 _errHandler.sync(this);
13722 _la = _input.LA(1);
13723 while (_la==AT) {
13724 {
13725 {
13726 setState(2181);
13727 annotation();
13728 }
13729 }
13730 setState(2186);
13731 _errHandler.sync(this);
13732 _la = _input.LA(1);
13733 }
13734 setState(2187);
13735 identifier();
13736 }
13737 }
13738 setState(2192);
13739 _errHandler.sync(this);
13740 _la = _input.LA(1);
13741 }
13742 setState(2194);
13743 _errHandler.sync(this);
13744 _la = _input.LA(1);
13745 if (_la==LT) {
13746 {
13747 setState(2193);
13748 typeArgumentsOrDiamond();
13749 }
13750 }
13751
13752 setState(2196);
13753 match(LPAREN);
13754 setState(2198);
13755 _errHandler.sync(this);
13756 _la = _input.LA(1);
13757 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)) {
13758 {
13759 setState(2197);
13760 argumentList();
13761 }
13762 }
13763
13764 setState(2200);
13765 match(RPAREN);
13766 setState(2202);
13767 _errHandler.sync(this);
13768 _la = _input.LA(1);
13769 if (_la==LBRACE) {
13770 {
13771 setState(2201);
13772 classBody();
13773 }
13774 }
13775
13776 }
13777 break;
13778 case 2:
13779 enterOuterAlt(_localctx, 2);
13780 {
13781 setState(2204);
13782 expressionName();
13783 setState(2205);
13784 match(DOT);
13785 setState(2206);
13786 match(NEW);
13787 setState(2208);
13788 _errHandler.sync(this);
13789 _la = _input.LA(1);
13790 if (_la==LT) {
13791 {
13792 setState(2207);
13793 typeArguments();
13794 }
13795 }
13796
13797 setState(2213);
13798 _errHandler.sync(this);
13799 _la = _input.LA(1);
13800 while (_la==AT) {
13801 {
13802 {
13803 setState(2210);
13804 annotation();
13805 }
13806 }
13807 setState(2215);
13808 _errHandler.sync(this);
13809 _la = _input.LA(1);
13810 }
13811 setState(2216);
13812 identifier();
13813 setState(2218);
13814 _errHandler.sync(this);
13815 _la = _input.LA(1);
13816 if (_la==LT) {
13817 {
13818 setState(2217);
13819 typeArgumentsOrDiamond();
13820 }
13821 }
13822
13823 setState(2220);
13824 match(LPAREN);
13825 setState(2222);
13826 _errHandler.sync(this);
13827 _la = _input.LA(1);
13828 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)) {
13829 {
13830 setState(2221);
13831 argumentList();
13832 }
13833 }
13834
13835 setState(2224);
13836 match(RPAREN);
13837 setState(2226);
13838 _errHandler.sync(this);
13839 _la = _input.LA(1);
13840 if (_la==LBRACE) {
13841 {
13842 setState(2225);
13843 classBody();
13844 }
13845 }
13846
13847 }
13848 break;
13849 case 3:
13850 enterOuterAlt(_localctx, 3);
13851 {
13852 setState(2228);
13853 primary();
13854 setState(2229);
13855 match(DOT);
13856 setState(2230);
13857 match(NEW);
13858 setState(2232);
13859 _errHandler.sync(this);
13860 _la = _input.LA(1);
13861 if (_la==LT) {
13862 {
13863 setState(2231);
13864 typeArguments();
13865 }
13866 }
13867
13868 setState(2237);
13869 _errHandler.sync(this);
13870 _la = _input.LA(1);
13871 while (_la==AT) {
13872 {
13873 {
13874 setState(2234);
13875 annotation();
13876 }
13877 }
13878 setState(2239);
13879 _errHandler.sync(this);
13880 _la = _input.LA(1);
13881 }
13882 setState(2240);
13883 identifier();
13884 setState(2242);
13885 _errHandler.sync(this);
13886 _la = _input.LA(1);
13887 if (_la==LT) {
13888 {
13889 setState(2241);
13890 typeArgumentsOrDiamond();
13891 }
13892 }
13893
13894 setState(2244);
13895 match(LPAREN);
13896 setState(2246);
13897 _errHandler.sync(this);
13898 _la = _input.LA(1);
13899 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)) {
13900 {
13901 setState(2245);
13902 argumentList();
13903 }
13904 }
13905
13906 setState(2248);
13907 match(RPAREN);
13908 setState(2250);
13909 _errHandler.sync(this);
13910 _la = _input.LA(1);
13911 if (_la==LBRACE) {
13912 {
13913 setState(2249);
13914 classBody();
13915 }
13916 }
13917
13918 }
13919 break;
13920 }
13921 }
13922 catch (RecognitionException re) {
13923 _localctx.exception = re;
13924 _errHandler.reportError(this, re);
13925 _errHandler.recover(this, re);
13926 }
13927 finally {
13928 exitRule();
13929 }
13930 return _localctx;
13931 }
13932
13933 public static class ClassInstanceCreationExpression_lf_primaryContext extends ParserRuleContext {
13934 public IdentifierContext identifier() {
13935 return getRuleContext(IdentifierContext.class,0);
13936 }
13937 public TypeArgumentsContext typeArguments() {
13938 return getRuleContext(TypeArgumentsContext.class,0);
13939 }
13940 public List<AnnotationContext> annotation() {
13941 return getRuleContexts(AnnotationContext.class);
13942 }
13943 public AnnotationContext annotation(int i) {
13944 return getRuleContext(AnnotationContext.class,i);
13945 }
13946 public TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() {
13947 return getRuleContext(TypeArgumentsOrDiamondContext.class,0);
13948 }
13949 public ArgumentListContext argumentList() {
13950 return getRuleContext(ArgumentListContext.class,0);
13951 }
13952 public ClassBodyContext classBody() {
13953 return getRuleContext(ClassBodyContext.class,0);
13954 }
13955 public ClassInstanceCreationExpression_lf_primaryContext(ParserRuleContext parent, int invokingState) {
13956 super(parent, invokingState);
13957 }
13958 @Override public int getRuleIndex() { return RULE_classInstanceCreationExpression_lf_primary; }
13959 @Override
13960 public void enterRule(ParseTreeListener listener) {
13961 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterClassInstanceCreationExpression_lf_primary(this);
13962 }
13963 @Override
13964 public void exitRule(ParseTreeListener listener) {
13965 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitClassInstanceCreationExpression_lf_primary(this);
13966 }
13967 }
13968
13969 public final ClassInstanceCreationExpression_lf_primaryContext classInstanceCreationExpression_lf_primary() throws RecognitionException {
13970 ClassInstanceCreationExpression_lf_primaryContext _localctx = new ClassInstanceCreationExpression_lf_primaryContext(_ctx, getState());
13971 enterRule(_localctx, 398, RULE_classInstanceCreationExpression_lf_primary);
13972 int _la;
13973 try {
13974 enterOuterAlt(_localctx, 1);
13975 {
13976 setState(2254);
13977 match(DOT);
13978 setState(2255);
13979 match(NEW);
13980 setState(2257);
13981 _errHandler.sync(this);
13982 _la = _input.LA(1);
13983 if (_la==LT) {
13984 {
13985 setState(2256);
13986 typeArguments();
13987 }
13988 }
13989
13990 setState(2262);
13991 _errHandler.sync(this);
13992 _la = _input.LA(1);
13993 while (_la==AT) {
13994 {
13995 {
13996 setState(2259);
13997 annotation();
13998 }
13999 }
14000 setState(2264);
14001 _errHandler.sync(this);
14002 _la = _input.LA(1);
14003 }
14004 setState(2265);
14005 identifier();
14006 setState(2267);
14007 _errHandler.sync(this);
14008 _la = _input.LA(1);
14009 if (_la==LT) {
14010 {
14011 setState(2266);
14012 typeArgumentsOrDiamond();
14013 }
14014 }
14015
14016 setState(2269);
14017 match(LPAREN);
14018 setState(2271);
14019 _errHandler.sync(this);
14020 _la = _input.LA(1);
14021 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)) {
14022 {
14023 setState(2270);
14024 argumentList();
14025 }
14026 }
14027
14028 setState(2273);
14029 match(RPAREN);
14030 setState(2275);
14031 _errHandler.sync(this);
14032 switch ( getInterpreter().adaptivePredict(_input,242,_ctx) ) {
14033 case 1:
14034 {
14035 setState(2274);
14036 classBody();
14037 }
14038 break;
14039 }
14040 }
14041 }
14042 catch (RecognitionException re) {
14043 _localctx.exception = re;
14044 _errHandler.reportError(this, re);
14045 _errHandler.recover(this, re);
14046 }
14047 finally {
14048 exitRule();
14049 }
14050 return _localctx;
14051 }
14052
14053 public static class ClassInstanceCreationExpression_lfno_primaryContext extends ParserRuleContext {
14054 public List<IdentifierContext> identifier() {
14055 return getRuleContexts(IdentifierContext.class);
14056 }
14057 public IdentifierContext identifier(int i) {
14058 return getRuleContext(IdentifierContext.class,i);
14059 }
14060 public TypeArgumentsContext typeArguments() {
14061 return getRuleContext(TypeArgumentsContext.class,0);
14062 }
14063 public List<AnnotationContext> annotation() {
14064 return getRuleContexts(AnnotationContext.class);
14065 }
14066 public AnnotationContext annotation(int i) {
14067 return getRuleContext(AnnotationContext.class,i);
14068 }
14069 public TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() {
14070 return getRuleContext(TypeArgumentsOrDiamondContext.class,0);
14071 }
14072 public ArgumentListContext argumentList() {
14073 return getRuleContext(ArgumentListContext.class,0);
14074 }
14075 public ClassBodyContext classBody() {
14076 return getRuleContext(ClassBodyContext.class,0);
14077 }
14078 public ExpressionNameContext expressionName() {
14079 return getRuleContext(ExpressionNameContext.class,0);
14080 }
14081 public ClassInstanceCreationExpression_lfno_primaryContext(ParserRuleContext parent, int invokingState) {
14082 super(parent, invokingState);
14083 }
14084 @Override public int getRuleIndex() { return RULE_classInstanceCreationExpression_lfno_primary; }
14085 @Override
14086 public void enterRule(ParseTreeListener listener) {
14087 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterClassInstanceCreationExpression_lfno_primary(this);
14088 }
14089 @Override
14090 public void exitRule(ParseTreeListener listener) {
14091 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitClassInstanceCreationExpression_lfno_primary(this);
14092 }
14093 }
14094
14095 public final ClassInstanceCreationExpression_lfno_primaryContext classInstanceCreationExpression_lfno_primary() throws RecognitionException {
14096 ClassInstanceCreationExpression_lfno_primaryContext _localctx = new ClassInstanceCreationExpression_lfno_primaryContext(_ctx, getState());
14097 enterRule(_localctx, 400, RULE_classInstanceCreationExpression_lfno_primary);
14098 int _la;
14099 try {
14100 setState(2336);
14101 _errHandler.sync(this);
14102 switch (_input.LA(1)) {
14103 case NEW:
14104 enterOuterAlt(_localctx, 1);
14105 {
14106 setState(2277);
14107 match(NEW);
14108 setState(2279);
14109 _errHandler.sync(this);
14110 _la = _input.LA(1);
14111 if (_la==LT) {
14112 {
14113 setState(2278);
14114 typeArguments();
14115 }
14116 }
14117
14118 setState(2284);
14119 _errHandler.sync(this);
14120 _la = _input.LA(1);
14121 while (_la==AT) {
14122 {
14123 {
14124 setState(2281);
14125 annotation();
14126 }
14127 }
14128 setState(2286);
14129 _errHandler.sync(this);
14130 _la = _input.LA(1);
14131 }
14132 setState(2287);
14133 identifier();
14134 setState(2298);
14135 _errHandler.sync(this);
14136 _la = _input.LA(1);
14137 while (_la==DOT) {
14138 {
14139 {
14140 setState(2288);
14141 match(DOT);
14142 setState(2292);
14143 _errHandler.sync(this);
14144 _la = _input.LA(1);
14145 while (_la==AT) {
14146 {
14147 {
14148 setState(2289);
14149 annotation();
14150 }
14151 }
14152 setState(2294);
14153 _errHandler.sync(this);
14154 _la = _input.LA(1);
14155 }
14156 setState(2295);
14157 identifier();
14158 }
14159 }
14160 setState(2300);
14161 _errHandler.sync(this);
14162 _la = _input.LA(1);
14163 }
14164 setState(2302);
14165 _errHandler.sync(this);
14166 _la = _input.LA(1);
14167 if (_la==LT) {
14168 {
14169 setState(2301);
14170 typeArgumentsOrDiamond();
14171 }
14172 }
14173
14174 setState(2304);
14175 match(LPAREN);
14176 setState(2306);
14177 _errHandler.sync(this);
14178 _la = _input.LA(1);
14179 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)) {
14180 {
14181 setState(2305);
14182 argumentList();
14183 }
14184 }
14185
14186 setState(2308);
14187 match(RPAREN);
14188 setState(2310);
14189 _errHandler.sync(this);
14190 switch ( getInterpreter().adaptivePredict(_input,249,_ctx) ) {
14191 case 1:
14192 {
14193 setState(2309);
14194 classBody();
14195 }
14196 break;
14197 }
14198 }
14199 break;
14200 case T__0:
14201 case T__1:
14202 case T__2:
14203 case T__3:
14204 case T__4:
14205 case T__5:
14206 case T__6:
14207 case T__7:
14208 case T__8:
14209 case Identifier:
14210 enterOuterAlt(_localctx, 2);
14211 {
14212 setState(2312);
14213 expressionName();
14214 setState(2313);
14215 match(DOT);
14216 setState(2314);
14217 match(NEW);
14218 setState(2316);
14219 _errHandler.sync(this);
14220 _la = _input.LA(1);
14221 if (_la==LT) {
14222 {
14223 setState(2315);
14224 typeArguments();
14225 }
14226 }
14227
14228 setState(2321);
14229 _errHandler.sync(this);
14230 _la = _input.LA(1);
14231 while (_la==AT) {
14232 {
14233 {
14234 setState(2318);
14235 annotation();
14236 }
14237 }
14238 setState(2323);
14239 _errHandler.sync(this);
14240 _la = _input.LA(1);
14241 }
14242 setState(2324);
14243 identifier();
14244 setState(2326);
14245 _errHandler.sync(this);
14246 _la = _input.LA(1);
14247 if (_la==LT) {
14248 {
14249 setState(2325);
14250 typeArgumentsOrDiamond();
14251 }
14252 }
14253
14254 setState(2328);
14255 match(LPAREN);
14256 setState(2330);
14257 _errHandler.sync(this);
14258 _la = _input.LA(1);
14259 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)) {
14260 {
14261 setState(2329);
14262 argumentList();
14263 }
14264 }
14265
14266 setState(2332);
14267 match(RPAREN);
14268 setState(2334);
14269 _errHandler.sync(this);
14270 switch ( getInterpreter().adaptivePredict(_input,254,_ctx) ) {
14271 case 1:
14272 {
14273 setState(2333);
14274 classBody();
14275 }
14276 break;
14277 }
14278 }
14279 break;
14280 default:
14281 throw new NoViableAltException(this);
14282 }
14283 }
14284 catch (RecognitionException re) {
14285 _localctx.exception = re;
14286 _errHandler.reportError(this, re);
14287 _errHandler.recover(this, re);
14288 }
14289 finally {
14290 exitRule();
14291 }
14292 return _localctx;
14293 }
14294
14295 public static class TypeArgumentsOrDiamondContext extends ParserRuleContext {
14296 public TypeArgumentsContext typeArguments() {
14297 return getRuleContext(TypeArgumentsContext.class,0);
14298 }
14299 public TypeArgumentsOrDiamondContext(ParserRuleContext parent, int invokingState) {
14300 super(parent, invokingState);
14301 }
14302 @Override public int getRuleIndex() { return RULE_typeArgumentsOrDiamond; }
14303 @Override
14304 public void enterRule(ParseTreeListener listener) {
14305 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeArgumentsOrDiamond(this);
14306 }
14307 @Override
14308 public void exitRule(ParseTreeListener listener) {
14309 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeArgumentsOrDiamond(this);
14310 }
14311 }
14312
14313 public final TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() throws RecognitionException {
14314 TypeArgumentsOrDiamondContext _localctx = new TypeArgumentsOrDiamondContext(_ctx, getState());
14315 enterRule(_localctx, 402, RULE_typeArgumentsOrDiamond);
14316 try {
14317 setState(2341);
14318 _errHandler.sync(this);
14319 switch ( getInterpreter().adaptivePredict(_input,256,_ctx) ) {
14320 case 1:
14321 enterOuterAlt(_localctx, 1);
14322 {
14323 setState(2338);
14324 typeArguments();
14325 }
14326 break;
14327 case 2:
14328 enterOuterAlt(_localctx, 2);
14329 {
14330 setState(2339);
14331 match(LT);
14332 setState(2340);
14333 match(GT);
14334 }
14335 break;
14336 }
14337 }
14338 catch (RecognitionException re) {
14339 _localctx.exception = re;
14340 _errHandler.reportError(this, re);
14341 _errHandler.recover(this, re);
14342 }
14343 finally {
14344 exitRule();
14345 }
14346 return _localctx;
14347 }
14348
14349 public static class FieldAccessContext extends ParserRuleContext {
14350 public PrimaryContext primary() {
14351 return getRuleContext(PrimaryContext.class,0);
14352 }
14353 public IdentifierContext identifier() {
14354 return getRuleContext(IdentifierContext.class,0);
14355 }
14356 public TypeNameContext typeName() {
14357 return getRuleContext(TypeNameContext.class,0);
14358 }
14359 public FieldAccessContext(ParserRuleContext parent, int invokingState) {
14360 super(parent, invokingState);
14361 }
14362 @Override public int getRuleIndex() { return RULE_fieldAccess; }
14363 @Override
14364 public void enterRule(ParseTreeListener listener) {
14365 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterFieldAccess(this);
14366 }
14367 @Override
14368 public void exitRule(ParseTreeListener listener) {
14369 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitFieldAccess(this);
14370 }
14371 }
14372
14373 public final FieldAccessContext fieldAccess() throws RecognitionException {
14374 FieldAccessContext _localctx = new FieldAccessContext(_ctx, getState());
14375 enterRule(_localctx, 404, RULE_fieldAccess);
14376 try {
14377 setState(2356);
14378 _errHandler.sync(this);
14379 switch ( getInterpreter().adaptivePredict(_input,257,_ctx) ) {
14380 case 1:
14381 enterOuterAlt(_localctx, 1);
14382 {
14383 setState(2343);
14384 primary();
14385 setState(2344);
14386 match(DOT);
14387 setState(2345);
14388 identifier();
14389 }
14390 break;
14391 case 2:
14392 enterOuterAlt(_localctx, 2);
14393 {
14394 setState(2347);
14395 match(SUPER);
14396 setState(2348);
14397 match(DOT);
14398 setState(2349);
14399 identifier();
14400 }
14401 break;
14402 case 3:
14403 enterOuterAlt(_localctx, 3);
14404 {
14405 setState(2350);
14406 typeName();
14407 setState(2351);
14408 match(DOT);
14409 setState(2352);
14410 match(SUPER);
14411 setState(2353);
14412 match(DOT);
14413 setState(2354);
14414 identifier();
14415 }
14416 break;
14417 }
14418 }
14419 catch (RecognitionException re) {
14420 _localctx.exception = re;
14421 _errHandler.reportError(this, re);
14422 _errHandler.recover(this, re);
14423 }
14424 finally {
14425 exitRule();
14426 }
14427 return _localctx;
14428 }
14429
14430 public static class FieldAccess_lf_primaryContext extends ParserRuleContext {
14431 public IdentifierContext identifier() {
14432 return getRuleContext(IdentifierContext.class,0);
14433 }
14434 public FieldAccess_lf_primaryContext(ParserRuleContext parent, int invokingState) {
14435 super(parent, invokingState);
14436 }
14437 @Override public int getRuleIndex() { return RULE_fieldAccess_lf_primary; }
14438 @Override
14439 public void enterRule(ParseTreeListener listener) {
14440 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterFieldAccess_lf_primary(this);
14441 }
14442 @Override
14443 public void exitRule(ParseTreeListener listener) {
14444 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitFieldAccess_lf_primary(this);
14445 }
14446 }
14447
14448 public final FieldAccess_lf_primaryContext fieldAccess_lf_primary() throws RecognitionException {
14449 FieldAccess_lf_primaryContext _localctx = new FieldAccess_lf_primaryContext(_ctx, getState());
14450 enterRule(_localctx, 406, RULE_fieldAccess_lf_primary);
14451 try {
14452 enterOuterAlt(_localctx, 1);
14453 {
14454 setState(2358);
14455 match(DOT);
14456 setState(2359);
14457 identifier();
14458 }
14459 }
14460 catch (RecognitionException re) {
14461 _localctx.exception = re;
14462 _errHandler.reportError(this, re);
14463 _errHandler.recover(this, re);
14464 }
14465 finally {
14466 exitRule();
14467 }
14468 return _localctx;
14469 }
14470
14471 public static class FieldAccess_lfno_primaryContext extends ParserRuleContext {
14472 public IdentifierContext identifier() {
14473 return getRuleContext(IdentifierContext.class,0);
14474 }
14475 public TypeNameContext typeName() {
14476 return getRuleContext(TypeNameContext.class,0);
14477 }
14478 public FieldAccess_lfno_primaryContext(ParserRuleContext parent, int invokingState) {
14479 super(parent, invokingState);
14480 }
14481 @Override public int getRuleIndex() { return RULE_fieldAccess_lfno_primary; }
14482 @Override
14483 public void enterRule(ParseTreeListener listener) {
14484 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterFieldAccess_lfno_primary(this);
14485 }
14486 @Override
14487 public void exitRule(ParseTreeListener listener) {
14488 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitFieldAccess_lfno_primary(this);
14489 }
14490 }
14491
14492 public final FieldAccess_lfno_primaryContext fieldAccess_lfno_primary() throws RecognitionException {
14493 FieldAccess_lfno_primaryContext _localctx = new FieldAccess_lfno_primaryContext(_ctx, getState());
14494 enterRule(_localctx, 408, RULE_fieldAccess_lfno_primary);
14495 try {
14496 setState(2370);
14497 _errHandler.sync(this);
14498 switch (_input.LA(1)) {
14499 case SUPER:
14500 enterOuterAlt(_localctx, 1);
14501 {
14502 setState(2361);
14503 match(SUPER);
14504 setState(2362);
14505 match(DOT);
14506 setState(2363);
14507 identifier();
14508 }
14509 break;
14510 case T__0:
14511 case T__1:
14512 case T__2:
14513 case T__3:
14514 case T__4:
14515 case T__5:
14516 case T__6:
14517 case T__7:
14518 case T__8:
14519 case Identifier:
14520 enterOuterAlt(_localctx, 2);
14521 {
14522 setState(2364);
14523 typeName();
14524 setState(2365);
14525 match(DOT);
14526 setState(2366);
14527 match(SUPER);
14528 setState(2367);
14529 match(DOT);
14530 setState(2368);
14531 identifier();
14532 }
14533 break;
14534 default:
14535 throw new NoViableAltException(this);
14536 }
14537 }
14538 catch (RecognitionException re) {
14539 _localctx.exception = re;
14540 _errHandler.reportError(this, re);
14541 _errHandler.recover(this, re);
14542 }
14543 finally {
14544 exitRule();
14545 }
14546 return _localctx;
14547 }
14548
14549 public static class ArrayAccessContext extends ParserRuleContext {
14550 public ExpressionNameContext expressionName() {
14551 return getRuleContext(ExpressionNameContext.class,0);
14552 }
14553 public List<ExpressionContext> expression() {
14554 return getRuleContexts(ExpressionContext.class);
14555 }
14556 public ExpressionContext expression(int i) {
14557 return getRuleContext(ExpressionContext.class,i);
14558 }
14559 public PrimaryNoNewArray_lfno_arrayAccessContext primaryNoNewArray_lfno_arrayAccess() {
14560 return getRuleContext(PrimaryNoNewArray_lfno_arrayAccessContext.class,0);
14561 }
14562 public List<PrimaryNoNewArray_lf_arrayAccessContext> primaryNoNewArray_lf_arrayAccess() {
14563 return getRuleContexts(PrimaryNoNewArray_lf_arrayAccessContext.class);
14564 }
14565 public PrimaryNoNewArray_lf_arrayAccessContext primaryNoNewArray_lf_arrayAccess(int i) {
14566 return getRuleContext(PrimaryNoNewArray_lf_arrayAccessContext.class,i);
14567 }
14568 public ArrayAccessContext(ParserRuleContext parent, int invokingState) {
14569 super(parent, invokingState);
14570 }
14571 @Override public int getRuleIndex() { return RULE_arrayAccess; }
14572 @Override
14573 public void enterRule(ParseTreeListener listener) {
14574 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterArrayAccess(this);
14575 }
14576 @Override
14577 public void exitRule(ParseTreeListener listener) {
14578 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitArrayAccess(this);
14579 }
14580 }
14581
14582 public final ArrayAccessContext arrayAccess() throws RecognitionException {
14583 ArrayAccessContext _localctx = new ArrayAccessContext(_ctx, getState());
14584 enterRule(_localctx, 410, RULE_arrayAccess);
14585 int _la;
14586 try {
14587 enterOuterAlt(_localctx, 1);
14588 {
14589 setState(2382);
14590 _errHandler.sync(this);
14591 switch ( getInterpreter().adaptivePredict(_input,259,_ctx) ) {
14592 case 1:
14593 {
14594 setState(2372);
14595 expressionName();
14596 setState(2373);
14597 match(LBRACK);
14598 setState(2374);
14599 expression();
14600 setState(2375);
14601 match(RBRACK);
14602 }
14603 break;
14604 case 2:
14605 {
14606 setState(2377);
14607 primaryNoNewArray_lfno_arrayAccess();
14608 setState(2378);
14609 match(LBRACK);
14610 setState(2379);
14611 expression();
14612 setState(2380);
14613 match(RBRACK);
14614 }
14615 break;
14616 }
14617 setState(2391);
14618 _errHandler.sync(this);
14619 _la = _input.LA(1);
14620 while (_la==LBRACK) {
14621 {
14622 {
14623 setState(2384);
14624 primaryNoNewArray_lf_arrayAccess();
14625 setState(2385);
14626 match(LBRACK);
14627 setState(2386);
14628 expression();
14629 setState(2387);
14630 match(RBRACK);
14631 }
14632 }
14633 setState(2393);
14634 _errHandler.sync(this);
14635 _la = _input.LA(1);
14636 }
14637 }
14638 }
14639 catch (RecognitionException re) {
14640 _localctx.exception = re;
14641 _errHandler.reportError(this, re);
14642 _errHandler.recover(this, re);
14643 }
14644 finally {
14645 exitRule();
14646 }
14647 return _localctx;
14648 }
14649
14650 public static class ArrayAccess_lf_primaryContext extends ParserRuleContext {
14651 public PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary() {
14652 return getRuleContext(PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext.class,0);
14653 }
14654 public List<ExpressionContext> expression() {
14655 return getRuleContexts(ExpressionContext.class);
14656 }
14657 public ExpressionContext expression(int i) {
14658 return getRuleContext(ExpressionContext.class,i);
14659 }
14660 public List<PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext> primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary() {
14661 return getRuleContexts(PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext.class);
14662 }
14663 public PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary(int i) {
14664 return getRuleContext(PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext.class,i);
14665 }
14666 public ArrayAccess_lf_primaryContext(ParserRuleContext parent, int invokingState) {
14667 super(parent, invokingState);
14668 }
14669 @Override public int getRuleIndex() { return RULE_arrayAccess_lf_primary; }
14670 @Override
14671 public void enterRule(ParseTreeListener listener) {
14672 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterArrayAccess_lf_primary(this);
14673 }
14674 @Override
14675 public void exitRule(ParseTreeListener listener) {
14676 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitArrayAccess_lf_primary(this);
14677 }
14678 }
14679
14680 public final ArrayAccess_lf_primaryContext arrayAccess_lf_primary() throws RecognitionException {
14681 ArrayAccess_lf_primaryContext _localctx = new ArrayAccess_lf_primaryContext(_ctx, getState());
14682 enterRule(_localctx, 412, RULE_arrayAccess_lf_primary);
14683 try {
14684 int _alt;
14685 enterOuterAlt(_localctx, 1);
14686 {
14687 {
14688 setState(2394);
14689 primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary();
14690 setState(2395);
14691 match(LBRACK);
14692 setState(2396);
14693 expression();
14694 setState(2397);
14695 match(RBRACK);
14696 }
14697 setState(2406);
14698 _errHandler.sync(this);
14699 _alt = getInterpreter().adaptivePredict(_input,261,_ctx);
14700 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14701 if ( _alt==1 ) {
14702 {
14703 {
14704 setState(2399);
14705 primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary();
14706 setState(2400);
14707 match(LBRACK);
14708 setState(2401);
14709 expression();
14710 setState(2402);
14711 match(RBRACK);
14712 }
14713 }
14714 }
14715 setState(2408);
14716 _errHandler.sync(this);
14717 _alt = getInterpreter().adaptivePredict(_input,261,_ctx);
14718 }
14719 }
14720 }
14721 catch (RecognitionException re) {
14722 _localctx.exception = re;
14723 _errHandler.reportError(this, re);
14724 _errHandler.recover(this, re);
14725 }
14726 finally {
14727 exitRule();
14728 }
14729 return _localctx;
14730 }
14731
14732 public static class ArrayAccess_lfno_primaryContext extends ParserRuleContext {
14733 public ExpressionNameContext expressionName() {
14734 return getRuleContext(ExpressionNameContext.class,0);
14735 }
14736 public List<ExpressionContext> expression() {
14737 return getRuleContexts(ExpressionContext.class);
14738 }
14739 public ExpressionContext expression(int i) {
14740 return getRuleContext(ExpressionContext.class,i);
14741 }
14742 public PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary() {
14743 return getRuleContext(PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext.class,0);
14744 }
14745 public List<PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext> primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary() {
14746 return getRuleContexts(PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext.class);
14747 }
14748 public PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary(int i) {
14749 return getRuleContext(PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext.class,i);
14750 }
14751 public ArrayAccess_lfno_primaryContext(ParserRuleContext parent, int invokingState) {
14752 super(parent, invokingState);
14753 }
14754 @Override public int getRuleIndex() { return RULE_arrayAccess_lfno_primary; }
14755 @Override
14756 public void enterRule(ParseTreeListener listener) {
14757 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterArrayAccess_lfno_primary(this);
14758 }
14759 @Override
14760 public void exitRule(ParseTreeListener listener) {
14761 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitArrayAccess_lfno_primary(this);
14762 }
14763 }
14764
14765 public final ArrayAccess_lfno_primaryContext arrayAccess_lfno_primary() throws RecognitionException {
14766 ArrayAccess_lfno_primaryContext _localctx = new ArrayAccess_lfno_primaryContext(_ctx, getState());
14767 enterRule(_localctx, 414, RULE_arrayAccess_lfno_primary);
14768 try {
14769 int _alt;
14770 enterOuterAlt(_localctx, 1);
14771 {
14772 setState(2419);
14773 _errHandler.sync(this);
14774 switch ( getInterpreter().adaptivePredict(_input,262,_ctx) ) {
14775 case 1:
14776 {
14777 setState(2409);
14778 expressionName();
14779 setState(2410);
14780 match(LBRACK);
14781 setState(2411);
14782 expression();
14783 setState(2412);
14784 match(RBRACK);
14785 }
14786 break;
14787 case 2:
14788 {
14789 setState(2414);
14790 primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary();
14791 setState(2415);
14792 match(LBRACK);
14793 setState(2416);
14794 expression();
14795 setState(2417);
14796 match(RBRACK);
14797 }
14798 break;
14799 }
14800 setState(2428);
14801 _errHandler.sync(this);
14802 _alt = getInterpreter().adaptivePredict(_input,263,_ctx);
14803 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
14804 if ( _alt==1 ) {
14805 {
14806 {
14807 setState(2421);
14808 primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary();
14809 setState(2422);
14810 match(LBRACK);
14811 setState(2423);
14812 expression();
14813 setState(2424);
14814 match(RBRACK);
14815 }
14816 }
14817 }
14818 setState(2430);
14819 _errHandler.sync(this);
14820 _alt = getInterpreter().adaptivePredict(_input,263,_ctx);
14821 }
14822 }
14823 }
14824 catch (RecognitionException re) {
14825 _localctx.exception = re;
14826 _errHandler.reportError(this, re);
14827 _errHandler.recover(this, re);
14828 }
14829 finally {
14830 exitRule();
14831 }
14832 return _localctx;
14833 }
14834
14835 public static class MethodInvocationContext extends ParserRuleContext {
14836 public MethodNameContext methodName() {
14837 return getRuleContext(MethodNameContext.class,0);
14838 }
14839 public ArgumentListContext argumentList() {
14840 return getRuleContext(ArgumentListContext.class,0);
14841 }
14842 public TypeNameContext typeName() {
14843 return getRuleContext(TypeNameContext.class,0);
14844 }
14845 public IdentifierContext identifier() {
14846 return getRuleContext(IdentifierContext.class,0);
14847 }
14848 public TypeArgumentsContext typeArguments() {
14849 return getRuleContext(TypeArgumentsContext.class,0);
14850 }
14851 public ExpressionNameContext expressionName() {
14852 return getRuleContext(ExpressionNameContext.class,0);
14853 }
14854 public PrimaryContext primary() {
14855 return getRuleContext(PrimaryContext.class,0);
14856 }
14857 public MethodInvocationContext(ParserRuleContext parent, int invokingState) {
14858 super(parent, invokingState);
14859 }
14860 @Override public int getRuleIndex() { return RULE_methodInvocation; }
14861 @Override
14862 public void enterRule(ParseTreeListener listener) {
14863 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterMethodInvocation(this);
14864 }
14865 @Override
14866 public void exitRule(ParseTreeListener listener) {
14867 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitMethodInvocation(this);
14868 }
14869 }
14870
14871 public final MethodInvocationContext methodInvocation() throws RecognitionException {
14872 MethodInvocationContext _localctx = new MethodInvocationContext(_ctx, getState());
14873 enterRule(_localctx, 416, RULE_methodInvocation);
14874 int _la;
14875 try {
14876 setState(2500);
14877 _errHandler.sync(this);
14878 switch ( getInterpreter().adaptivePredict(_input,275,_ctx) ) {
14879 case 1:
14880 enterOuterAlt(_localctx, 1);
14881 {
14882 setState(2431);
14883 methodName();
14884 setState(2432);
14885 match(LPAREN);
14886 setState(2434);
14887 _errHandler.sync(this);
14888 _la = _input.LA(1);
14889 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)) {
14890 {
14891 setState(2433);
14892 argumentList();
14893 }
14894 }
14895
14896 setState(2436);
14897 match(RPAREN);
14898 }
14899 break;
14900 case 2:
14901 enterOuterAlt(_localctx, 2);
14902 {
14903 setState(2438);
14904 typeName();
14905 setState(2439);
14906 match(DOT);
14907 setState(2441);
14908 _errHandler.sync(this);
14909 _la = _input.LA(1);
14910 if (_la==LT) {
14911 {
14912 setState(2440);
14913 typeArguments();
14914 }
14915 }
14916
14917 setState(2443);
14918 identifier();
14919 setState(2444);
14920 match(LPAREN);
14921 setState(2446);
14922 _errHandler.sync(this);
14923 _la = _input.LA(1);
14924 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)) {
14925 {
14926 setState(2445);
14927 argumentList();
14928 }
14929 }
14930
14931 setState(2448);
14932 match(RPAREN);
14933 }
14934 break;
14935 case 3:
14936 enterOuterAlt(_localctx, 3);
14937 {
14938 setState(2450);
14939 expressionName();
14940 setState(2451);
14941 match(DOT);
14942 setState(2453);
14943 _errHandler.sync(this);
14944 _la = _input.LA(1);
14945 if (_la==LT) {
14946 {
14947 setState(2452);
14948 typeArguments();
14949 }
14950 }
14951
14952 setState(2455);
14953 identifier();
14954 setState(2456);
14955 match(LPAREN);
14956 setState(2458);
14957 _errHandler.sync(this);
14958 _la = _input.LA(1);
14959 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)) {
14960 {
14961 setState(2457);
14962 argumentList();
14963 }
14964 }
14965
14966 setState(2460);
14967 match(RPAREN);
14968 }
14969 break;
14970 case 4:
14971 enterOuterAlt(_localctx, 4);
14972 {
14973 setState(2462);
14974 primary();
14975 setState(2463);
14976 match(DOT);
14977 setState(2465);
14978 _errHandler.sync(this);
14979 _la = _input.LA(1);
14980 if (_la==LT) {
14981 {
14982 setState(2464);
14983 typeArguments();
14984 }
14985 }
14986
14987 setState(2467);
14988 identifier();
14989 setState(2468);
14990 match(LPAREN);
14991 setState(2470);
14992 _errHandler.sync(this);
14993 _la = _input.LA(1);
14994 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)) {
14995 {
14996 setState(2469);
14997 argumentList();
14998 }
14999 }
15000
15001 setState(2472);
15002 match(RPAREN);
15003 }
15004 break;
15005 case 5:
15006 enterOuterAlt(_localctx, 5);
15007 {
15008 setState(2474);
15009 match(SUPER);
15010 setState(2475);
15011 match(DOT);
15012 setState(2477);
15013 _errHandler.sync(this);
15014 _la = _input.LA(1);
15015 if (_la==LT) {
15016 {
15017 setState(2476);
15018 typeArguments();
15019 }
15020 }
15021
15022 setState(2479);
15023 identifier();
15024 setState(2480);
15025 match(LPAREN);
15026 setState(2482);
15027 _errHandler.sync(this);
15028 _la = _input.LA(1);
15029 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)) {
15030 {
15031 setState(2481);
15032 argumentList();
15033 }
15034 }
15035
15036 setState(2484);
15037 match(RPAREN);
15038 }
15039 break;
15040 case 6:
15041 enterOuterAlt(_localctx, 6);
15042 {
15043 setState(2486);
15044 typeName();
15045 setState(2487);
15046 match(DOT);
15047 setState(2488);
15048 match(SUPER);
15049 setState(2489);
15050 match(DOT);
15051 setState(2491);
15052 _errHandler.sync(this);
15053 _la = _input.LA(1);
15054 if (_la==LT) {
15055 {
15056 setState(2490);
15057 typeArguments();
15058 }
15059 }
15060
15061 setState(2493);
15062 identifier();
15063 setState(2494);
15064 match(LPAREN);
15065 setState(2496);
15066 _errHandler.sync(this);
15067 _la = _input.LA(1);
15068 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)) {
15069 {
15070 setState(2495);
15071 argumentList();
15072 }
15073 }
15074
15075 setState(2498);
15076 match(RPAREN);
15077 }
15078 break;
15079 }
15080 }
15081 catch (RecognitionException re) {
15082 _localctx.exception = re;
15083 _errHandler.reportError(this, re);
15084 _errHandler.recover(this, re);
15085 }
15086 finally {
15087 exitRule();
15088 }
15089 return _localctx;
15090 }
15091
15092 public static class MethodInvocation_lf_primaryContext extends ParserRuleContext {
15093 public IdentifierContext identifier() {
15094 return getRuleContext(IdentifierContext.class,0);
15095 }
15096 public TypeArgumentsContext typeArguments() {
15097 return getRuleContext(TypeArgumentsContext.class,0);
15098 }
15099 public ArgumentListContext argumentList() {
15100 return getRuleContext(ArgumentListContext.class,0);
15101 }
15102 public MethodInvocation_lf_primaryContext(ParserRuleContext parent, int invokingState) {
15103 super(parent, invokingState);
15104 }
15105 @Override public int getRuleIndex() { return RULE_methodInvocation_lf_primary; }
15106 @Override
15107 public void enterRule(ParseTreeListener listener) {
15108 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterMethodInvocation_lf_primary(this);
15109 }
15110 @Override
15111 public void exitRule(ParseTreeListener listener) {
15112 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitMethodInvocation_lf_primary(this);
15113 }
15114 }
15115
15116 public final MethodInvocation_lf_primaryContext methodInvocation_lf_primary() throws RecognitionException {
15117 MethodInvocation_lf_primaryContext _localctx = new MethodInvocation_lf_primaryContext(_ctx, getState());
15118 enterRule(_localctx, 418, RULE_methodInvocation_lf_primary);
15119 int _la;
15120 try {
15121 enterOuterAlt(_localctx, 1);
15122 {
15123 setState(2502);
15124 match(DOT);
15125 setState(2504);
15126 _errHandler.sync(this);
15127 _la = _input.LA(1);
15128 if (_la==LT) {
15129 {
15130 setState(2503);
15131 typeArguments();
15132 }
15133 }
15134
15135 setState(2506);
15136 identifier();
15137 setState(2507);
15138 match(LPAREN);
15139 setState(2509);
15140 _errHandler.sync(this);
15141 _la = _input.LA(1);
15142 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)) {
15143 {
15144 setState(2508);
15145 argumentList();
15146 }
15147 }
15148
15149 setState(2511);
15150 match(RPAREN);
15151 }
15152 }
15153 catch (RecognitionException re) {
15154 _localctx.exception = re;
15155 _errHandler.reportError(this, re);
15156 _errHandler.recover(this, re);
15157 }
15158 finally {
15159 exitRule();
15160 }
15161 return _localctx;
15162 }
15163
15164 public static class MethodInvocation_lfno_primaryContext extends ParserRuleContext {
15165 public MethodNameContext methodName() {
15166 return getRuleContext(MethodNameContext.class,0);
15167 }
15168 public ArgumentListContext argumentList() {
15169 return getRuleContext(ArgumentListContext.class,0);
15170 }
15171 public TypeNameContext typeName() {
15172 return getRuleContext(TypeNameContext.class,0);
15173 }
15174 public IdentifierContext identifier() {
15175 return getRuleContext(IdentifierContext.class,0);
15176 }
15177 public TypeArgumentsContext typeArguments() {
15178 return getRuleContext(TypeArgumentsContext.class,0);
15179 }
15180 public ExpressionNameContext expressionName() {
15181 return getRuleContext(ExpressionNameContext.class,0);
15182 }
15183 public MethodInvocation_lfno_primaryContext(ParserRuleContext parent, int invokingState) {
15184 super(parent, invokingState);
15185 }
15186 @Override public int getRuleIndex() { return RULE_methodInvocation_lfno_primary; }
15187 @Override
15188 public void enterRule(ParseTreeListener listener) {
15189 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterMethodInvocation_lfno_primary(this);
15190 }
15191 @Override
15192 public void exitRule(ParseTreeListener listener) {
15193 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitMethodInvocation_lfno_primary(this);
15194 }
15195 }
15196
15197 public final MethodInvocation_lfno_primaryContext methodInvocation_lfno_primary() throws RecognitionException {
15198 MethodInvocation_lfno_primaryContext _localctx = new MethodInvocation_lfno_primaryContext(_ctx, getState());
15199 enterRule(_localctx, 420, RULE_methodInvocation_lfno_primary);
15200 int _la;
15201 try {
15202 setState(2570);
15203 _errHandler.sync(this);
15204 switch ( getInterpreter().adaptivePredict(_input,287,_ctx) ) {
15205 case 1:
15206 enterOuterAlt(_localctx, 1);
15207 {
15208 setState(2513);
15209 methodName();
15210 setState(2514);
15211 match(LPAREN);
15212 setState(2516);
15213 _errHandler.sync(this);
15214 _la = _input.LA(1);
15215 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)) {
15216 {
15217 setState(2515);
15218 argumentList();
15219 }
15220 }
15221
15222 setState(2518);
15223 match(RPAREN);
15224 }
15225 break;
15226 case 2:
15227 enterOuterAlt(_localctx, 2);
15228 {
15229 setState(2520);
15230 typeName();
15231 setState(2521);
15232 match(DOT);
15233 setState(2523);
15234 _errHandler.sync(this);
15235 _la = _input.LA(1);
15236 if (_la==LT) {
15237 {
15238 setState(2522);
15239 typeArguments();
15240 }
15241 }
15242
15243 setState(2525);
15244 identifier();
15245 setState(2526);
15246 match(LPAREN);
15247 setState(2528);
15248 _errHandler.sync(this);
15249 _la = _input.LA(1);
15250 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)) {
15251 {
15252 setState(2527);
15253 argumentList();
15254 }
15255 }
15256
15257 setState(2530);
15258 match(RPAREN);
15259 }
15260 break;
15261 case 3:
15262 enterOuterAlt(_localctx, 3);
15263 {
15264 setState(2532);
15265 expressionName();
15266 setState(2533);
15267 match(DOT);
15268 setState(2535);
15269 _errHandler.sync(this);
15270 _la = _input.LA(1);
15271 if (_la==LT) {
15272 {
15273 setState(2534);
15274 typeArguments();
15275 }
15276 }
15277
15278 setState(2537);
15279 identifier();
15280 setState(2538);
15281 match(LPAREN);
15282 setState(2540);
15283 _errHandler.sync(this);
15284 _la = _input.LA(1);
15285 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)) {
15286 {
15287 setState(2539);
15288 argumentList();
15289 }
15290 }
15291
15292 setState(2542);
15293 match(RPAREN);
15294 }
15295 break;
15296 case 4:
15297 enterOuterAlt(_localctx, 4);
15298 {
15299 setState(2544);
15300 match(SUPER);
15301 setState(2545);
15302 match(DOT);
15303 setState(2547);
15304 _errHandler.sync(this);
15305 _la = _input.LA(1);
15306 if (_la==LT) {
15307 {
15308 setState(2546);
15309 typeArguments();
15310 }
15311 }
15312
15313 setState(2549);
15314 identifier();
15315 setState(2550);
15316 match(LPAREN);
15317 setState(2552);
15318 _errHandler.sync(this);
15319 _la = _input.LA(1);
15320 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)) {
15321 {
15322 setState(2551);
15323 argumentList();
15324 }
15325 }
15326
15327 setState(2554);
15328 match(RPAREN);
15329 }
15330 break;
15331 case 5:
15332 enterOuterAlt(_localctx, 5);
15333 {
15334 setState(2556);
15335 typeName();
15336 setState(2557);
15337 match(DOT);
15338 setState(2558);
15339 match(SUPER);
15340 setState(2559);
15341 match(DOT);
15342 setState(2561);
15343 _errHandler.sync(this);
15344 _la = _input.LA(1);
15345 if (_la==LT) {
15346 {
15347 setState(2560);
15348 typeArguments();
15349 }
15350 }
15351
15352 setState(2563);
15353 identifier();
15354 setState(2564);
15355 match(LPAREN);
15356 setState(2566);
15357 _errHandler.sync(this);
15358 _la = _input.LA(1);
15359 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)) {
15360 {
15361 setState(2565);
15362 argumentList();
15363 }
15364 }
15365
15366 setState(2568);
15367 match(RPAREN);
15368 }
15369 break;
15370 }
15371 }
15372 catch (RecognitionException re) {
15373 _localctx.exception = re;
15374 _errHandler.reportError(this, re);
15375 _errHandler.recover(this, re);
15376 }
15377 finally {
15378 exitRule();
15379 }
15380 return _localctx;
15381 }
15382
15383 public static class ArgumentListContext extends ParserRuleContext {
15384 public List<ExpressionContext> expression() {
15385 return getRuleContexts(ExpressionContext.class);
15386 }
15387 public ExpressionContext expression(int i) {
15388 return getRuleContext(ExpressionContext.class,i);
15389 }
15390 public ArgumentListContext(ParserRuleContext parent, int invokingState) {
15391 super(parent, invokingState);
15392 }
15393 @Override public int getRuleIndex() { return RULE_argumentList; }
15394 @Override
15395 public void enterRule(ParseTreeListener listener) {
15396 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterArgumentList(this);
15397 }
15398 @Override
15399 public void exitRule(ParseTreeListener listener) {
15400 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitArgumentList(this);
15401 }
15402 }
15403
15404 public final ArgumentListContext argumentList() throws RecognitionException {
15405 ArgumentListContext _localctx = new ArgumentListContext(_ctx, getState());
15406 enterRule(_localctx, 422, RULE_argumentList);
15407 int _la;
15408 try {
15409 enterOuterAlt(_localctx, 1);
15410 {
15411 setState(2572);
15412 expression();
15413 setState(2577);
15414 _errHandler.sync(this);
15415 _la = _input.LA(1);
15416 while (_la==COMMA) {
15417 {
15418 {
15419 setState(2573);
15420 match(COMMA);
15421 setState(2574);
15422 expression();
15423 }
15424 }
15425 setState(2579);
15426 _errHandler.sync(this);
15427 _la = _input.LA(1);
15428 }
15429 }
15430 }
15431 catch (RecognitionException re) {
15432 _localctx.exception = re;
15433 _errHandler.reportError(this, re);
15434 _errHandler.recover(this, re);
15435 }
15436 finally {
15437 exitRule();
15438 }
15439 return _localctx;
15440 }
15441
15442 public static class MethodReferenceContext extends ParserRuleContext {
15443 public ExpressionNameContext expressionName() {
15444 return getRuleContext(ExpressionNameContext.class,0);
15445 }
15446 public IdentifierContext identifier() {
15447 return getRuleContext(IdentifierContext.class,0);
15448 }
15449 public TypeArgumentsContext typeArguments() {
15450 return getRuleContext(TypeArgumentsContext.class,0);
15451 }
15452 public ReferenceTypeContext referenceType() {
15453 return getRuleContext(ReferenceTypeContext.class,0);
15454 }
15455 public PrimaryContext primary() {
15456 return getRuleContext(PrimaryContext.class,0);
15457 }
15458 public TypeNameContext typeName() {
15459 return getRuleContext(TypeNameContext.class,0);
15460 }
15461 public ClassTypeContext classType() {
15462 return getRuleContext(ClassTypeContext.class,0);
15463 }
15464 public ArrayTypeContext arrayType() {
15465 return getRuleContext(ArrayTypeContext.class,0);
15466 }
15467 public MethodReferenceContext(ParserRuleContext parent, int invokingState) {
15468 super(parent, invokingState);
15469 }
15470 @Override public int getRuleIndex() { return RULE_methodReference; }
15471 @Override
15472 public void enterRule(ParseTreeListener listener) {
15473 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterMethodReference(this);
15474 }
15475 @Override
15476 public void exitRule(ParseTreeListener listener) {
15477 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitMethodReference(this);
15478 }
15479 }
15480
15481 public final MethodReferenceContext methodReference() throws RecognitionException {
15482 MethodReferenceContext _localctx = new MethodReferenceContext(_ctx, getState());
15483 enterRule(_localctx, 424, RULE_methodReference);
15484 int _la;
15485 try {
15486 setState(2627);
15487 _errHandler.sync(this);
15488 switch ( getInterpreter().adaptivePredict(_input,295,_ctx) ) {
15489 case 1:
15490 enterOuterAlt(_localctx, 1);
15491 {
15492 setState(2580);
15493 expressionName();
15494 setState(2581);
15495 match(COLONCOLON);
15496 setState(2583);
15497 _errHandler.sync(this);
15498 _la = _input.LA(1);
15499 if (_la==LT) {
15500 {
15501 setState(2582);
15502 typeArguments();
15503 }
15504 }
15505
15506 setState(2585);
15507 identifier();
15508 }
15509 break;
15510 case 2:
15511 enterOuterAlt(_localctx, 2);
15512 {
15513 setState(2587);
15514 referenceType();
15515 setState(2588);
15516 match(COLONCOLON);
15517 setState(2590);
15518 _errHandler.sync(this);
15519 _la = _input.LA(1);
15520 if (_la==LT) {
15521 {
15522 setState(2589);
15523 typeArguments();
15524 }
15525 }
15526
15527 setState(2592);
15528 identifier();
15529 }
15530 break;
15531 case 3:
15532 enterOuterAlt(_localctx, 3);
15533 {
15534 setState(2594);
15535 primary();
15536 setState(2595);
15537 match(COLONCOLON);
15538 setState(2597);
15539 _errHandler.sync(this);
15540 _la = _input.LA(1);
15541 if (_la==LT) {
15542 {
15543 setState(2596);
15544 typeArguments();
15545 }
15546 }
15547
15548 setState(2599);
15549 identifier();
15550 }
15551 break;
15552 case 4:
15553 enterOuterAlt(_localctx, 4);
15554 {
15555 setState(2601);
15556 match(SUPER);
15557 setState(2602);
15558 match(COLONCOLON);
15559 setState(2604);
15560 _errHandler.sync(this);
15561 _la = _input.LA(1);
15562 if (_la==LT) {
15563 {
15564 setState(2603);
15565 typeArguments();
15566 }
15567 }
15568
15569 setState(2606);
15570 identifier();
15571 }
15572 break;
15573 case 5:
15574 enterOuterAlt(_localctx, 5);
15575 {
15576 setState(2607);
15577 typeName();
15578 setState(2608);
15579 match(DOT);
15580 setState(2609);
15581 match(SUPER);
15582 setState(2610);
15583 match(COLONCOLON);
15584 setState(2612);
15585 _errHandler.sync(this);
15586 _la = _input.LA(1);
15587 if (_la==LT) {
15588 {
15589 setState(2611);
15590 typeArguments();
15591 }
15592 }
15593
15594 setState(2614);
15595 identifier();
15596 }
15597 break;
15598 case 6:
15599 enterOuterAlt(_localctx, 6);
15600 {
15601 setState(2616);
15602 classType();
15603 setState(2617);
15604 match(COLONCOLON);
15605 setState(2619);
15606 _errHandler.sync(this);
15607 _la = _input.LA(1);
15608 if (_la==LT) {
15609 {
15610 setState(2618);
15611 typeArguments();
15612 }
15613 }
15614
15615 setState(2621);
15616 match(NEW);
15617 }
15618 break;
15619 case 7:
15620 enterOuterAlt(_localctx, 7);
15621 {
15622 setState(2623);
15623 arrayType();
15624 setState(2624);
15625 match(COLONCOLON);
15626 setState(2625);
15627 match(NEW);
15628 }
15629 break;
15630 }
15631 }
15632 catch (RecognitionException re) {
15633 _localctx.exception = re;
15634 _errHandler.reportError(this, re);
15635 _errHandler.recover(this, re);
15636 }
15637 finally {
15638 exitRule();
15639 }
15640 return _localctx;
15641 }
15642
15643 public static class MethodReference_lf_primaryContext extends ParserRuleContext {
15644 public IdentifierContext identifier() {
15645 return getRuleContext(IdentifierContext.class,0);
15646 }
15647 public TypeArgumentsContext typeArguments() {
15648 return getRuleContext(TypeArgumentsContext.class,0);
15649 }
15650 public MethodReference_lf_primaryContext(ParserRuleContext parent, int invokingState) {
15651 super(parent, invokingState);
15652 }
15653 @Override public int getRuleIndex() { return RULE_methodReference_lf_primary; }
15654 @Override
15655 public void enterRule(ParseTreeListener listener) {
15656 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterMethodReference_lf_primary(this);
15657 }
15658 @Override
15659 public void exitRule(ParseTreeListener listener) {
15660 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitMethodReference_lf_primary(this);
15661 }
15662 }
15663
15664 public final MethodReference_lf_primaryContext methodReference_lf_primary() throws RecognitionException {
15665 MethodReference_lf_primaryContext _localctx = new MethodReference_lf_primaryContext(_ctx, getState());
15666 enterRule(_localctx, 426, RULE_methodReference_lf_primary);
15667 int _la;
15668 try {
15669 enterOuterAlt(_localctx, 1);
15670 {
15671 setState(2629);
15672 match(COLONCOLON);
15673 setState(2631);
15674 _errHandler.sync(this);
15675 _la = _input.LA(1);
15676 if (_la==LT) {
15677 {
15678 setState(2630);
15679 typeArguments();
15680 }
15681 }
15682
15683 setState(2633);
15684 identifier();
15685 }
15686 }
15687 catch (RecognitionException re) {
15688 _localctx.exception = re;
15689 _errHandler.reportError(this, re);
15690 _errHandler.recover(this, re);
15691 }
15692 finally {
15693 exitRule();
15694 }
15695 return _localctx;
15696 }
15697
15698 public static class MethodReference_lfno_primaryContext extends ParserRuleContext {
15699 public ExpressionNameContext expressionName() {
15700 return getRuleContext(ExpressionNameContext.class,0);
15701 }
15702 public IdentifierContext identifier() {
15703 return getRuleContext(IdentifierContext.class,0);
15704 }
15705 public TypeArgumentsContext typeArguments() {
15706 return getRuleContext(TypeArgumentsContext.class,0);
15707 }
15708 public ReferenceTypeContext referenceType() {
15709 return getRuleContext(ReferenceTypeContext.class,0);
15710 }
15711 public TypeNameContext typeName() {
15712 return getRuleContext(TypeNameContext.class,0);
15713 }
15714 public ClassTypeContext classType() {
15715 return getRuleContext(ClassTypeContext.class,0);
15716 }
15717 public ArrayTypeContext arrayType() {
15718 return getRuleContext(ArrayTypeContext.class,0);
15719 }
15720 public MethodReference_lfno_primaryContext(ParserRuleContext parent, int invokingState) {
15721 super(parent, invokingState);
15722 }
15723 @Override public int getRuleIndex() { return RULE_methodReference_lfno_primary; }
15724 @Override
15725 public void enterRule(ParseTreeListener listener) {
15726 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterMethodReference_lfno_primary(this);
15727 }
15728 @Override
15729 public void exitRule(ParseTreeListener listener) {
15730 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitMethodReference_lfno_primary(this);
15731 }
15732 }
15733
15734 public final MethodReference_lfno_primaryContext methodReference_lfno_primary() throws RecognitionException {
15735 MethodReference_lfno_primaryContext _localctx = new MethodReference_lfno_primaryContext(_ctx, getState());
15736 enterRule(_localctx, 428, RULE_methodReference_lfno_primary);
15737 int _la;
15738 try {
15739 setState(2675);
15740 _errHandler.sync(this);
15741 switch ( getInterpreter().adaptivePredict(_input,302,_ctx) ) {
15742 case 1:
15743 enterOuterAlt(_localctx, 1);
15744 {
15745 setState(2635);
15746 expressionName();
15747 setState(2636);
15748 match(COLONCOLON);
15749 setState(2638);
15750 _errHandler.sync(this);
15751 _la = _input.LA(1);
15752 if (_la==LT) {
15753 {
15754 setState(2637);
15755 typeArguments();
15756 }
15757 }
15758
15759 setState(2640);
15760 identifier();
15761 }
15762 break;
15763 case 2:
15764 enterOuterAlt(_localctx, 2);
15765 {
15766 setState(2642);
15767 referenceType();
15768 setState(2643);
15769 match(COLONCOLON);
15770 setState(2645);
15771 _errHandler.sync(this);
15772 _la = _input.LA(1);
15773 if (_la==LT) {
15774 {
15775 setState(2644);
15776 typeArguments();
15777 }
15778 }
15779
15780 setState(2647);
15781 identifier();
15782 }
15783 break;
15784 case 3:
15785 enterOuterAlt(_localctx, 3);
15786 {
15787 setState(2649);
15788 match(SUPER);
15789 setState(2650);
15790 match(COLONCOLON);
15791 setState(2652);
15792 _errHandler.sync(this);
15793 _la = _input.LA(1);
15794 if (_la==LT) {
15795 {
15796 setState(2651);
15797 typeArguments();
15798 }
15799 }
15800
15801 setState(2654);
15802 identifier();
15803 }
15804 break;
15805 case 4:
15806 enterOuterAlt(_localctx, 4);
15807 {
15808 setState(2655);
15809 typeName();
15810 setState(2656);
15811 match(DOT);
15812 setState(2657);
15813 match(SUPER);
15814 setState(2658);
15815 match(COLONCOLON);
15816 setState(2660);
15817 _errHandler.sync(this);
15818 _la = _input.LA(1);
15819 if (_la==LT) {
15820 {
15821 setState(2659);
15822 typeArguments();
15823 }
15824 }
15825
15826 setState(2662);
15827 identifier();
15828 }
15829 break;
15830 case 5:
15831 enterOuterAlt(_localctx, 5);
15832 {
15833 setState(2664);
15834 classType();
15835 setState(2665);
15836 match(COLONCOLON);
15837 setState(2667);
15838 _errHandler.sync(this);
15839 _la = _input.LA(1);
15840 if (_la==LT) {
15841 {
15842 setState(2666);
15843 typeArguments();
15844 }
15845 }
15846
15847 setState(2669);
15848 match(NEW);
15849 }
15850 break;
15851 case 6:
15852 enterOuterAlt(_localctx, 6);
15853 {
15854 setState(2671);
15855 arrayType();
15856 setState(2672);
15857 match(COLONCOLON);
15858 setState(2673);
15859 match(NEW);
15860 }
15861 break;
15862 }
15863 }
15864 catch (RecognitionException re) {
15865 _localctx.exception = re;
15866 _errHandler.reportError(this, re);
15867 _errHandler.recover(this, re);
15868 }
15869 finally {
15870 exitRule();
15871 }
15872 return _localctx;
15873 }
15874
15875 public static class ArrayCreationExpressionContext extends ParserRuleContext {
15876 public PrimitiveTypeContext primitiveType() {
15877 return getRuleContext(PrimitiveTypeContext.class,0);
15878 }
15879 public DimExprsContext dimExprs() {
15880 return getRuleContext(DimExprsContext.class,0);
15881 }
15882 public DimsContext dims() {
15883 return getRuleContext(DimsContext.class,0);
15884 }
15885 public ClassOrInterfaceTypeContext classOrInterfaceType() {
15886 return getRuleContext(ClassOrInterfaceTypeContext.class,0);
15887 }
15888 public ArrayInitializerContext arrayInitializer() {
15889 return getRuleContext(ArrayInitializerContext.class,0);
15890 }
15891 public ArrayCreationExpressionContext(ParserRuleContext parent, int invokingState) {
15892 super(parent, invokingState);
15893 }
15894 @Override public int getRuleIndex() { return RULE_arrayCreationExpression; }
15895 @Override
15896 public void enterRule(ParseTreeListener listener) {
15897 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterArrayCreationExpression(this);
15898 }
15899 @Override
15900 public void exitRule(ParseTreeListener listener) {
15901 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitArrayCreationExpression(this);
15902 }
15903 }
15904
15905 public final ArrayCreationExpressionContext arrayCreationExpression() throws RecognitionException {
15906 ArrayCreationExpressionContext _localctx = new ArrayCreationExpressionContext(_ctx, getState());
15907 enterRule(_localctx, 430, RULE_arrayCreationExpression);
15908 try {
15909 setState(2699);
15910 _errHandler.sync(this);
15911 switch ( getInterpreter().adaptivePredict(_input,305,_ctx) ) {
15912 case 1:
15913 enterOuterAlt(_localctx, 1);
15914 {
15915 setState(2677);
15916 match(NEW);
15917 setState(2678);
15918 primitiveType();
15919 setState(2679);
15920 dimExprs();
15921 setState(2681);
15922 _errHandler.sync(this);
15923 switch ( getInterpreter().adaptivePredict(_input,303,_ctx) ) {
15924 case 1:
15925 {
15926 setState(2680);
15927 dims();
15928 }
15929 break;
15930 }
15931 }
15932 break;
15933 case 2:
15934 enterOuterAlt(_localctx, 2);
15935 {
15936 setState(2683);
15937 match(NEW);
15938 setState(2684);
15939 classOrInterfaceType();
15940 setState(2685);
15941 dimExprs();
15942 setState(2687);
15943 _errHandler.sync(this);
15944 switch ( getInterpreter().adaptivePredict(_input,304,_ctx) ) {
15945 case 1:
15946 {
15947 setState(2686);
15948 dims();
15949 }
15950 break;
15951 }
15952 }
15953 break;
15954 case 3:
15955 enterOuterAlt(_localctx, 3);
15956 {
15957 setState(2689);
15958 match(NEW);
15959 setState(2690);
15960 primitiveType();
15961 setState(2691);
15962 dims();
15963 setState(2692);
15964 arrayInitializer();
15965 }
15966 break;
15967 case 4:
15968 enterOuterAlt(_localctx, 4);
15969 {
15970 setState(2694);
15971 match(NEW);
15972 setState(2695);
15973 classOrInterfaceType();
15974 setState(2696);
15975 dims();
15976 setState(2697);
15977 arrayInitializer();
15978 }
15979 break;
15980 }
15981 }
15982 catch (RecognitionException re) {
15983 _localctx.exception = re;
15984 _errHandler.reportError(this, re);
15985 _errHandler.recover(this, re);
15986 }
15987 finally {
15988 exitRule();
15989 }
15990 return _localctx;
15991 }
15992
15993 public static class DimExprsContext extends ParserRuleContext {
15994 public List<DimExprContext> dimExpr() {
15995 return getRuleContexts(DimExprContext.class);
15996 }
15997 public DimExprContext dimExpr(int i) {
15998 return getRuleContext(DimExprContext.class,i);
15999 }
16000 public DimExprsContext(ParserRuleContext parent, int invokingState) {
16001 super(parent, invokingState);
16002 }
16003 @Override public int getRuleIndex() { return RULE_dimExprs; }
16004 @Override
16005 public void enterRule(ParseTreeListener listener) {
16006 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterDimExprs(this);
16007 }
16008 @Override
16009 public void exitRule(ParseTreeListener listener) {
16010 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitDimExprs(this);
16011 }
16012 }
16013
16014 public final DimExprsContext dimExprs() throws RecognitionException {
16015 DimExprsContext _localctx = new DimExprsContext(_ctx, getState());
16016 enterRule(_localctx, 432, RULE_dimExprs);
16017 try {
16018 int _alt;
16019 enterOuterAlt(_localctx, 1);
16020 {
16021 setState(2702);
16022 _errHandler.sync(this);
16023 _alt = 1;
16024 do {
16025 switch (_alt) {
16026 case 1:
16027 {
16028 {
16029 setState(2701);
16030 dimExpr();
16031 }
16032 }
16033 break;
16034 default:
16035 throw new NoViableAltException(this);
16036 }
16037 setState(2704);
16038 _errHandler.sync(this);
16039 _alt = getInterpreter().adaptivePredict(_input,306,_ctx);
16040 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
16041 }
16042 }
16043 catch (RecognitionException re) {
16044 _localctx.exception = re;
16045 _errHandler.reportError(this, re);
16046 _errHandler.recover(this, re);
16047 }
16048 finally {
16049 exitRule();
16050 }
16051 return _localctx;
16052 }
16053
16054 public static class DimExprContext extends ParserRuleContext {
16055 public ExpressionContext expression() {
16056 return getRuleContext(ExpressionContext.class,0);
16057 }
16058 public List<AnnotationContext> annotation() {
16059 return getRuleContexts(AnnotationContext.class);
16060 }
16061 public AnnotationContext annotation(int i) {
16062 return getRuleContext(AnnotationContext.class,i);
16063 }
16064 public DimExprContext(ParserRuleContext parent, int invokingState) {
16065 super(parent, invokingState);
16066 }
16067 @Override public int getRuleIndex() { return RULE_dimExpr; }
16068 @Override
16069 public void enterRule(ParseTreeListener listener) {
16070 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterDimExpr(this);
16071 }
16072 @Override
16073 public void exitRule(ParseTreeListener listener) {
16074 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitDimExpr(this);
16075 }
16076 }
16077
16078 public final DimExprContext dimExpr() throws RecognitionException {
16079 DimExprContext _localctx = new DimExprContext(_ctx, getState());
16080 enterRule(_localctx, 434, RULE_dimExpr);
16081 int _la;
16082 try {
16083 enterOuterAlt(_localctx, 1);
16084 {
16085 setState(2709);
16086 _errHandler.sync(this);
16087 _la = _input.LA(1);
16088 while (_la==AT) {
16089 {
16090 {
16091 setState(2706);
16092 annotation();
16093 }
16094 }
16095 setState(2711);
16096 _errHandler.sync(this);
16097 _la = _input.LA(1);
16098 }
16099 setState(2712);
16100 match(LBRACK);
16101 setState(2713);
16102 expression();
16103 setState(2714);
16104 match(RBRACK);
16105 }
16106 }
16107 catch (RecognitionException re) {
16108 _localctx.exception = re;
16109 _errHandler.reportError(this, re);
16110 _errHandler.recover(this, re);
16111 }
16112 finally {
16113 exitRule();
16114 }
16115 return _localctx;
16116 }
16117
16118 public static class ConstantExpressionContext extends ParserRuleContext {
16119 public ExpressionContext expression() {
16120 return getRuleContext(ExpressionContext.class,0);
16121 }
16122 public ConstantExpressionContext(ParserRuleContext parent, int invokingState) {
16123 super(parent, invokingState);
16124 }
16125 @Override public int getRuleIndex() { return RULE_constantExpression; }
16126 @Override
16127 public void enterRule(ParseTreeListener listener) {
16128 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterConstantExpression(this);
16129 }
16130 @Override
16131 public void exitRule(ParseTreeListener listener) {
16132 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitConstantExpression(this);
16133 }
16134 }
16135
16136 public final ConstantExpressionContext constantExpression() throws RecognitionException {
16137 ConstantExpressionContext _localctx = new ConstantExpressionContext(_ctx, getState());
16138 enterRule(_localctx, 436, RULE_constantExpression);
16139 try {
16140 enterOuterAlt(_localctx, 1);
16141 {
16142 setState(2716);
16143 expression();
16144 }
16145 }
16146 catch (RecognitionException re) {
16147 _localctx.exception = re;
16148 _errHandler.reportError(this, re);
16149 _errHandler.recover(this, re);
16150 }
16151 finally {
16152 exitRule();
16153 }
16154 return _localctx;
16155 }
16156
16157 public static class ExpressionContext extends ParserRuleContext {
16158 public LambdaExpressionContext lambdaExpression() {
16159 return getRuleContext(LambdaExpressionContext.class,0);
16160 }
16161 public AssignmentExpressionContext assignmentExpression() {
16162 return getRuleContext(AssignmentExpressionContext.class,0);
16163 }
16164 public ExpressionContext(ParserRuleContext parent, int invokingState) {
16165 super(parent, invokingState);
16166 }
16167 @Override public int getRuleIndex() { return RULE_expression; }
16168 @Override
16169 public void enterRule(ParseTreeListener listener) {
16170 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterExpression(this);
16171 }
16172 @Override
16173 public void exitRule(ParseTreeListener listener) {
16174 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitExpression(this);
16175 }
16176 }
16177
16178 public final ExpressionContext expression() throws RecognitionException {
16179 ExpressionContext _localctx = new ExpressionContext(_ctx, getState());
16180 enterRule(_localctx, 438, RULE_expression);
16181 try {
16182 setState(2720);
16183 _errHandler.sync(this);
16184 switch ( getInterpreter().adaptivePredict(_input,308,_ctx) ) {
16185 case 1:
16186 enterOuterAlt(_localctx, 1);
16187 {
16188 setState(2718);
16189 lambdaExpression();
16190 }
16191 break;
16192 case 2:
16193 enterOuterAlt(_localctx, 2);
16194 {
16195 setState(2719);
16196 assignmentExpression();
16197 }
16198 break;
16199 }
16200 }
16201 catch (RecognitionException re) {
16202 _localctx.exception = re;
16203 _errHandler.reportError(this, re);
16204 _errHandler.recover(this, re);
16205 }
16206 finally {
16207 exitRule();
16208 }
16209 return _localctx;
16210 }
16211
16212 public static class LambdaExpressionContext extends ParserRuleContext {
16213 public LambdaParametersContext lambdaParameters() {
16214 return getRuleContext(LambdaParametersContext.class,0);
16215 }
16216 public LambdaBodyContext lambdaBody() {
16217 return getRuleContext(LambdaBodyContext.class,0);
16218 }
16219 public LambdaExpressionContext(ParserRuleContext parent, int invokingState) {
16220 super(parent, invokingState);
16221 }
16222 @Override public int getRuleIndex() { return RULE_lambdaExpression; }
16223 @Override
16224 public void enterRule(ParseTreeListener listener) {
16225 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterLambdaExpression(this);
16226 }
16227 @Override
16228 public void exitRule(ParseTreeListener listener) {
16229 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitLambdaExpression(this);
16230 }
16231 }
16232
16233 public final LambdaExpressionContext lambdaExpression() throws RecognitionException {
16234 LambdaExpressionContext _localctx = new LambdaExpressionContext(_ctx, getState());
16235 enterRule(_localctx, 440, RULE_lambdaExpression);
16236 try {
16237 enterOuterAlt(_localctx, 1);
16238 {
16239 setState(2722);
16240 lambdaParameters();
16241 setState(2723);
16242 match(ARROW);
16243 setState(2724);
16244 lambdaBody();
16245 }
16246 }
16247 catch (RecognitionException re) {
16248 _localctx.exception = re;
16249 _errHandler.reportError(this, re);
16250 _errHandler.recover(this, re);
16251 }
16252 finally {
16253 exitRule();
16254 }
16255 return _localctx;
16256 }
16257
16258 public static class LambdaParametersContext extends ParserRuleContext {
16259 public IdentifierContext identifier() {
16260 return getRuleContext(IdentifierContext.class,0);
16261 }
16262 public FormalParameterListContext formalParameterList() {
16263 return getRuleContext(FormalParameterListContext.class,0);
16264 }
16265 public InferredFormalParameterListContext inferredFormalParameterList() {
16266 return getRuleContext(InferredFormalParameterListContext.class,0);
16267 }
16268 public LambdaParametersContext(ParserRuleContext parent, int invokingState) {
16269 super(parent, invokingState);
16270 }
16271 @Override public int getRuleIndex() { return RULE_lambdaParameters; }
16272 @Override
16273 public void enterRule(ParseTreeListener listener) {
16274 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterLambdaParameters(this);
16275 }
16276 @Override
16277 public void exitRule(ParseTreeListener listener) {
16278 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitLambdaParameters(this);
16279 }
16280 }
16281
16282 public final LambdaParametersContext lambdaParameters() throws RecognitionException {
16283 LambdaParametersContext _localctx = new LambdaParametersContext(_ctx, getState());
16284 enterRule(_localctx, 442, RULE_lambdaParameters);
16285 int _la;
16286 try {
16287 setState(2736);
16288 _errHandler.sync(this);
16289 switch ( getInterpreter().adaptivePredict(_input,310,_ctx) ) {
16290 case 1:
16291 enterOuterAlt(_localctx, 1);
16292 {
16293 setState(2726);
16294 identifier();
16295 }
16296 break;
16297 case 2:
16298 enterOuterAlt(_localctx, 2);
16299 {
16300 setState(2727);
16301 match(LPAREN);
16302 setState(2729);
16303 _errHandler.sync(this);
16304 _la = _input.LA(1);
16305 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) {
16306 {
16307 setState(2728);
16308 formalParameterList();
16309 }
16310 }
16311
16312 setState(2731);
16313 match(RPAREN);
16314 }
16315 break;
16316 case 3:
16317 enterOuterAlt(_localctx, 3);
16318 {
16319 setState(2732);
16320 match(LPAREN);
16321 setState(2733);
16322 inferredFormalParameterList();
16323 setState(2734);
16324 match(RPAREN);
16325 }
16326 break;
16327 }
16328 }
16329 catch (RecognitionException re) {
16330 _localctx.exception = re;
16331 _errHandler.reportError(this, re);
16332 _errHandler.recover(this, re);
16333 }
16334 finally {
16335 exitRule();
16336 }
16337 return _localctx;
16338 }
16339
16340 public static class InferredFormalParameterListContext extends ParserRuleContext {
16341 public List<IdentifierContext> identifier() {
16342 return getRuleContexts(IdentifierContext.class);
16343 }
16344 public IdentifierContext identifier(int i) {
16345 return getRuleContext(IdentifierContext.class,i);
16346 }
16347 public InferredFormalParameterListContext(ParserRuleContext parent, int invokingState) {
16348 super(parent, invokingState);
16349 }
16350 @Override public int getRuleIndex() { return RULE_inferredFormalParameterList; }
16351 @Override
16352 public void enterRule(ParseTreeListener listener) {
16353 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInferredFormalParameterList(this);
16354 }
16355 @Override
16356 public void exitRule(ParseTreeListener listener) {
16357 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInferredFormalParameterList(this);
16358 }
16359 }
16360
16361 public final InferredFormalParameterListContext inferredFormalParameterList() throws RecognitionException {
16362 InferredFormalParameterListContext _localctx = new InferredFormalParameterListContext(_ctx, getState());
16363 enterRule(_localctx, 444, RULE_inferredFormalParameterList);
16364 int _la;
16365 try {
16366 enterOuterAlt(_localctx, 1);
16367 {
16368 setState(2738);
16369 identifier();
16370 setState(2743);
16371 _errHandler.sync(this);
16372 _la = _input.LA(1);
16373 while (_la==COMMA) {
16374 {
16375 {
16376 setState(2739);
16377 match(COMMA);
16378 setState(2740);
16379 identifier();
16380 }
16381 }
16382 setState(2745);
16383 _errHandler.sync(this);
16384 _la = _input.LA(1);
16385 }
16386 }
16387 }
16388 catch (RecognitionException re) {
16389 _localctx.exception = re;
16390 _errHandler.reportError(this, re);
16391 _errHandler.recover(this, re);
16392 }
16393 finally {
16394 exitRule();
16395 }
16396 return _localctx;
16397 }
16398
16399 public static class LambdaBodyContext extends ParserRuleContext {
16400 public ExpressionContext expression() {
16401 return getRuleContext(ExpressionContext.class,0);
16402 }
16403 public BlockContext block() {
16404 return getRuleContext(BlockContext.class,0);
16405 }
16406 public LambdaBodyContext(ParserRuleContext parent, int invokingState) {
16407 super(parent, invokingState);
16408 }
16409 @Override public int getRuleIndex() { return RULE_lambdaBody; }
16410 @Override
16411 public void enterRule(ParseTreeListener listener) {
16412 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterLambdaBody(this);
16413 }
16414 @Override
16415 public void exitRule(ParseTreeListener listener) {
16416 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitLambdaBody(this);
16417 }
16418 }
16419
16420 public final LambdaBodyContext lambdaBody() throws RecognitionException {
16421 LambdaBodyContext _localctx = new LambdaBodyContext(_ctx, getState());
16422 enterRule(_localctx, 446, RULE_lambdaBody);
16423 try {
16424 setState(2748);
16425 _errHandler.sync(this);
16426 switch (_input.LA(1)) {
16427 case T__0:
16428 case T__1:
16429 case T__2:
16430 case T__3:
16431 case T__4:
16432 case T__5:
16433 case T__6:
16434 case T__7:
16435 case T__8:
16436 case BOOLEAN:
16437 case BYTE:
16438 case CHAR:
16439 case DOUBLE:
16440 case FLOAT:
16441 case INT:
16442 case LONG:
16443 case NEW:
16444 case SHORT:
16445 case SUPER:
16446 case THIS:
16447 case VOID:
16448 case IntegerLiteral:
16449 case FloatingPointLiteral:
16450 case BooleanLiteral:
16451 case CharacterLiteral:
16452 case StringLiteral:
16453 case NullLiteral:
16454 case LPAREN:
16455 case AT:
16456 case BANG:
16457 case TILDE:
16458 case INC:
16459 case DEC:
16460 case ADD:
16461 case SUB:
16462 case Identifier:
16463 enterOuterAlt(_localctx, 1);
16464 {
16465 setState(2746);
16466 expression();
16467 }
16468 break;
16469 case LBRACE:
16470 enterOuterAlt(_localctx, 2);
16471 {
16472 setState(2747);
16473 block();
16474 }
16475 break;
16476 default:
16477 throw new NoViableAltException(this);
16478 }
16479 }
16480 catch (RecognitionException re) {
16481 _localctx.exception = re;
16482 _errHandler.reportError(this, re);
16483 _errHandler.recover(this, re);
16484 }
16485 finally {
16486 exitRule();
16487 }
16488 return _localctx;
16489 }
16490
16491 public static class AssignmentExpressionContext extends ParserRuleContext {
16492 public ConditionalExpressionContext conditionalExpression() {
16493 return getRuleContext(ConditionalExpressionContext.class,0);
16494 }
16495 public AssignmentContext assignment() {
16496 return getRuleContext(AssignmentContext.class,0);
16497 }
16498 public AssignmentExpressionContext(ParserRuleContext parent, int invokingState) {
16499 super(parent, invokingState);
16500 }
16501 @Override public int getRuleIndex() { return RULE_assignmentExpression; }
16502 @Override
16503 public void enterRule(ParseTreeListener listener) {
16504 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterAssignmentExpression(this);
16505 }
16506 @Override
16507 public void exitRule(ParseTreeListener listener) {
16508 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitAssignmentExpression(this);
16509 }
16510 }
16511
16512 public final AssignmentExpressionContext assignmentExpression() throws RecognitionException {
16513 AssignmentExpressionContext _localctx = new AssignmentExpressionContext(_ctx, getState());
16514 enterRule(_localctx, 448, RULE_assignmentExpression);
16515 try {
16516 setState(2752);
16517 _errHandler.sync(this);
16518 switch ( getInterpreter().adaptivePredict(_input,313,_ctx) ) {
16519 case 1:
16520 enterOuterAlt(_localctx, 1);
16521 {
16522 setState(2750);
16523 conditionalExpression();
16524 }
16525 break;
16526 case 2:
16527 enterOuterAlt(_localctx, 2);
16528 {
16529 setState(2751);
16530 assignment();
16531 }
16532 break;
16533 }
16534 }
16535 catch (RecognitionException re) {
16536 _localctx.exception = re;
16537 _errHandler.reportError(this, re);
16538 _errHandler.recover(this, re);
16539 }
16540 finally {
16541 exitRule();
16542 }
16543 return _localctx;
16544 }
16545
16546 public static class AssignmentContext extends ParserRuleContext {
16547 public LeftHandSideContext leftHandSide() {
16548 return getRuleContext(LeftHandSideContext.class,0);
16549 }
16550 public AssignmentOperatorContext assignmentOperator() {
16551 return getRuleContext(AssignmentOperatorContext.class,0);
16552 }
16553 public ExpressionContext expression() {
16554 return getRuleContext(ExpressionContext.class,0);
16555 }
16556 public AssignmentContext(ParserRuleContext parent, int invokingState) {
16557 super(parent, invokingState);
16558 }
16559 @Override public int getRuleIndex() { return RULE_assignment; }
16560 @Override
16561 public void enterRule(ParseTreeListener listener) {
16562 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterAssignment(this);
16563 }
16564 @Override
16565 public void exitRule(ParseTreeListener listener) {
16566 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitAssignment(this);
16567 }
16568 }
16569
16570 public final AssignmentContext assignment() throws RecognitionException {
16571 AssignmentContext _localctx = new AssignmentContext(_ctx, getState());
16572 enterRule(_localctx, 450, RULE_assignment);
16573 try {
16574 enterOuterAlt(_localctx, 1);
16575 {
16576 setState(2754);
16577 leftHandSide();
16578 setState(2755);
16579 assignmentOperator();
16580 setState(2756);
16581 expression();
16582 }
16583 }
16584 catch (RecognitionException re) {
16585 _localctx.exception = re;
16586 _errHandler.reportError(this, re);
16587 _errHandler.recover(this, re);
16588 }
16589 finally {
16590 exitRule();
16591 }
16592 return _localctx;
16593 }
16594
16595 public static class LeftHandSideContext extends ParserRuleContext {
16596 public ExpressionNameContext expressionName() {
16597 return getRuleContext(ExpressionNameContext.class,0);
16598 }
16599 public FieldAccessContext fieldAccess() {
16600 return getRuleContext(FieldAccessContext.class,0);
16601 }
16602 public ArrayAccessContext arrayAccess() {
16603 return getRuleContext(ArrayAccessContext.class,0);
16604 }
16605 public LeftHandSideContext(ParserRuleContext parent, int invokingState) {
16606 super(parent, invokingState);
16607 }
16608 @Override public int getRuleIndex() { return RULE_leftHandSide; }
16609 @Override
16610 public void enterRule(ParseTreeListener listener) {
16611 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterLeftHandSide(this);
16612 }
16613 @Override
16614 public void exitRule(ParseTreeListener listener) {
16615 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitLeftHandSide(this);
16616 }
16617 }
16618
16619 public final LeftHandSideContext leftHandSide() throws RecognitionException {
16620 LeftHandSideContext _localctx = new LeftHandSideContext(_ctx, getState());
16621 enterRule(_localctx, 452, RULE_leftHandSide);
16622 try {
16623 setState(2761);
16624 _errHandler.sync(this);
16625 switch ( getInterpreter().adaptivePredict(_input,314,_ctx) ) {
16626 case 1:
16627 enterOuterAlt(_localctx, 1);
16628 {
16629 setState(2758);
16630 expressionName();
16631 }
16632 break;
16633 case 2:
16634 enterOuterAlt(_localctx, 2);
16635 {
16636 setState(2759);
16637 fieldAccess();
16638 }
16639 break;
16640 case 3:
16641 enterOuterAlt(_localctx, 3);
16642 {
16643 setState(2760);
16644 arrayAccess();
16645 }
16646 break;
16647 }
16648 }
16649 catch (RecognitionException re) {
16650 _localctx.exception = re;
16651 _errHandler.reportError(this, re);
16652 _errHandler.recover(this, re);
16653 }
16654 finally {
16655 exitRule();
16656 }
16657 return _localctx;
16658 }
16659
16660 public static class AssignmentOperatorContext extends ParserRuleContext {
16661 public AssignmentOperatorContext(ParserRuleContext parent, int invokingState) {
16662 super(parent, invokingState);
16663 }
16664 @Override public int getRuleIndex() { return RULE_assignmentOperator; }
16665 @Override
16666 public void enterRule(ParseTreeListener listener) {
16667 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterAssignmentOperator(this);
16668 }
16669 @Override
16670 public void exitRule(ParseTreeListener listener) {
16671 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitAssignmentOperator(this);
16672 }
16673 }
16674
16675 public final AssignmentOperatorContext assignmentOperator() throws RecognitionException {
16676 AssignmentOperatorContext _localctx = new AssignmentOperatorContext(_ctx, getState());
16677 enterRule(_localctx, 454, RULE_assignmentOperator);
16678 int _la;
16679 try {
16680 enterOuterAlt(_localctx, 1);
16681 {
16682 setState(2763);
16683 _la = _input.LA(1);
16684 if ( !(((((_la - 80)) & ~0x3f) == 0 && ((1L << (_la - 80)) & ((1L << (ASSIGN - 80)) | (1L << (ADD_ASSIGN - 80)) | (1L << (SUB_ASSIGN - 80)) | (1L << (MUL_ASSIGN - 80)) | (1L << (DIV_ASSIGN - 80)) | (1L << (AND_ASSIGN - 80)) | (1L << (OR_ASSIGN - 80)) | (1L << (XOR_ASSIGN - 80)) | (1L << (MOD_ASSIGN - 80)) | (1L << (LSHIFT_ASSIGN - 80)) | (1L << (RSHIFT_ASSIGN - 80)) | (1L << (URSHIFT_ASSIGN - 80)))) != 0)) ) {
16685 _errHandler.recoverInline(this);
16686 }
16687 else {
16688 if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
16689 _errHandler.reportMatch(this);
16690 consume();
16691 }
16692 }
16693 }
16694 catch (RecognitionException re) {
16695 _localctx.exception = re;
16696 _errHandler.reportError(this, re);
16697 _errHandler.recover(this, re);
16698 }
16699 finally {
16700 exitRule();
16701 }
16702 return _localctx;
16703 }
16704
16705 public static class ConditionalExpressionContext extends ParserRuleContext {
16706 public ConditionalOrExpressionContext conditionalOrExpression() {
16707 return getRuleContext(ConditionalOrExpressionContext.class,0);
16708 }
16709 public ExpressionContext expression() {
16710 return getRuleContext(ExpressionContext.class,0);
16711 }
16712 public ConditionalExpressionContext conditionalExpression() {
16713 return getRuleContext(ConditionalExpressionContext.class,0);
16714 }
16715 public LambdaExpressionContext lambdaExpression() {
16716 return getRuleContext(LambdaExpressionContext.class,0);
16717 }
16718 public ConditionalExpressionContext(ParserRuleContext parent, int invokingState) {
16719 super(parent, invokingState);
16720 }
16721 @Override public int getRuleIndex() { return RULE_conditionalExpression; }
16722 @Override
16723 public void enterRule(ParseTreeListener listener) {
16724 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterConditionalExpression(this);
16725 }
16726 @Override
16727 public void exitRule(ParseTreeListener listener) {
16728 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitConditionalExpression(this);
16729 }
16730 }
16731
16732 public final ConditionalExpressionContext conditionalExpression() throws RecognitionException {
16733 ConditionalExpressionContext _localctx = new ConditionalExpressionContext(_ctx, getState());
16734 enterRule(_localctx, 456, RULE_conditionalExpression);
16735 try {
16736 setState(2774);
16737 _errHandler.sync(this);
16738 switch ( getInterpreter().adaptivePredict(_input,316,_ctx) ) {
16739 case 1:
16740 enterOuterAlt(_localctx, 1);
16741 {
16742 setState(2765);
16743 conditionalOrExpression(0);
16744 }
16745 break;
16746 case 2:
16747 enterOuterAlt(_localctx, 2);
16748 {
16749 setState(2766);
16750 conditionalOrExpression(0);
16751 setState(2767);
16752 match(QUESTION);
16753 setState(2768);
16754 expression();
16755 setState(2769);
16756 match(COLON);
16757 setState(2772);
16758 _errHandler.sync(this);
16759 switch ( getInterpreter().adaptivePredict(_input,315,_ctx) ) {
16760 case 1:
16761 {
16762 setState(2770);
16763 conditionalExpression();
16764 }
16765 break;
16766 case 2:
16767 {
16768 setState(2771);
16769 lambdaExpression();
16770 }
16771 break;
16772 }
16773 }
16774 break;
16775 }
16776 }
16777 catch (RecognitionException re) {
16778 _localctx.exception = re;
16779 _errHandler.reportError(this, re);
16780 _errHandler.recover(this, re);
16781 }
16782 finally {
16783 exitRule();
16784 }
16785 return _localctx;
16786 }
16787
16788 public static class ConditionalOrExpressionContext extends ParserRuleContext {
16789 public ConditionalAndExpressionContext conditionalAndExpression() {
16790 return getRuleContext(ConditionalAndExpressionContext.class,0);
16791 }
16792 public ConditionalOrExpressionContext conditionalOrExpression() {
16793 return getRuleContext(ConditionalOrExpressionContext.class,0);
16794 }
16795 public ConditionalOrExpressionContext(ParserRuleContext parent, int invokingState) {
16796 super(parent, invokingState);
16797 }
16798 @Override public int getRuleIndex() { return RULE_conditionalOrExpression; }
16799 @Override
16800 public void enterRule(ParseTreeListener listener) {
16801 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterConditionalOrExpression(this);
16802 }
16803 @Override
16804 public void exitRule(ParseTreeListener listener) {
16805 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitConditionalOrExpression(this);
16806 }
16807 }
16808
16809 public final ConditionalOrExpressionContext conditionalOrExpression() throws RecognitionException {
16810 return conditionalOrExpression(0);
16811 }
16812
16813 private ConditionalOrExpressionContext conditionalOrExpression(int _p) throws RecognitionException {
16814 ParserRuleContext _parentctx = _ctx;
16815 int _parentState = getState();
16816 ConditionalOrExpressionContext _localctx = new ConditionalOrExpressionContext(_ctx, _parentState);
16817 ConditionalOrExpressionContext _prevctx = _localctx;
16818 int _startState = 458;
16819 enterRecursionRule(_localctx, 458, RULE_conditionalOrExpression, _p);
16820 try {
16821 int _alt;
16822 enterOuterAlt(_localctx, 1);
16823 {
16824 {
16825 setState(2777);
16826 conditionalAndExpression(0);
16827 }
16828 _ctx.stop = _input.LT(-1);
16829 setState(2784);
16830 _errHandler.sync(this);
16831 _alt = getInterpreter().adaptivePredict(_input,317,_ctx);
16832 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
16833 if ( _alt==1 ) {
16834 if ( _parseListeners!=null ) triggerExitRuleEvent();
16835 _prevctx = _localctx;
16836 {
16837 {
16838 _localctx = new ConditionalOrExpressionContext(_parentctx, _parentState);
16839 pushNewRecursionContext(_localctx, _startState, RULE_conditionalOrExpression);
16840 setState(2779);
16841 if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
16842 setState(2780);
16843 match(OR);
16844 setState(2781);
16845 conditionalAndExpression(0);
16846 }
16847 }
16848 }
16849 setState(2786);
16850 _errHandler.sync(this);
16851 _alt = getInterpreter().adaptivePredict(_input,317,_ctx);
16852 }
16853 }
16854 }
16855 catch (RecognitionException re) {
16856 _localctx.exception = re;
16857 _errHandler.reportError(this, re);
16858 _errHandler.recover(this, re);
16859 }
16860 finally {
16861 unrollRecursionContexts(_parentctx);
16862 }
16863 return _localctx;
16864 }
16865
16866 public static class ConditionalAndExpressionContext extends ParserRuleContext {
16867 public InclusiveOrExpressionContext inclusiveOrExpression() {
16868 return getRuleContext(InclusiveOrExpressionContext.class,0);
16869 }
16870 public ConditionalAndExpressionContext conditionalAndExpression() {
16871 return getRuleContext(ConditionalAndExpressionContext.class,0);
16872 }
16873 public ConditionalAndExpressionContext(ParserRuleContext parent, int invokingState) {
16874 super(parent, invokingState);
16875 }
16876 @Override public int getRuleIndex() { return RULE_conditionalAndExpression; }
16877 @Override
16878 public void enterRule(ParseTreeListener listener) {
16879 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterConditionalAndExpression(this);
16880 }
16881 @Override
16882 public void exitRule(ParseTreeListener listener) {
16883 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitConditionalAndExpression(this);
16884 }
16885 }
16886
16887 public final ConditionalAndExpressionContext conditionalAndExpression() throws RecognitionException {
16888 return conditionalAndExpression(0);
16889 }
16890
16891 private ConditionalAndExpressionContext conditionalAndExpression(int _p) throws RecognitionException {
16892 ParserRuleContext _parentctx = _ctx;
16893 int _parentState = getState();
16894 ConditionalAndExpressionContext _localctx = new ConditionalAndExpressionContext(_ctx, _parentState);
16895 ConditionalAndExpressionContext _prevctx = _localctx;
16896 int _startState = 460;
16897 enterRecursionRule(_localctx, 460, RULE_conditionalAndExpression, _p);
16898 try {
16899 int _alt;
16900 enterOuterAlt(_localctx, 1);
16901 {
16902 {
16903 setState(2788);
16904 inclusiveOrExpression(0);
16905 }
16906 _ctx.stop = _input.LT(-1);
16907 setState(2795);
16908 _errHandler.sync(this);
16909 _alt = getInterpreter().adaptivePredict(_input,318,_ctx);
16910 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
16911 if ( _alt==1 ) {
16912 if ( _parseListeners!=null ) triggerExitRuleEvent();
16913 _prevctx = _localctx;
16914 {
16915 {
16916 _localctx = new ConditionalAndExpressionContext(_parentctx, _parentState);
16917 pushNewRecursionContext(_localctx, _startState, RULE_conditionalAndExpression);
16918 setState(2790);
16919 if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
16920 setState(2791);
16921 match(AND);
16922 setState(2792);
16923 inclusiveOrExpression(0);
16924 }
16925 }
16926 }
16927 setState(2797);
16928 _errHandler.sync(this);
16929 _alt = getInterpreter().adaptivePredict(_input,318,_ctx);
16930 }
16931 }
16932 }
16933 catch (RecognitionException re) {
16934 _localctx.exception = re;
16935 _errHandler.reportError(this, re);
16936 _errHandler.recover(this, re);
16937 }
16938 finally {
16939 unrollRecursionContexts(_parentctx);
16940 }
16941 return _localctx;
16942 }
16943
16944 public static class InclusiveOrExpressionContext extends ParserRuleContext {
16945 public ExclusiveOrExpressionContext exclusiveOrExpression() {
16946 return getRuleContext(ExclusiveOrExpressionContext.class,0);
16947 }
16948 public InclusiveOrExpressionContext inclusiveOrExpression() {
16949 return getRuleContext(InclusiveOrExpressionContext.class,0);
16950 }
16951 public InclusiveOrExpressionContext(ParserRuleContext parent, int invokingState) {
16952 super(parent, invokingState);
16953 }
16954 @Override public int getRuleIndex() { return RULE_inclusiveOrExpression; }
16955 @Override
16956 public void enterRule(ParseTreeListener listener) {
16957 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInclusiveOrExpression(this);
16958 }
16959 @Override
16960 public void exitRule(ParseTreeListener listener) {
16961 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInclusiveOrExpression(this);
16962 }
16963 }
16964
16965 public final InclusiveOrExpressionContext inclusiveOrExpression() throws RecognitionException {
16966 return inclusiveOrExpression(0);
16967 }
16968
16969 private InclusiveOrExpressionContext inclusiveOrExpression(int _p) throws RecognitionException {
16970 ParserRuleContext _parentctx = _ctx;
16971 int _parentState = getState();
16972 InclusiveOrExpressionContext _localctx = new InclusiveOrExpressionContext(_ctx, _parentState);
16973 InclusiveOrExpressionContext _prevctx = _localctx;
16974 int _startState = 462;
16975 enterRecursionRule(_localctx, 462, RULE_inclusiveOrExpression, _p);
16976 try {
16977 int _alt;
16978 enterOuterAlt(_localctx, 1);
16979 {
16980 {
16981 setState(2799);
16982 exclusiveOrExpression(0);
16983 }
16984 _ctx.stop = _input.LT(-1);
16985 setState(2806);
16986 _errHandler.sync(this);
16987 _alt = getInterpreter().adaptivePredict(_input,319,_ctx);
16988 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
16989 if ( _alt==1 ) {
16990 if ( _parseListeners!=null ) triggerExitRuleEvent();
16991 _prevctx = _localctx;
16992 {
16993 {
16994 _localctx = new InclusiveOrExpressionContext(_parentctx, _parentState);
16995 pushNewRecursionContext(_localctx, _startState, RULE_inclusiveOrExpression);
16996 setState(2801);
16997 if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
16998 setState(2802);
16999 match(BITOR);
17000 setState(2803);
17001 exclusiveOrExpression(0);
17002 }
17003 }
17004 }
17005 setState(2808);
17006 _errHandler.sync(this);
17007 _alt = getInterpreter().adaptivePredict(_input,319,_ctx);
17008 }
17009 }
17010 }
17011 catch (RecognitionException re) {
17012 _localctx.exception = re;
17013 _errHandler.reportError(this, re);
17014 _errHandler.recover(this, re);
17015 }
17016 finally {
17017 unrollRecursionContexts(_parentctx);
17018 }
17019 return _localctx;
17020 }
17021
17022 public static class ExclusiveOrExpressionContext extends ParserRuleContext {
17023 public AndExpressionContext andExpression() {
17024 return getRuleContext(AndExpressionContext.class,0);
17025 }
17026 public ExclusiveOrExpressionContext exclusiveOrExpression() {
17027 return getRuleContext(ExclusiveOrExpressionContext.class,0);
17028 }
17029 public ExclusiveOrExpressionContext(ParserRuleContext parent, int invokingState) {
17030 super(parent, invokingState);
17031 }
17032 @Override public int getRuleIndex() { return RULE_exclusiveOrExpression; }
17033 @Override
17034 public void enterRule(ParseTreeListener listener) {
17035 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterExclusiveOrExpression(this);
17036 }
17037 @Override
17038 public void exitRule(ParseTreeListener listener) {
17039 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitExclusiveOrExpression(this);
17040 }
17041 }
17042
17043 public final ExclusiveOrExpressionContext exclusiveOrExpression() throws RecognitionException {
17044 return exclusiveOrExpression(0);
17045 }
17046
17047 private ExclusiveOrExpressionContext exclusiveOrExpression(int _p) throws RecognitionException {
17048 ParserRuleContext _parentctx = _ctx;
17049 int _parentState = getState();
17050 ExclusiveOrExpressionContext _localctx = new ExclusiveOrExpressionContext(_ctx, _parentState);
17051 ExclusiveOrExpressionContext _prevctx = _localctx;
17052 int _startState = 464;
17053 enterRecursionRule(_localctx, 464, RULE_exclusiveOrExpression, _p);
17054 try {
17055 int _alt;
17056 enterOuterAlt(_localctx, 1);
17057 {
17058 {
17059 setState(2810);
17060 andExpression(0);
17061 }
17062 _ctx.stop = _input.LT(-1);
17063 setState(2817);
17064 _errHandler.sync(this);
17065 _alt = getInterpreter().adaptivePredict(_input,320,_ctx);
17066 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
17067 if ( _alt==1 ) {
17068 if ( _parseListeners!=null ) triggerExitRuleEvent();
17069 _prevctx = _localctx;
17070 {
17071 {
17072 _localctx = new ExclusiveOrExpressionContext(_parentctx, _parentState);
17073 pushNewRecursionContext(_localctx, _startState, RULE_exclusiveOrExpression);
17074 setState(2812);
17075 if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
17076 setState(2813);
17077 match(CARET);
17078 setState(2814);
17079 andExpression(0);
17080 }
17081 }
17082 }
17083 setState(2819);
17084 _errHandler.sync(this);
17085 _alt = getInterpreter().adaptivePredict(_input,320,_ctx);
17086 }
17087 }
17088 }
17089 catch (RecognitionException re) {
17090 _localctx.exception = re;
17091 _errHandler.reportError(this, re);
17092 _errHandler.recover(this, re);
17093 }
17094 finally {
17095 unrollRecursionContexts(_parentctx);
17096 }
17097 return _localctx;
17098 }
17099
17100 public static class AndExpressionContext extends ParserRuleContext {
17101 public EqualityExpressionContext equalityExpression() {
17102 return getRuleContext(EqualityExpressionContext.class,0);
17103 }
17104 public AndExpressionContext andExpression() {
17105 return getRuleContext(AndExpressionContext.class,0);
17106 }
17107 public AndExpressionContext(ParserRuleContext parent, int invokingState) {
17108 super(parent, invokingState);
17109 }
17110 @Override public int getRuleIndex() { return RULE_andExpression; }
17111 @Override
17112 public void enterRule(ParseTreeListener listener) {
17113 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterAndExpression(this);
17114 }
17115 @Override
17116 public void exitRule(ParseTreeListener listener) {
17117 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitAndExpression(this);
17118 }
17119 }
17120
17121 public final AndExpressionContext andExpression() throws RecognitionException {
17122 return andExpression(0);
17123 }
17124
17125 private AndExpressionContext andExpression(int _p) throws RecognitionException {
17126 ParserRuleContext _parentctx = _ctx;
17127 int _parentState = getState();
17128 AndExpressionContext _localctx = new AndExpressionContext(_ctx, _parentState);
17129 AndExpressionContext _prevctx = _localctx;
17130 int _startState = 466;
17131 enterRecursionRule(_localctx, 466, RULE_andExpression, _p);
17132 try {
17133 int _alt;
17134 enterOuterAlt(_localctx, 1);
17135 {
17136 {
17137 setState(2821);
17138 equalityExpression(0);
17139 }
17140 _ctx.stop = _input.LT(-1);
17141 setState(2828);
17142 _errHandler.sync(this);
17143 _alt = getInterpreter().adaptivePredict(_input,321,_ctx);
17144 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
17145 if ( _alt==1 ) {
17146 if ( _parseListeners!=null ) triggerExitRuleEvent();
17147 _prevctx = _localctx;
17148 {
17149 {
17150 _localctx = new AndExpressionContext(_parentctx, _parentState);
17151 pushNewRecursionContext(_localctx, _startState, RULE_andExpression);
17152 setState(2823);
17153 if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
17154 setState(2824);
17155 match(BITAND);
17156 setState(2825);
17157 equalityExpression(0);
17158 }
17159 }
17160 }
17161 setState(2830);
17162 _errHandler.sync(this);
17163 _alt = getInterpreter().adaptivePredict(_input,321,_ctx);
17164 }
17165 }
17166 }
17167 catch (RecognitionException re) {
17168 _localctx.exception = re;
17169 _errHandler.reportError(this, re);
17170 _errHandler.recover(this, re);
17171 }
17172 finally {
17173 unrollRecursionContexts(_parentctx);
17174 }
17175 return _localctx;
17176 }
17177
17178 public static class EqualityExpressionContext extends ParserRuleContext {
17179 public RelationalExpressionContext relationalExpression() {
17180 return getRuleContext(RelationalExpressionContext.class,0);
17181 }
17182 public EqualityExpressionContext equalityExpression() {
17183 return getRuleContext(EqualityExpressionContext.class,0);
17184 }
17185 public EqualityExpressionContext(ParserRuleContext parent, int invokingState) {
17186 super(parent, invokingState);
17187 }
17188 @Override public int getRuleIndex() { return RULE_equalityExpression; }
17189 @Override
17190 public void enterRule(ParseTreeListener listener) {
17191 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterEqualityExpression(this);
17192 }
17193 @Override
17194 public void exitRule(ParseTreeListener listener) {
17195 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitEqualityExpression(this);
17196 }
17197 }
17198
17199 public final EqualityExpressionContext equalityExpression() throws RecognitionException {
17200 return equalityExpression(0);
17201 }
17202
17203 private EqualityExpressionContext equalityExpression(int _p) throws RecognitionException {
17204 ParserRuleContext _parentctx = _ctx;
17205 int _parentState = getState();
17206 EqualityExpressionContext _localctx = new EqualityExpressionContext(_ctx, _parentState);
17207 EqualityExpressionContext _prevctx = _localctx;
17208 int _startState = 468;
17209 enterRecursionRule(_localctx, 468, RULE_equalityExpression, _p);
17210 try {
17211 int _alt;
17212 enterOuterAlt(_localctx, 1);
17213 {
17214 {
17215 setState(2832);
17216 relationalExpression(0);
17217 }
17218 _ctx.stop = _input.LT(-1);
17219 setState(2842);
17220 _errHandler.sync(this);
17221 _alt = getInterpreter().adaptivePredict(_input,323,_ctx);
17222 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
17223 if ( _alt==1 ) {
17224 if ( _parseListeners!=null ) triggerExitRuleEvent();
17225 _prevctx = _localctx;
17226 {
17227 setState(2840);
17228 _errHandler.sync(this);
17229 switch ( getInterpreter().adaptivePredict(_input,322,_ctx) ) {
17230 case 1:
17231 {
17232 _localctx = new EqualityExpressionContext(_parentctx, _parentState);
17233 pushNewRecursionContext(_localctx, _startState, RULE_equalityExpression);
17234 setState(2834);
17235 if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
17236 setState(2835);
17237 match(EQUAL);
17238 setState(2836);
17239 relationalExpression(0);
17240 }
17241 break;
17242 case 2:
17243 {
17244 _localctx = new EqualityExpressionContext(_parentctx, _parentState);
17245 pushNewRecursionContext(_localctx, _startState, RULE_equalityExpression);
17246 setState(2837);
17247 if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
17248 setState(2838);
17249 match(NOTEQUAL);
17250 setState(2839);
17251 relationalExpression(0);
17252 }
17253 break;
17254 }
17255 }
17256 }
17257 setState(2844);
17258 _errHandler.sync(this);
17259 _alt = getInterpreter().adaptivePredict(_input,323,_ctx);
17260 }
17261 }
17262 }
17263 catch (RecognitionException re) {
17264 _localctx.exception = re;
17265 _errHandler.reportError(this, re);
17266 _errHandler.recover(this, re);
17267 }
17268 finally {
17269 unrollRecursionContexts(_parentctx);
17270 }
17271 return _localctx;
17272 }
17273
17274 public static class RelationalExpressionContext extends ParserRuleContext {
17275 public ShiftExpressionContext shiftExpression() {
17276 return getRuleContext(ShiftExpressionContext.class,0);
17277 }
17278 public RelationalExpressionContext relationalExpression() {
17279 return getRuleContext(RelationalExpressionContext.class,0);
17280 }
17281 public ReferenceTypeContext referenceType() {
17282 return getRuleContext(ReferenceTypeContext.class,0);
17283 }
17284 public RelationalExpressionContext(ParserRuleContext parent, int invokingState) {
17285 super(parent, invokingState);
17286 }
17287 @Override public int getRuleIndex() { return RULE_relationalExpression; }
17288 @Override
17289 public void enterRule(ParseTreeListener listener) {
17290 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterRelationalExpression(this);
17291 }
17292 @Override
17293 public void exitRule(ParseTreeListener listener) {
17294 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitRelationalExpression(this);
17295 }
17296 }
17297
17298 public final RelationalExpressionContext relationalExpression() throws RecognitionException {
17299 return relationalExpression(0);
17300 }
17301
17302 private RelationalExpressionContext relationalExpression(int _p) throws RecognitionException {
17303 ParserRuleContext _parentctx = _ctx;
17304 int _parentState = getState();
17305 RelationalExpressionContext _localctx = new RelationalExpressionContext(_ctx, _parentState);
17306 RelationalExpressionContext _prevctx = _localctx;
17307 int _startState = 470;
17308 enterRecursionRule(_localctx, 470, RULE_relationalExpression, _p);
17309 try {
17310 int _alt;
17311 enterOuterAlt(_localctx, 1);
17312 {
17313 {
17314 setState(2846);
17315 shiftExpression(0);
17316 }
17317 _ctx.stop = _input.LT(-1);
17318 setState(2865);
17319 _errHandler.sync(this);
17320 _alt = getInterpreter().adaptivePredict(_input,325,_ctx);
17321 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
17322 if ( _alt==1 ) {
17323 if ( _parseListeners!=null ) triggerExitRuleEvent();
17324 _prevctx = _localctx;
17325 {
17326 setState(2863);
17327 _errHandler.sync(this);
17328 switch ( getInterpreter().adaptivePredict(_input,324,_ctx) ) {
17329 case 1:
17330 {
17331 _localctx = new RelationalExpressionContext(_parentctx, _parentState);
17332 pushNewRecursionContext(_localctx, _startState, RULE_relationalExpression);
17333 setState(2848);
17334 if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
17335 setState(2849);
17336 match(LT);
17337 setState(2850);
17338 shiftExpression(0);
17339 }
17340 break;
17341 case 2:
17342 {
17343 _localctx = new RelationalExpressionContext(_parentctx, _parentState);
17344 pushNewRecursionContext(_localctx, _startState, RULE_relationalExpression);
17345 setState(2851);
17346 if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
17347 setState(2852);
17348 match(GT);
17349 setState(2853);
17350 shiftExpression(0);
17351 }
17352 break;
17353 case 3:
17354 {
17355 _localctx = new RelationalExpressionContext(_parentctx, _parentState);
17356 pushNewRecursionContext(_localctx, _startState, RULE_relationalExpression);
17357 setState(2854);
17358 if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
17359 setState(2855);
17360 match(LE);
17361 setState(2856);
17362 shiftExpression(0);
17363 }
17364 break;
17365 case 4:
17366 {
17367 _localctx = new RelationalExpressionContext(_parentctx, _parentState);
17368 pushNewRecursionContext(_localctx, _startState, RULE_relationalExpression);
17369 setState(2857);
17370 if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
17371 setState(2858);
17372 match(GE);
17373 setState(2859);
17374 shiftExpression(0);
17375 }
17376 break;
17377 case 5:
17378 {
17379 _localctx = new RelationalExpressionContext(_parentctx, _parentState);
17380 pushNewRecursionContext(_localctx, _startState, RULE_relationalExpression);
17381 setState(2860);
17382 if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
17383 setState(2861);
17384 match(INSTANCEOF);
17385 setState(2862);
17386 referenceType();
17387 }
17388 break;
17389 }
17390 }
17391 }
17392 setState(2867);
17393 _errHandler.sync(this);
17394 _alt = getInterpreter().adaptivePredict(_input,325,_ctx);
17395 }
17396 }
17397 }
17398 catch (RecognitionException re) {
17399 _localctx.exception = re;
17400 _errHandler.reportError(this, re);
17401 _errHandler.recover(this, re);
17402 }
17403 finally {
17404 unrollRecursionContexts(_parentctx);
17405 }
17406 return _localctx;
17407 }
17408
17409 public static class ShiftExpressionContext extends ParserRuleContext {
17410 public AdditiveExpressionContext additiveExpression() {
17411 return getRuleContext(AdditiveExpressionContext.class,0);
17412 }
17413 public ShiftExpressionContext shiftExpression() {
17414 return getRuleContext(ShiftExpressionContext.class,0);
17415 }
17416 public ShiftExpressionContext(ParserRuleContext parent, int invokingState) {
17417 super(parent, invokingState);
17418 }
17419 @Override public int getRuleIndex() { return RULE_shiftExpression; }
17420 @Override
17421 public void enterRule(ParseTreeListener listener) {
17422 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterShiftExpression(this);
17423 }
17424 @Override
17425 public void exitRule(ParseTreeListener listener) {
17426 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitShiftExpression(this);
17427 }
17428 }
17429
17430 public final ShiftExpressionContext shiftExpression() throws RecognitionException {
17431 return shiftExpression(0);
17432 }
17433
17434 private ShiftExpressionContext shiftExpression(int _p) throws RecognitionException {
17435 ParserRuleContext _parentctx = _ctx;
17436 int _parentState = getState();
17437 ShiftExpressionContext _localctx = new ShiftExpressionContext(_ctx, _parentState);
17438 ShiftExpressionContext _prevctx = _localctx;
17439 int _startState = 472;
17440 enterRecursionRule(_localctx, 472, RULE_shiftExpression, _p);
17441 try {
17442 int _alt;
17443 enterOuterAlt(_localctx, 1);
17444 {
17445 {
17446 setState(2869);
17447 additiveExpression(0);
17448 }
17449 _ctx.stop = _input.LT(-1);
17450 setState(2886);
17451 _errHandler.sync(this);
17452 _alt = getInterpreter().adaptivePredict(_input,327,_ctx);
17453 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
17454 if ( _alt==1 ) {
17455 if ( _parseListeners!=null ) triggerExitRuleEvent();
17456 _prevctx = _localctx;
17457 {
17458 setState(2884);
17459 _errHandler.sync(this);
17460 switch ( getInterpreter().adaptivePredict(_input,326,_ctx) ) {
17461 case 1:
17462 {
17463 _localctx = new ShiftExpressionContext(_parentctx, _parentState);
17464 pushNewRecursionContext(_localctx, _startState, RULE_shiftExpression);
17465 setState(2871);
17466 if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
17467 setState(2872);
17468 match(LT);
17469 setState(2873);
17470 match(LT);
17471 setState(2874);
17472 additiveExpression(0);
17473 }
17474 break;
17475 case 2:
17476 {
17477 _localctx = new ShiftExpressionContext(_parentctx, _parentState);
17478 pushNewRecursionContext(_localctx, _startState, RULE_shiftExpression);
17479 setState(2875);
17480 if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
17481 setState(2876);
17482 match(GT);
17483 setState(2877);
17484 match(GT);
17485 setState(2878);
17486 additiveExpression(0);
17487 }
17488 break;
17489 case 3:
17490 {
17491 _localctx = new ShiftExpressionContext(_parentctx, _parentState);
17492 pushNewRecursionContext(_localctx, _startState, RULE_shiftExpression);
17493 setState(2879);
17494 if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
17495 setState(2880);
17496 match(GT);
17497 setState(2881);
17498 match(GT);
17499 setState(2882);
17500 match(GT);
17501 setState(2883);
17502 additiveExpression(0);
17503 }
17504 break;
17505 }
17506 }
17507 }
17508 setState(2888);
17509 _errHandler.sync(this);
17510 _alt = getInterpreter().adaptivePredict(_input,327,_ctx);
17511 }
17512 }
17513 }
17514 catch (RecognitionException re) {
17515 _localctx.exception = re;
17516 _errHandler.reportError(this, re);
17517 _errHandler.recover(this, re);
17518 }
17519 finally {
17520 unrollRecursionContexts(_parentctx);
17521 }
17522 return _localctx;
17523 }
17524
17525 public static class AdditiveExpressionContext extends ParserRuleContext {
17526 public MultiplicativeExpressionContext multiplicativeExpression() {
17527 return getRuleContext(MultiplicativeExpressionContext.class,0);
17528 }
17529 public AdditiveExpressionContext additiveExpression() {
17530 return getRuleContext(AdditiveExpressionContext.class,0);
17531 }
17532 public AdditiveExpressionContext(ParserRuleContext parent, int invokingState) {
17533 super(parent, invokingState);
17534 }
17535 @Override public int getRuleIndex() { return RULE_additiveExpression; }
17536 @Override
17537 public void enterRule(ParseTreeListener listener) {
17538 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterAdditiveExpression(this);
17539 }
17540 @Override
17541 public void exitRule(ParseTreeListener listener) {
17542 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitAdditiveExpression(this);
17543 }
17544 }
17545
17546 public final AdditiveExpressionContext additiveExpression() throws RecognitionException {
17547 return additiveExpression(0);
17548 }
17549
17550 private AdditiveExpressionContext additiveExpression(int _p) throws RecognitionException {
17551 ParserRuleContext _parentctx = _ctx;
17552 int _parentState = getState();
17553 AdditiveExpressionContext _localctx = new AdditiveExpressionContext(_ctx, _parentState);
17554 AdditiveExpressionContext _prevctx = _localctx;
17555 int _startState = 474;
17556 enterRecursionRule(_localctx, 474, RULE_additiveExpression, _p);
17557 try {
17558 int _alt;
17559 enterOuterAlt(_localctx, 1);
17560 {
17561 {
17562 setState(2890);
17563 multiplicativeExpression(0);
17564 }
17565 _ctx.stop = _input.LT(-1);
17566 setState(2900);
17567 _errHandler.sync(this);
17568 _alt = getInterpreter().adaptivePredict(_input,329,_ctx);
17569 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
17570 if ( _alt==1 ) {
17571 if ( _parseListeners!=null ) triggerExitRuleEvent();
17572 _prevctx = _localctx;
17573 {
17574 setState(2898);
17575 _errHandler.sync(this);
17576 switch ( getInterpreter().adaptivePredict(_input,328,_ctx) ) {
17577 case 1:
17578 {
17579 _localctx = new AdditiveExpressionContext(_parentctx, _parentState);
17580 pushNewRecursionContext(_localctx, _startState, RULE_additiveExpression);
17581 setState(2892);
17582 if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
17583 setState(2893);
17584 match(ADD);
17585 setState(2894);
17586 multiplicativeExpression(0);
17587 }
17588 break;
17589 case 2:
17590 {
17591 _localctx = new AdditiveExpressionContext(_parentctx, _parentState);
17592 pushNewRecursionContext(_localctx, _startState, RULE_additiveExpression);
17593 setState(2895);
17594 if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
17595 setState(2896);
17596 match(SUB);
17597 setState(2897);
17598 multiplicativeExpression(0);
17599 }
17600 break;
17601 }
17602 }
17603 }
17604 setState(2902);
17605 _errHandler.sync(this);
17606 _alt = getInterpreter().adaptivePredict(_input,329,_ctx);
17607 }
17608 }
17609 }
17610 catch (RecognitionException re) {
17611 _localctx.exception = re;
17612 _errHandler.reportError(this, re);
17613 _errHandler.recover(this, re);
17614 }
17615 finally {
17616 unrollRecursionContexts(_parentctx);
17617 }
17618 return _localctx;
17619 }
17620
17621 public static class MultiplicativeExpressionContext extends ParserRuleContext {
17622 public UnaryExpressionContext unaryExpression() {
17623 return getRuleContext(UnaryExpressionContext.class,0);
17624 }
17625 public MultiplicativeExpressionContext multiplicativeExpression() {
17626 return getRuleContext(MultiplicativeExpressionContext.class,0);
17627 }
17628 public MultiplicativeExpressionContext(ParserRuleContext parent, int invokingState) {
17629 super(parent, invokingState);
17630 }
17631 @Override public int getRuleIndex() { return RULE_multiplicativeExpression; }
17632 @Override
17633 public void enterRule(ParseTreeListener listener) {
17634 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterMultiplicativeExpression(this);
17635 }
17636 @Override
17637 public void exitRule(ParseTreeListener listener) {
17638 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitMultiplicativeExpression(this);
17639 }
17640 }
17641
17642 public final MultiplicativeExpressionContext multiplicativeExpression() throws RecognitionException {
17643 return multiplicativeExpression(0);
17644 }
17645
17646 private MultiplicativeExpressionContext multiplicativeExpression(int _p) throws RecognitionException {
17647 ParserRuleContext _parentctx = _ctx;
17648 int _parentState = getState();
17649 MultiplicativeExpressionContext _localctx = new MultiplicativeExpressionContext(_ctx, _parentState);
17650 MultiplicativeExpressionContext _prevctx = _localctx;
17651 int _startState = 476;
17652 enterRecursionRule(_localctx, 476, RULE_multiplicativeExpression, _p);
17653 try {
17654 int _alt;
17655 enterOuterAlt(_localctx, 1);
17656 {
17657 {
17658 setState(2904);
17659 unaryExpression();
17660 }
17661 _ctx.stop = _input.LT(-1);
17662 setState(2917);
17663 _errHandler.sync(this);
17664 _alt = getInterpreter().adaptivePredict(_input,331,_ctx);
17665 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
17666 if ( _alt==1 ) {
17667 if ( _parseListeners!=null ) triggerExitRuleEvent();
17668 _prevctx = _localctx;
17669 {
17670 setState(2915);
17671 _errHandler.sync(this);
17672 switch ( getInterpreter().adaptivePredict(_input,330,_ctx) ) {
17673 case 1:
17674 {
17675 _localctx = new MultiplicativeExpressionContext(_parentctx, _parentState);
17676 pushNewRecursionContext(_localctx, _startState, RULE_multiplicativeExpression);
17677 setState(2906);
17678 if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
17679 setState(2907);
17680 match(MUL);
17681 setState(2908);
17682 unaryExpression();
17683 }
17684 break;
17685 case 2:
17686 {
17687 _localctx = new MultiplicativeExpressionContext(_parentctx, _parentState);
17688 pushNewRecursionContext(_localctx, _startState, RULE_multiplicativeExpression);
17689 setState(2909);
17690 if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
17691 setState(2910);
17692 match(DIV);
17693 setState(2911);
17694 unaryExpression();
17695 }
17696 break;
17697 case 3:
17698 {
17699 _localctx = new MultiplicativeExpressionContext(_parentctx, _parentState);
17700 pushNewRecursionContext(_localctx, _startState, RULE_multiplicativeExpression);
17701 setState(2912);
17702 if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
17703 setState(2913);
17704 match(MOD);
17705 setState(2914);
17706 unaryExpression();
17707 }
17708 break;
17709 }
17710 }
17711 }
17712 setState(2919);
17713 _errHandler.sync(this);
17714 _alt = getInterpreter().adaptivePredict(_input,331,_ctx);
17715 }
17716 }
17717 }
17718 catch (RecognitionException re) {
17719 _localctx.exception = re;
17720 _errHandler.reportError(this, re);
17721 _errHandler.recover(this, re);
17722 }
17723 finally {
17724 unrollRecursionContexts(_parentctx);
17725 }
17726 return _localctx;
17727 }
17728
17729 public static class UnaryExpressionContext extends ParserRuleContext {
17730 public PreIncrementExpressionContext preIncrementExpression() {
17731 return getRuleContext(PreIncrementExpressionContext.class,0);
17732 }
17733 public PreDecrementExpressionContext preDecrementExpression() {
17734 return getRuleContext(PreDecrementExpressionContext.class,0);
17735 }
17736 public UnaryExpressionContext unaryExpression() {
17737 return getRuleContext(UnaryExpressionContext.class,0);
17738 }
17739 public UnaryExpressionNotPlusMinusContext unaryExpressionNotPlusMinus() {
17740 return getRuleContext(UnaryExpressionNotPlusMinusContext.class,0);
17741 }
17742 public UnaryExpressionContext(ParserRuleContext parent, int invokingState) {
17743 super(parent, invokingState);
17744 }
17745 @Override public int getRuleIndex() { return RULE_unaryExpression; }
17746 @Override
17747 public void enterRule(ParseTreeListener listener) {
17748 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnaryExpression(this);
17749 }
17750 @Override
17751 public void exitRule(ParseTreeListener listener) {
17752 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnaryExpression(this);
17753 }
17754 }
17755
17756 public final UnaryExpressionContext unaryExpression() throws RecognitionException {
17757 UnaryExpressionContext _localctx = new UnaryExpressionContext(_ctx, getState());
17758 enterRule(_localctx, 478, RULE_unaryExpression);
17759 try {
17760 setState(2927);
17761 _errHandler.sync(this);
17762 switch (_input.LA(1)) {
17763 case INC:
17764 enterOuterAlt(_localctx, 1);
17765 {
17766 setState(2920);
17767 preIncrementExpression();
17768 }
17769 break;
17770 case DEC:
17771 enterOuterAlt(_localctx, 2);
17772 {
17773 setState(2921);
17774 preDecrementExpression();
17775 }
17776 break;
17777 case ADD:
17778 enterOuterAlt(_localctx, 3);
17779 {
17780 setState(2922);
17781 match(ADD);
17782 setState(2923);
17783 unaryExpression();
17784 }
17785 break;
17786 case SUB:
17787 enterOuterAlt(_localctx, 4);
17788 {
17789 setState(2924);
17790 match(SUB);
17791 setState(2925);
17792 unaryExpression();
17793 }
17794 break;
17795 case T__0:
17796 case T__1:
17797 case T__2:
17798 case T__3:
17799 case T__4:
17800 case T__5:
17801 case T__6:
17802 case T__7:
17803 case T__8:
17804 case BOOLEAN:
17805 case BYTE:
17806 case CHAR:
17807 case DOUBLE:
17808 case FLOAT:
17809 case INT:
17810 case LONG:
17811 case NEW:
17812 case SHORT:
17813 case SUPER:
17814 case THIS:
17815 case VOID:
17816 case IntegerLiteral:
17817 case FloatingPointLiteral:
17818 case BooleanLiteral:
17819 case CharacterLiteral:
17820 case StringLiteral:
17821 case NullLiteral:
17822 case LPAREN:
17823 case AT:
17824 case BANG:
17825 case TILDE:
17826 case Identifier:
17827 enterOuterAlt(_localctx, 5);
17828 {
17829 setState(2926);
17830 unaryExpressionNotPlusMinus();
17831 }
17832 break;
17833 default:
17834 throw new NoViableAltException(this);
17835 }
17836 }
17837 catch (RecognitionException re) {
17838 _localctx.exception = re;
17839 _errHandler.reportError(this, re);
17840 _errHandler.recover(this, re);
17841 }
17842 finally {
17843 exitRule();
17844 }
17845 return _localctx;
17846 }
17847
17848 public static class PreIncrementExpressionContext extends ParserRuleContext {
17849 public UnaryExpressionContext unaryExpression() {
17850 return getRuleContext(UnaryExpressionContext.class,0);
17851 }
17852 public PreIncrementExpressionContext(ParserRuleContext parent, int invokingState) {
17853 super(parent, invokingState);
17854 }
17855 @Override public int getRuleIndex() { return RULE_preIncrementExpression; }
17856 @Override
17857 public void enterRule(ParseTreeListener listener) {
17858 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPreIncrementExpression(this);
17859 }
17860 @Override
17861 public void exitRule(ParseTreeListener listener) {
17862 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPreIncrementExpression(this);
17863 }
17864 }
17865
17866 public final PreIncrementExpressionContext preIncrementExpression() throws RecognitionException {
17867 PreIncrementExpressionContext _localctx = new PreIncrementExpressionContext(_ctx, getState());
17868 enterRule(_localctx, 480, RULE_preIncrementExpression);
17869 try {
17870 enterOuterAlt(_localctx, 1);
17871 {
17872 setState(2929);
17873 match(INC);
17874 setState(2930);
17875 unaryExpression();
17876 }
17877 }
17878 catch (RecognitionException re) {
17879 _localctx.exception = re;
17880 _errHandler.reportError(this, re);
17881 _errHandler.recover(this, re);
17882 }
17883 finally {
17884 exitRule();
17885 }
17886 return _localctx;
17887 }
17888
17889 public static class PreDecrementExpressionContext extends ParserRuleContext {
17890 public UnaryExpressionContext unaryExpression() {
17891 return getRuleContext(UnaryExpressionContext.class,0);
17892 }
17893 public PreDecrementExpressionContext(ParserRuleContext parent, int invokingState) {
17894 super(parent, invokingState);
17895 }
17896 @Override public int getRuleIndex() { return RULE_preDecrementExpression; }
17897 @Override
17898 public void enterRule(ParseTreeListener listener) {
17899 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPreDecrementExpression(this);
17900 }
17901 @Override
17902 public void exitRule(ParseTreeListener listener) {
17903 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPreDecrementExpression(this);
17904 }
17905 }
17906
17907 public final PreDecrementExpressionContext preDecrementExpression() throws RecognitionException {
17908 PreDecrementExpressionContext _localctx = new PreDecrementExpressionContext(_ctx, getState());
17909 enterRule(_localctx, 482, RULE_preDecrementExpression);
17910 try {
17911 enterOuterAlt(_localctx, 1);
17912 {
17913 setState(2932);
17914 match(DEC);
17915 setState(2933);
17916 unaryExpression();
17917 }
17918 }
17919 catch (RecognitionException re) {
17920 _localctx.exception = re;
17921 _errHandler.reportError(this, re);
17922 _errHandler.recover(this, re);
17923 }
17924 finally {
17925 exitRule();
17926 }
17927 return _localctx;
17928 }
17929
17930 public static class UnaryExpressionNotPlusMinusContext extends ParserRuleContext {
17931 public PostfixExpressionContext postfixExpression() {
17932 return getRuleContext(PostfixExpressionContext.class,0);
17933 }
17934 public UnaryExpressionContext unaryExpression() {
17935 return getRuleContext(UnaryExpressionContext.class,0);
17936 }
17937 public CastExpressionContext castExpression() {
17938 return getRuleContext(CastExpressionContext.class,0);
17939 }
17940 public UnaryExpressionNotPlusMinusContext(ParserRuleContext parent, int invokingState) {
17941 super(parent, invokingState);
17942 }
17943 @Override public int getRuleIndex() { return RULE_unaryExpressionNotPlusMinus; }
17944 @Override
17945 public void enterRule(ParseTreeListener listener) {
17946 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnaryExpressionNotPlusMinus(this);
17947 }
17948 @Override
17949 public void exitRule(ParseTreeListener listener) {
17950 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnaryExpressionNotPlusMinus(this);
17951 }
17952 }
17953
17954 public final UnaryExpressionNotPlusMinusContext unaryExpressionNotPlusMinus() throws RecognitionException {
17955 UnaryExpressionNotPlusMinusContext _localctx = new UnaryExpressionNotPlusMinusContext(_ctx, getState());
17956 enterRule(_localctx, 484, RULE_unaryExpressionNotPlusMinus);
17957 try {
17958 setState(2941);
17959 _errHandler.sync(this);
17960 switch ( getInterpreter().adaptivePredict(_input,333,_ctx) ) {
17961 case 1:
17962 enterOuterAlt(_localctx, 1);
17963 {
17964 setState(2935);
17965 postfixExpression();
17966 }
17967 break;
17968 case 2:
17969 enterOuterAlt(_localctx, 2);
17970 {
17971 setState(2936);
17972 match(TILDE);
17973 setState(2937);
17974 unaryExpression();
17975 }
17976 break;
17977 case 3:
17978 enterOuterAlt(_localctx, 3);
17979 {
17980 setState(2938);
17981 match(BANG);
17982 setState(2939);
17983 unaryExpression();
17984 }
17985 break;
17986 case 4:
17987 enterOuterAlt(_localctx, 4);
17988 {
17989 setState(2940);
17990 castExpression();
17991 }
17992 break;
17993 }
17994 }
17995 catch (RecognitionException re) {
17996 _localctx.exception = re;
17997 _errHandler.reportError(this, re);
17998 _errHandler.recover(this, re);
17999 }
18000 finally {
18001 exitRule();
18002 }
18003 return _localctx;
18004 }
18005
18006 public static class PostfixExpressionContext extends ParserRuleContext {
18007 public PrimaryContext primary() {
18008 return getRuleContext(PrimaryContext.class,0);
18009 }
18010 public ExpressionNameContext expressionName() {
18011 return getRuleContext(ExpressionNameContext.class,0);
18012 }
18013 public List<PostIncrementExpression_lf_postfixExpressionContext> postIncrementExpression_lf_postfixExpression() {
18014 return getRuleContexts(PostIncrementExpression_lf_postfixExpressionContext.class);
18015 }
18016 public PostIncrementExpression_lf_postfixExpressionContext postIncrementExpression_lf_postfixExpression(int i) {
18017 return getRuleContext(PostIncrementExpression_lf_postfixExpressionContext.class,i);
18018 }
18019 public List<PostDecrementExpression_lf_postfixExpressionContext> postDecrementExpression_lf_postfixExpression() {
18020 return getRuleContexts(PostDecrementExpression_lf_postfixExpressionContext.class);
18021 }
18022 public PostDecrementExpression_lf_postfixExpressionContext postDecrementExpression_lf_postfixExpression(int i) {
18023 return getRuleContext(PostDecrementExpression_lf_postfixExpressionContext.class,i);
18024 }
18025 public PostfixExpressionContext(ParserRuleContext parent, int invokingState) {
18026 super(parent, invokingState);
18027 }
18028 @Override public int getRuleIndex() { return RULE_postfixExpression; }
18029 @Override
18030 public void enterRule(ParseTreeListener listener) {
18031 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPostfixExpression(this);
18032 }
18033 @Override
18034 public void exitRule(ParseTreeListener listener) {
18035 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPostfixExpression(this);
18036 }
18037 }
18038
18039 public final PostfixExpressionContext postfixExpression() throws RecognitionException {
18040 PostfixExpressionContext _localctx = new PostfixExpressionContext(_ctx, getState());
18041 enterRule(_localctx, 486, RULE_postfixExpression);
18042 try {
18043 int _alt;
18044 enterOuterAlt(_localctx, 1);
18045 {
18046 setState(2945);
18047 _errHandler.sync(this);
18048 switch ( getInterpreter().adaptivePredict(_input,334,_ctx) ) {
18049 case 1:
18050 {
18051 setState(2943);
18052 primary();
18053 }
18054 break;
18055 case 2:
18056 {
18057 setState(2944);
18058 expressionName();
18059 }
18060 break;
18061 }
18062 setState(2951);
18063 _errHandler.sync(this);
18064 _alt = getInterpreter().adaptivePredict(_input,336,_ctx);
18065 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
18066 if ( _alt==1 ) {
18067 {
18068 setState(2949);
18069 _errHandler.sync(this);
18070 switch (_input.LA(1)) {
18071 case INC:
18072 {
18073 setState(2947);
18074 postIncrementExpression_lf_postfixExpression();
18075 }
18076 break;
18077 case DEC:
18078 {
18079 setState(2948);
18080 postDecrementExpression_lf_postfixExpression();
18081 }
18082 break;
18083 default:
18084 throw new NoViableAltException(this);
18085 }
18086 }
18087 }
18088 setState(2953);
18089 _errHandler.sync(this);
18090 _alt = getInterpreter().adaptivePredict(_input,336,_ctx);
18091 }
18092 }
18093 }
18094 catch (RecognitionException re) {
18095 _localctx.exception = re;
18096 _errHandler.reportError(this, re);
18097 _errHandler.recover(this, re);
18098 }
18099 finally {
18100 exitRule();
18101 }
18102 return _localctx;
18103 }
18104
18105 public static class PostIncrementExpressionContext extends ParserRuleContext {
18106 public PostfixExpressionContext postfixExpression() {
18107 return getRuleContext(PostfixExpressionContext.class,0);
18108 }
18109 public PostIncrementExpressionContext(ParserRuleContext parent, int invokingState) {
18110 super(parent, invokingState);
18111 }
18112 @Override public int getRuleIndex() { return RULE_postIncrementExpression; }
18113 @Override
18114 public void enterRule(ParseTreeListener listener) {
18115 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPostIncrementExpression(this);
18116 }
18117 @Override
18118 public void exitRule(ParseTreeListener listener) {
18119 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPostIncrementExpression(this);
18120 }
18121 }
18122
18123 public final PostIncrementExpressionContext postIncrementExpression() throws RecognitionException {
18124 PostIncrementExpressionContext _localctx = new PostIncrementExpressionContext(_ctx, getState());
18125 enterRule(_localctx, 488, RULE_postIncrementExpression);
18126 try {
18127 enterOuterAlt(_localctx, 1);
18128 {
18129 setState(2954);
18130 postfixExpression();
18131 setState(2955);
18132 match(INC);
18133 }
18134 }
18135 catch (RecognitionException re) {
18136 _localctx.exception = re;
18137 _errHandler.reportError(this, re);
18138 _errHandler.recover(this, re);
18139 }
18140 finally {
18141 exitRule();
18142 }
18143 return _localctx;
18144 }
18145
18146 public static class PostIncrementExpression_lf_postfixExpressionContext extends ParserRuleContext {
18147 public PostIncrementExpression_lf_postfixExpressionContext(ParserRuleContext parent, int invokingState) {
18148 super(parent, invokingState);
18149 }
18150 @Override public int getRuleIndex() { return RULE_postIncrementExpression_lf_postfixExpression; }
18151 @Override
18152 public void enterRule(ParseTreeListener listener) {
18153 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPostIncrementExpression_lf_postfixExpression(this);
18154 }
18155 @Override
18156 public void exitRule(ParseTreeListener listener) {
18157 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPostIncrementExpression_lf_postfixExpression(this);
18158 }
18159 }
18160
18161 public final PostIncrementExpression_lf_postfixExpressionContext postIncrementExpression_lf_postfixExpression() throws RecognitionException {
18162 PostIncrementExpression_lf_postfixExpressionContext _localctx = new PostIncrementExpression_lf_postfixExpressionContext(_ctx, getState());
18163 enterRule(_localctx, 490, RULE_postIncrementExpression_lf_postfixExpression);
18164 try {
18165 enterOuterAlt(_localctx, 1);
18166 {
18167 setState(2957);
18168 match(INC);
18169 }
18170 }
18171 catch (RecognitionException re) {
18172 _localctx.exception = re;
18173 _errHandler.reportError(this, re);
18174 _errHandler.recover(this, re);
18175 }
18176 finally {
18177 exitRule();
18178 }
18179 return _localctx;
18180 }
18181
18182 public static class PostDecrementExpressionContext extends ParserRuleContext {
18183 public PostfixExpressionContext postfixExpression() {
18184 return getRuleContext(PostfixExpressionContext.class,0);
18185 }
18186 public PostDecrementExpressionContext(ParserRuleContext parent, int invokingState) {
18187 super(parent, invokingState);
18188 }
18189 @Override public int getRuleIndex() { return RULE_postDecrementExpression; }
18190 @Override
18191 public void enterRule(ParseTreeListener listener) {
18192 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPostDecrementExpression(this);
18193 }
18194 @Override
18195 public void exitRule(ParseTreeListener listener) {
18196 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPostDecrementExpression(this);
18197 }
18198 }
18199
18200 public final PostDecrementExpressionContext postDecrementExpression() throws RecognitionException {
18201 PostDecrementExpressionContext _localctx = new PostDecrementExpressionContext(_ctx, getState());
18202 enterRule(_localctx, 492, RULE_postDecrementExpression);
18203 try {
18204 enterOuterAlt(_localctx, 1);
18205 {
18206 setState(2959);
18207 postfixExpression();
18208 setState(2960);
18209 match(DEC);
18210 }
18211 }
18212 catch (RecognitionException re) {
18213 _localctx.exception = re;
18214 _errHandler.reportError(this, re);
18215 _errHandler.recover(this, re);
18216 }
18217 finally {
18218 exitRule();
18219 }
18220 return _localctx;
18221 }
18222
18223 public static class PostDecrementExpression_lf_postfixExpressionContext extends ParserRuleContext {
18224 public PostDecrementExpression_lf_postfixExpressionContext(ParserRuleContext parent, int invokingState) {
18225 super(parent, invokingState);
18226 }
18227 @Override public int getRuleIndex() { return RULE_postDecrementExpression_lf_postfixExpression; }
18228 @Override
18229 public void enterRule(ParseTreeListener listener) {
18230 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPostDecrementExpression_lf_postfixExpression(this);
18231 }
18232 @Override
18233 public void exitRule(ParseTreeListener listener) {
18234 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPostDecrementExpression_lf_postfixExpression(this);
18235 }
18236 }
18237
18238 public final PostDecrementExpression_lf_postfixExpressionContext postDecrementExpression_lf_postfixExpression() throws RecognitionException {
18239 PostDecrementExpression_lf_postfixExpressionContext _localctx = new PostDecrementExpression_lf_postfixExpressionContext(_ctx, getState());
18240 enterRule(_localctx, 494, RULE_postDecrementExpression_lf_postfixExpression);
18241 try {
18242 enterOuterAlt(_localctx, 1);
18243 {
18244 setState(2962);
18245 match(DEC);
18246 }
18247 }
18248 catch (RecognitionException re) {
18249 _localctx.exception = re;
18250 _errHandler.reportError(this, re);
18251 _errHandler.recover(this, re);
18252 }
18253 finally {
18254 exitRule();
18255 }
18256 return _localctx;
18257 }
18258
18259 public static class CastExpressionContext extends ParserRuleContext {
18260 public PrimitiveTypeContext primitiveType() {
18261 return getRuleContext(PrimitiveTypeContext.class,0);
18262 }
18263 public UnaryExpressionContext unaryExpression() {
18264 return getRuleContext(UnaryExpressionContext.class,0);
18265 }
18266 public ReferenceTypeContext referenceType() {
18267 return getRuleContext(ReferenceTypeContext.class,0);
18268 }
18269 public UnaryExpressionNotPlusMinusContext unaryExpressionNotPlusMinus() {
18270 return getRuleContext(UnaryExpressionNotPlusMinusContext.class,0);
18271 }
18272 public List<AdditionalBoundContext> additionalBound() {
18273 return getRuleContexts(AdditionalBoundContext.class);
18274 }
18275 public AdditionalBoundContext additionalBound(int i) {
18276 return getRuleContext(AdditionalBoundContext.class,i);
18277 }
18278 public LambdaExpressionContext lambdaExpression() {
18279 return getRuleContext(LambdaExpressionContext.class,0);
18280 }
18281 public CastExpressionContext(ParserRuleContext parent, int invokingState) {
18282 super(parent, invokingState);
18283 }
18284 @Override public int getRuleIndex() { return RULE_castExpression; }
18285 @Override
18286 public void enterRule(ParseTreeListener listener) {
18287 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterCastExpression(this);
18288 }
18289 @Override
18290 public void exitRule(ParseTreeListener listener) {
18291 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitCastExpression(this);
18292 }
18293 }
18294
18295 public final CastExpressionContext castExpression() throws RecognitionException {
18296 CastExpressionContext _localctx = new CastExpressionContext(_ctx, getState());
18297 enterRule(_localctx, 496, RULE_castExpression);
18298 int _la;
18299 try {
18300 setState(2991);
18301 _errHandler.sync(this);
18302 switch ( getInterpreter().adaptivePredict(_input,339,_ctx) ) {
18303 case 1:
18304 enterOuterAlt(_localctx, 1);
18305 {
18306 setState(2964);
18307 match(LPAREN);
18308 setState(2965);
18309 primitiveType();
18310 setState(2966);
18311 match(RPAREN);
18312 setState(2967);
18313 unaryExpression();
18314 }
18315 break;
18316 case 2:
18317 enterOuterAlt(_localctx, 2);
18318 {
18319 setState(2969);
18320 match(LPAREN);
18321 setState(2970);
18322 referenceType();
18323 setState(2974);
18324 _errHandler.sync(this);
18325 _la = _input.LA(1);
18326 while (_la==BITAND) {
18327 {
18328 {
18329 setState(2971);
18330 additionalBound();
18331 }
18332 }
18333 setState(2976);
18334 _errHandler.sync(this);
18335 _la = _input.LA(1);
18336 }
18337 setState(2977);
18338 match(RPAREN);
18339 setState(2978);
18340 unaryExpressionNotPlusMinus();
18341 }
18342 break;
18343 case 3:
18344 enterOuterAlt(_localctx, 3);
18345 {
18346 setState(2980);
18347 match(LPAREN);
18348 setState(2981);
18349 referenceType();
18350 setState(2985);
18351 _errHandler.sync(this);
18352 _la = _input.LA(1);
18353 while (_la==BITAND) {
18354 {
18355 {
18356 setState(2982);
18357 additionalBound();
18358 }
18359 }
18360 setState(2987);
18361 _errHandler.sync(this);
18362 _la = _input.LA(1);
18363 }
18364 setState(2988);
18365 match(RPAREN);
18366 setState(2989);
18367 lambdaExpression();
18368 }
18369 break;
18370 }
18371 }
18372 catch (RecognitionException re) {
18373 _localctx.exception = re;
18374 _errHandler.reportError(this, re);
18375 _errHandler.recover(this, re);
18376 }
18377 finally {
18378 exitRule();
18379 }
18380 return _localctx;
18381 }
18382
18383 public static class IdentifierContext extends ParserRuleContext {
18384 public TerminalNode Identifier() { return getToken(Java9Parser.Identifier, 0); }
18385 public IdentifierContext(ParserRuleContext parent, int invokingState) {
18386 super(parent, invokingState);
18387 }
18388 @Override public int getRuleIndex() { return RULE_identifier; }
18389 @Override
18390 public void enterRule(ParseTreeListener listener) {
18391 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterIdentifier(this);
18392 }
18393 @Override
18394 public void exitRule(ParseTreeListener listener) {
18395 if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitIdentifier(this);
18396 }
18397 }
18398
18399 public final IdentifierContext identifier() throws RecognitionException {
18400 IdentifierContext _localctx = new IdentifierContext(_ctx, getState());
18401 enterRule(_localctx, 498, RULE_identifier);
18402 int _la;
18403 try {
18404 enterOuterAlt(_localctx, 1);
18405 {
18406 setState(2993);
18407 _la = _input.LA(1);
18408 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) ) {
18409 _errHandler.recoverInline(this);
18410 }
18411 else {
18412 if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
18413 _errHandler.reportMatch(this);
18414 consume();
18415 }
18416 }
18417 }
18418 catch (RecognitionException re) {
18419 _localctx.exception = re;
18420 _errHandler.reportError(this, re);
18421 _errHandler.recover(this, re);
18422 }
18423 finally {
18424 exitRule();
18425 }
18426 return _localctx;
18427 }
18428
18429 public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
18430 switch (ruleIndex) {
18431 case 25:
18432 return moduleName_sempred((ModuleNameContext)_localctx, predIndex);
18433 case 26:
18434 return packageName_sempred((PackageNameContext)_localctx, predIndex);
18435 case 28:
18436 return packageOrTypeName_sempred((PackageOrTypeNameContext)_localctx, predIndex);
18437 case 31:
18438 return ambiguousName_sempred((AmbiguousNameContext)_localctx, predIndex);
18439 case 229:
18440 return conditionalOrExpression_sempred((ConditionalOrExpressionContext)_localctx, predIndex);
18441 case 230:
18442 return conditionalAndExpression_sempred((ConditionalAndExpressionContext)_localctx, predIndex);
18443 case 231:
18444 return inclusiveOrExpression_sempred((InclusiveOrExpressionContext)_localctx, predIndex);
18445 case 232:
18446 return exclusiveOrExpression_sempred((ExclusiveOrExpressionContext)_localctx, predIndex);
18447 case 233:
18448 return andExpression_sempred((AndExpressionContext)_localctx, predIndex);
18449 case 234:
18450 return equalityExpression_sempred((EqualityExpressionContext)_localctx, predIndex);
18451 case 235:
18452 return relationalExpression_sempred((RelationalExpressionContext)_localctx, predIndex);
18453 case 236:
18454 return shiftExpression_sempred((ShiftExpressionContext)_localctx, predIndex);
18455 case 237:
18456 return additiveExpression_sempred((AdditiveExpressionContext)_localctx, predIndex);
18457 case 238:
18458 return multiplicativeExpression_sempred((MultiplicativeExpressionContext)_localctx, predIndex);
18459 }
18460 return true;
18461 }
18462 private boolean moduleName_sempred(ModuleNameContext _localctx, int predIndex) {
18463 switch (predIndex) {
18464 case 0:
18465 return precpred(_ctx, 1);
18466 }
18467 return true;
18468 }
18469 private boolean packageName_sempred(PackageNameContext _localctx, int predIndex) {
18470 switch (predIndex) {
18471 case 1:
18472 return precpred(_ctx, 1);
18473 }
18474 return true;
18475 }
18476 private boolean packageOrTypeName_sempred(PackageOrTypeNameContext _localctx, int predIndex) {
18477 switch (predIndex) {
18478 case 2:
18479 return precpred(_ctx, 1);
18480 }
18481 return true;
18482 }
18483 private boolean ambiguousName_sempred(AmbiguousNameContext _localctx, int predIndex) {
18484 switch (predIndex) {
18485 case 3:
18486 return precpred(_ctx, 1);
18487 }
18488 return true;
18489 }
18490 private boolean conditionalOrExpression_sempred(ConditionalOrExpressionContext _localctx, int predIndex) {
18491 switch (predIndex) {
18492 case 4:
18493 return precpred(_ctx, 1);
18494 }
18495 return true;
18496 }
18497 private boolean conditionalAndExpression_sempred(ConditionalAndExpressionContext _localctx, int predIndex) {
18498 switch (predIndex) {
18499 case 5:
18500 return precpred(_ctx, 1);
18501 }
18502 return true;
18503 }
18504 private boolean inclusiveOrExpression_sempred(InclusiveOrExpressionContext _localctx, int predIndex) {
18505 switch (predIndex) {
18506 case 6:
18507 return precpred(_ctx, 1);
18508 }
18509 return true;
18510 }
18511 private boolean exclusiveOrExpression_sempred(ExclusiveOrExpressionContext _localctx, int predIndex) {
18512 switch (predIndex) {
18513 case 7:
18514 return precpred(_ctx, 1);
18515 }
18516 return true;
18517 }
18518 private boolean andExpression_sempred(AndExpressionContext _localctx, int predIndex) {
18519 switch (predIndex) {
18520 case 8:
18521 return precpred(_ctx, 1);
18522 }
18523 return true;
18524 }
18525 private boolean equalityExpression_sempred(EqualityExpressionContext _localctx, int predIndex) {
18526 switch (predIndex) {
18527 case 9:
18528 return precpred(_ctx, 2);
18529 case 10:
18530 return precpred(_ctx, 1);
18531 }
18532 return true;
18533 }
18534 private boolean relationalExpression_sempred(RelationalExpressionContext _localctx, int predIndex) {
18535 switch (predIndex) {
18536 case 11:
18537 return precpred(_ctx, 5);
18538 case 12:
18539 return precpred(_ctx, 4);
18540 case 13:
18541 return precpred(_ctx, 3);
18542 case 14:
18543 return precpred(_ctx, 2);
18544 case 15:
18545 return precpred(_ctx, 1);
18546 }
18547 return true;
18548 }
18549 private boolean shiftExpression_sempred(ShiftExpressionContext _localctx, int predIndex) {
18550 switch (predIndex) {
18551 case 16:
18552 return precpred(_ctx, 3);
18553 case 17:
18554 return precpred(_ctx, 2);
18555 case 18:
18556 return precpred(_ctx, 1);
18557 }
18558 return true;
18559 }
18560 private boolean additiveExpression_sempred(AdditiveExpressionContext _localctx, int predIndex) {
18561 switch (predIndex) {
18562 case 19:
18563 return precpred(_ctx, 2);
18564 case 20:
18565 return precpred(_ctx, 1);
18566 }
18567 return true;
18568 }
18569 private boolean multiplicativeExpression_sempred(MultiplicativeExpressionContext _localctx, int predIndex) {
18570 switch (predIndex) {
18571 case 21:
18572 return precpred(_ctx, 3);
18573 case 22:
18574 return precpred(_ctx, 2);
18575 case 23:
18576 return precpred(_ctx, 1);
18577 }
18578 return true;
18579 }
18580
18581 private static final int _serializedATNSegments = 2;
18582 private static final String _serializedATNSegment0 =
18583 "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3x\u0bb6\4\2\t\2\4"+
18584 "\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
18585 "\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
18586 "\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
18587 "\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
18588 "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
18589 ",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
18590 "\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+
18591 "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+
18592 "\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+
18593 "\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+
18594 "`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t"+
18595 "k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4"+
18596 "w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080"+
18597 "\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084\t\u0084\4\u0085"+
18598 "\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087\4\u0088\t\u0088\4\u0089\t\u0089"+
18599 "\4\u008a\t\u008a\4\u008b\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e"+
18600 "\t\u008e\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092\t\u0092"+
18601 "\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095\t\u0095\4\u0096\t\u0096\4\u0097"+
18602 "\t\u0097\4\u0098\t\u0098\4\u0099\t\u0099\4\u009a\t\u009a\4\u009b\t\u009b"+
18603 "\4\u009c\t\u009c\4\u009d\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f\4\u00a0"+
18604 "\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3\t\u00a3\4\u00a4\t\u00a4"+
18605 "\4\u00a5\t\u00a5\4\u00a6\t\u00a6\4\u00a7\t\u00a7\4\u00a8\t\u00a8\4\u00a9"+
18606 "\t\u00a9\4\u00aa\t\u00aa\4\u00ab\t\u00ab\4\u00ac\t\u00ac\4\u00ad\t\u00ad"+
18607 "\4\u00ae\t\u00ae\4\u00af\t\u00af\4\u00b0\t\u00b0\4\u00b1\t\u00b1\4\u00b2"+
18608 "\t\u00b2\4\u00b3\t\u00b3\4\u00b4\t\u00b4\4\u00b5\t\u00b5\4\u00b6\t\u00b6"+
18609 "\4\u00b7\t\u00b7\4\u00b8\t\u00b8\4\u00b9\t\u00b9\4\u00ba\t\u00ba\4\u00bb"+
18610 "\t\u00bb\4\u00bc\t\u00bc\4\u00bd\t\u00bd\4\u00be\t\u00be\4\u00bf\t\u00bf"+
18611 "\4\u00c0\t\u00c0\4\u00c1\t\u00c1\4\u00c2\t\u00c2\4\u00c3\t\u00c3\4\u00c4"+
18612 "\t\u00c4\4\u00c5\t\u00c5\4\u00c6\t\u00c6\4\u00c7\t\u00c7\4\u00c8\t\u00c8"+
18613 "\4\u00c9\t\u00c9\4\u00ca\t\u00ca\4\u00cb\t\u00cb\4\u00cc\t\u00cc\4\u00cd"+
18614 "\t\u00cd\4\u00ce\t\u00ce\4\u00cf\t\u00cf\4\u00d0\t\u00d0\4\u00d1\t\u00d1"+
18615 "\4\u00d2\t\u00d2\4\u00d3\t\u00d3\4\u00d4\t\u00d4\4\u00d5\t\u00d5\4\u00d6"+
18616 "\t\u00d6\4\u00d7\t\u00d7\4\u00d8\t\u00d8\4\u00d9\t\u00d9\4\u00da\t\u00da"+
18617 "\4\u00db\t\u00db\4\u00dc\t\u00dc\4\u00dd\t\u00dd\4\u00de\t\u00de\4\u00df"+
18618 "\t\u00df\4\u00e0\t\u00e0\4\u00e1\t\u00e1\4\u00e2\t\u00e2\4\u00e3\t\u00e3"+
18619 "\4\u00e4\t\u00e4\4\u00e5\t\u00e5\4\u00e6\t\u00e6\4\u00e7\t\u00e7\4\u00e8"+
18620 "\t\u00e8\4\u00e9\t\u00e9\4\u00ea\t\u00ea\4\u00eb\t\u00eb\4\u00ec\t\u00ec"+
18621 "\4\u00ed\t\u00ed\4\u00ee\t\u00ee\4\u00ef\t\u00ef\4\u00f0\t\u00f0\4\u00f1"+
18622 "\t\u00f1\4\u00f2\t\u00f2\4\u00f3\t\u00f3\4\u00f4\t\u00f4\4\u00f5\t\u00f5"+
18623 "\4\u00f6\t\u00f6\4\u00f7\t\u00f7\4\u00f8\t\u00f8\4\u00f9\t\u00f9\4\u00fa"+
18624 "\t\u00fa\4\u00fb\t\u00fb\3\2\3\2\3\3\7\3\u01fa\n\3\f\3\16\3\u01fd\13\3"+
18625 "\3\3\3\3\7\3\u0201\n\3\f\3\16\3\u0204\13\3\3\3\5\3\u0207\n\3\3\4\3\4\5"+
18626 "\4\u020b\n\4\3\5\3\5\3\6\3\6\3\7\3\7\3\7\5\7\u0214\n\7\3\b\3\b\5\b\u0218"+
18627 "\n\b\3\b\3\b\7\b\u021c\n\b\f\b\16\b\u021f\13\b\3\t\7\t\u0222\n\t\f\t\16"+
18628 "\t\u0225\13\t\3\t\3\t\5\t\u0229\n\t\3\t\3\t\3\t\7\t\u022e\n\t\f\t\16\t"+
18629 "\u0231\13\t\3\t\3\t\5\t\u0235\n\t\5\t\u0237\n\t\3\n\3\n\7\n\u023b\n\n"+
18630 "\f\n\16\n\u023e\13\n\3\n\3\n\5\n\u0242\n\n\3\13\7\13\u0245\n\13\f\13\16"+
18631 "\13\u0248\13\13\3\13\3\13\5\13\u024c\n\13\3\f\3\f\3\r\3\r\3\16\3\16\3"+
18632 "\17\7\17\u0255\n\17\f\17\16\17\u0258\13\17\3\17\3\17\3\20\3\20\3\20\3"+
18633 "\20\3\20\3\20\3\20\3\20\3\20\5\20\u0265\n\20\3\21\7\21\u0268\n\21\f\21"+
18634 "\16\21\u026b\13\21\3\21\3\21\3\21\7\21\u0270\n\21\f\21\16\21\u0273\13"+
18635 "\21\3\21\3\21\7\21\u0277\n\21\f\21\16\21\u027a\13\21\3\22\7\22\u027d\n"+
18636 "\22\f\22\16\22\u0280\13\22\3\22\3\22\5\22\u0284\n\22\3\23\3\23\3\24\3"+
18637 "\24\3\24\3\24\3\24\7\24\u028d\n\24\f\24\16\24\u0290\13\24\5\24\u0292\n"+
18638 "\24\3\25\3\25\3\25\3\26\3\26\3\26\3\26\3\27\3\27\3\27\7\27\u029e\n\27"+
18639 "\f\27\16\27\u02a1\13\27\3\30\3\30\5\30\u02a5\n\30\3\31\7\31\u02a8\n\31"+
18640 "\f\31\16\31\u02ab\13\31\3\31\3\31\5\31\u02af\n\31\3\32\3\32\3\32\3\32"+
18641 "\5\32\u02b5\n\32\3\33\3\33\3\33\3\33\3\33\3\33\7\33\u02bd\n\33\f\33\16"+
18642 "\33\u02c0\13\33\3\34\3\34\3\34\3\34\3\34\3\34\7\34\u02c8\n\34\f\34\16"+
18643 "\34\u02cb\13\34\3\35\3\35\3\35\3\35\3\35\5\35\u02d2\n\35\3\36\3\36\3\36"+
18644 "\3\36\3\36\3\36\7\36\u02da\n\36\f\36\16\36\u02dd\13\36\3\37\3\37\3\37"+
18645 "\3\37\3\37\5\37\u02e4\n\37\3 \3 \3!\3!\3!\3!\3!\3!\7!\u02ee\n!\f!\16!"+
18646 "\u02f1\13!\3\"\3\"\5\"\u02f5\n\"\3#\5#\u02f8\n#\3#\7#\u02fb\n#\f#\16#"+
18647 "\u02fe\13#\3#\7#\u0301\n#\f#\16#\u0304\13#\3#\3#\3$\7$\u0309\n$\f$\16"+
18648 "$\u030c\13$\3$\3$\3%\7%\u0311\n%\f%\16%\u0314\13%\3%\3%\3%\3%\3&\3&\3"+
18649 "\'\3\'\3\'\3\'\5\'\u0320\n\'\3(\3(\3(\3(\3)\3)\3)\3)\3)\3)\3*\3*\3*\3"+
18650 "*\3*\3*\3*\3+\3+\3+\3+\3+\3+\3+\3,\3,\3,\5,\u033d\n,\3-\7-\u0340\n-\f"+
18651 "-\16-\u0343\13-\3-\5-\u0346\n-\3-\3-\3-\3-\7-\u034c\n-\f-\16-\u034f\13"+
18652 "-\3-\3-\3.\3.\3.\3.\3.\5.\u0358\n.\3/\3/\7/\u035c\n/\f/\16/\u035f\13/"+
18653 "\3/\3/\3/\3\60\3\60\3\60\3\60\3\60\3\60\7\60\u036a\n\60\f\60\16\60\u036d"+
18654 "\13\60\5\60\u036f\n\60\3\60\3\60\3\61\3\61\3\61\3\61\3\61\3\61\7\61\u0379"+
18655 "\n\61\f\61\16\61\u037c\13\61\5\61\u037e\n\61\3\61\3\61\3\62\3\62\3\62"+
18656 "\3\62\3\63\3\63\3\63\3\63\3\63\3\63\7\63\u038c\n\63\f\63\16\63\u038f\13"+
18657 "\63\3\63\3\63\3\64\3\64\3\65\3\65\5\65\u0397\n\65\3\66\7\66\u039a\n\66"+
18658 "\f\66\16\66\u039d\13\66\3\66\3\66\3\66\5\66\u03a2\n\66\3\66\5\66\u03a5"+
18659 "\n\66\3\66\5\66\u03a8\n\66\3\66\3\66\3\67\3\67\3\67\3\67\3\67\3\67\3\67"+
18660 "\3\67\5\67\u03b4\n\67\38\38\38\38\39\39\39\79\u03bd\n9\f9\169\u03c0\13"+
18661 "9\3:\3:\3:\3;\3;\3;\3<\3<\3<\7<\u03cb\n<\f<\16<\u03ce\13<\3=\3=\7=\u03d2"+
18662 "\n=\f=\16=\u03d5\13=\3=\3=\3>\3>\3>\3>\5>\u03dd\n>\3?\3?\3?\3?\3?\5?\u03e4"+
18663 "\n?\3@\7@\u03e7\n@\f@\16@\u03ea\13@\3@\3@\3@\3@\3A\3A\3A\3A\3A\3A\3A\3"+
18664 "A\5A\u03f8\nA\3B\3B\3B\7B\u03fd\nB\fB\16B\u0400\13B\3C\3C\3C\5C\u0405"+
18665 "\nC\3D\3D\5D\u0409\nD\3E\3E\5E\u040d\nE\3F\3F\5F\u0411\nF\3G\3G\5G\u0415"+
18666 "\nG\3H\3H\3H\5H\u041a\nH\3I\3I\5I\u041e\nI\3I\3I\7I\u0422\nI\fI\16I\u0425"+
18667 "\13I\3J\3J\5J\u0429\nJ\3J\3J\3J\7J\u042e\nJ\fJ\16J\u0431\13J\3J\3J\5J"+
18668 "\u0435\nJ\5J\u0437\nJ\3K\3K\7K\u043b\nK\fK\16K\u043e\13K\3K\3K\5K\u0442"+
18669 "\nK\3L\3L\5L\u0446\nL\3M\3M\3N\3N\3O\3O\3P\3P\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q"+
18670 "\3Q\5Q\u0459\nQ\3R\7R\u045c\nR\fR\16R\u045f\13R\3R\3R\3R\3S\3S\3S\3S\3"+
18671 "S\3S\3S\3S\3S\3S\5S\u046e\nS\3T\3T\3T\5T\u0473\nT\3T\3T\7T\u0477\nT\f"+
18672 "T\16T\u047a\13T\3T\3T\3T\5T\u047f\nT\5T\u0481\nT\3U\3U\5U\u0485\nU\3V"+
18673 "\3V\3V\5V\u048a\nV\3V\3V\5V\u048e\nV\3W\3W\3W\3W\3W\3W\5W\u0496\nW\3X"+
18674 "\3X\3X\7X\u049b\nX\fX\16X\u049e\13X\3X\3X\3X\7X\u04a3\nX\fX\16X\u04a6"+
18675 "\13X\5X\u04a8\nX\3Y\7Y\u04ab\nY\fY\16Y\u04ae\13Y\3Y\3Y\3Y\3Z\3Z\5Z\u04b5"+
18676 "\nZ\3[\7[\u04b8\n[\f[\16[\u04bb\13[\3[\3[\7[\u04bf\n[\f[\16[\u04c2\13"+
18677 "[\3[\3[\3[\3[\5[\u04c8\n[\3\\\7\\\u04cb\n\\\f\\\16\\\u04ce\13\\\3\\\3"+
18678 "\\\3\\\3\\\5\\\u04d4\n\\\3\\\3\\\3]\3]\3]\3^\3^\3^\7^\u04de\n^\f^\16^"+
18679 "\u04e1\13^\3_\3_\5_\u04e5\n_\3`\3`\5`\u04e9\n`\3a\3a\3b\3b\3b\3c\7c\u04f1"+
18680 "\nc\fc\16c\u04f4\13c\3c\3c\5c\u04f8\nc\3c\3c\3d\3d\3d\3d\5d\u0500\nd\3"+
18681 "e\5e\u0503\ne\3e\3e\3e\5e\u0508\ne\3e\3e\3f\3f\3g\3g\5g\u0510\ng\3g\5"+
18682 "g\u0513\ng\3g\3g\3h\5h\u0518\nh\3h\3h\3h\5h\u051d\nh\3h\3h\3h\5h\u0522"+
18683 "\nh\3h\3h\3h\5h\u0527\nh\3h\3h\3h\3h\3h\5h\u052e\nh\3h\3h\3h\5h\u0533"+
18684 "\nh\3h\3h\3h\3h\3h\3h\5h\u053b\nh\3h\3h\3h\5h\u0540\nh\3h\3h\3h\5h\u0545"+
18685 "\nh\3i\7i\u0548\ni\fi\16i\u054b\13i\3i\3i\3i\5i\u0550\ni\3i\3i\3j\3j\5"+
18686 "j\u0556\nj\3j\5j\u0559\nj\3j\5j\u055c\nj\3j\3j\3k\3k\3k\7k\u0563\nk\f"+
18687 "k\16k\u0566\13k\3l\7l\u0569\nl\fl\16l\u056c\13l\3l\3l\3l\5l\u0571\nl\3"+
18688 "l\5l\u0574\nl\3l\5l\u0577\nl\3m\3m\3n\3n\7n\u057d\nn\fn\16n\u0580\13n"+
18689 "\3o\3o\5o\u0584\no\3p\7p\u0587\np\fp\16p\u058a\13p\3p\3p\3p\5p\u058f\n"+
18690 "p\3p\5p\u0592\np\3p\3p\3q\3q\3q\3q\3q\3q\3q\5q\u059d\nq\3r\3r\3r\3s\3"+
18691 "s\7s\u05a4\ns\fs\16s\u05a7\13s\3s\3s\3t\3t\3t\3t\3t\5t\u05b0\nt\3u\7u"+
18692 "\u05b3\nu\fu\16u\u05b6\13u\3u\3u\3u\3u\3v\3v\3v\3v\5v\u05c0\nv\3w\7w\u05c3"+
18693 "\nw\fw\16w\u05c6\13w\3w\3w\3w\3x\3x\3x\3x\3x\3x\3x\5x\u05d2\nx\3y\7y\u05d5"+
18694 "\ny\fy\16y\u05d8\13y\3y\3y\3y\3y\3y\3z\3z\7z\u05e1\nz\fz\16z\u05e4\13"+
18695 "z\3z\3z\3{\3{\3{\3{\3{\5{\u05ed\n{\3|\7|\u05f0\n|\f|\16|\u05f3\13|\3|"+
18696 "\3|\3|\3|\3|\5|\u05fa\n|\3|\5|\u05fd\n|\3|\3|\3}\3}\3}\5}\u0604\n}\3~"+
18697 "\3~\3~\3\177\3\177\3\177\5\177\u060c\n\177\3\u0080\3\u0080\3\u0080\3\u0080"+
18698 "\5\u0080\u0612\n\u0080\3\u0080\3\u0080\3\u0081\3\u0081\3\u0081\7\u0081"+
18699 "\u0619\n\u0081\f\u0081\16\u0081\u061c\13\u0081\3\u0082\3\u0082\3\u0082"+
18700 "\3\u0082\3\u0083\3\u0083\3\u0083\5\u0083\u0625\n\u0083\3\u0084\3\u0084"+
18701 "\5\u0084\u0629\n\u0084\3\u0084\5\u0084\u062c\n\u0084\3\u0084\3\u0084\3"+
18702 "\u0085\3\u0085\3\u0085\7\u0085\u0633\n\u0085\f\u0085\16\u0085\u0636\13"+
18703 "\u0085\3\u0086\3\u0086\3\u0086\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087"+
18704 "\3\u0087\3\u0088\3\u0088\5\u0088\u0643\n\u0088\3\u0088\5\u0088\u0646\n"+
18705 "\u0088\3\u0088\3\u0088\3\u0089\3\u0089\3\u0089\7\u0089\u064d\n\u0089\f"+
18706 "\u0089\16\u0089\u0650\13\u0089\3\u008a\3\u008a\5\u008a\u0654\n\u008a\3"+
18707 "\u008a\3\u008a\3\u008b\6\u008b\u0659\n\u008b\r\u008b\16\u008b\u065a\3"+
18708 "\u008c\3\u008c\3\u008c\5\u008c\u0660\n\u008c\3\u008d\3\u008d\3\u008d\3"+
18709 "\u008e\7\u008e\u0666\n\u008e\f\u008e\16\u008e\u0669\13\u008e\3\u008e\3"+
18710 "\u008e\3\u008e\3\u008f\3\u008f\3\u008f\3\u008f\3\u008f\3\u008f\5\u008f"+
18711 "\u0674\n\u008f\3\u0090\3\u0090\3\u0090\3\u0090\3\u0090\5\u0090\u067b\n"+
18712 "\u0090\3\u0091\3\u0091\3\u0091\3\u0091\3\u0091\3\u0091\3\u0091\3\u0091"+
18713 "\3\u0091\3\u0091\3\u0091\3\u0091\5\u0091\u0689\n\u0091\3\u0092\3\u0092"+
18714 "\3\u0093\3\u0093\3\u0093\3\u0093\3\u0094\3\u0094\3\u0094\3\u0094\3\u0095"+
18715 "\3\u0095\3\u0095\3\u0096\3\u0096\3\u0096\3\u0096\3\u0096\3\u0096\3\u0096"+
18716 "\5\u0096\u069f\n\u0096\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097"+
18717 "\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098\3\u0099"+
18718 "\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u009a\3\u009a"+
18719 "\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\5\u009a"+
18720 "\u06c1\n\u009a\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009c"+
18721 "\3\u009c\7\u009c\u06cb\n\u009c\f\u009c\16\u009c\u06ce\13\u009c\3\u009c"+
18722 "\7\u009c\u06d1\n\u009c\f\u009c\16\u009c\u06d4\13\u009c\3\u009c\3\u009c"+
18723 "\3\u009d\3\u009d\3\u009d\3\u009e\6\u009e\u06dc\n\u009e\r\u009e\16\u009e"+
18724 "\u06dd\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f"+
18725 "\3\u009f\3\u009f\5\u009f\u06ea\n\u009f\3\u00a0\3\u00a0\3\u00a1\3\u00a1"+
18726 "\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a2"+
18727 "\3\u00a2\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3"+
18728 "\3\u00a4\3\u00a4\5\u00a4\u0704\n\u00a4\3\u00a5\3\u00a5\5\u00a5\u0708\n"+
18729 "\u00a5\3\u00a6\3\u00a6\3\u00a6\5\u00a6\u070d\n\u00a6\3\u00a6\3\u00a6\5"+
18730 "\u00a6\u0711\n\u00a6\3\u00a6\3\u00a6\5\u00a6\u0715\n\u00a6\3\u00a6\3\u00a6"+
18731 "\3\u00a6\3\u00a7\3\u00a7\3\u00a7\5\u00a7\u071d\n\u00a7\3\u00a7\3\u00a7"+
18732 "\5\u00a7\u0721\n\u00a7\3\u00a7\3\u00a7\5\u00a7\u0725\n\u00a7\3\u00a7\3"+
18733 "\u00a7\3\u00a7\3\u00a8\3\u00a8\5\u00a8\u072c\n\u00a8\3\u00a9\3\u00a9\3"+
18734 "\u00aa\3\u00aa\3\u00aa\7\u00aa\u0733\n\u00aa\f\u00aa\16\u00aa\u0736\13"+
18735 "\u00aa\3\u00ab\3\u00ab\3\u00ab\7\u00ab\u073b\n\u00ab\f\u00ab\16\u00ab"+
18736 "\u073e\13\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab"+
18737 "\3\u00ac\3\u00ac\3\u00ac\7\u00ac\u074a\n\u00ac\f\u00ac\16\u00ac\u074d"+
18738 "\13\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ad"+
18739 "\3\u00ad\5\u00ad\u0758\n\u00ad\3\u00ad\3\u00ad\3\u00ae\3\u00ae\5\u00ae"+
18740 "\u075e\n\u00ae\3\u00ae\3\u00ae\3\u00af\3\u00af\5\u00af\u0764\n\u00af\3"+
18741 "\u00af\3\u00af\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b1\3\u00b1\3\u00b1"+
18742 "\3\u00b1\3\u00b1\3\u00b1\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2"+
18743 "\3\u00b2\5\u00b2\u0779\n\u00b2\3\u00b2\3\u00b2\3\u00b2\5\u00b2\u077e\n"+
18744 "\u00b2\3\u00b3\6\u00b3\u0781\n\u00b3\r\u00b3\16\u00b3\u0782\3\u00b4\3"+
18745 "\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b5\7\u00b5\u078c\n\u00b5\f"+
18746 "\u00b5\16\u00b5\u078f\13\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b6\3\u00b6"+
18747 "\3\u00b6\7\u00b6\u0797\n\u00b6\f\u00b6\16\u00b6\u079a\13\u00b6\3\u00b7"+
18748 "\3\u00b7\3\u00b7\3\u00b8\3\u00b8\3\u00b8\3\u00b8\5\u00b8\u07a3\n\u00b8"+
18749 "\3\u00b8\5\u00b8\u07a6\n\u00b8\3\u00b9\3\u00b9\3\u00b9\5\u00b9\u07ab\n"+
18750 "\u00b9\3\u00b9\3\u00b9\3\u00ba\3\u00ba\3\u00ba\7\u00ba\u07b2\n\u00ba\f"+
18751 "\u00ba\16\u00ba\u07b5\13\u00ba\3\u00bb\7\u00bb\u07b8\n\u00bb\f\u00bb\16"+
18752 "\u00bb\u07bb\13\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb"+
18753 "\5\u00bb\u07c3\n\u00bb\3\u00bc\3\u00bc\5\u00bc\u07c7\n\u00bc\3\u00bd\3"+
18754 "\u00bd\5\u00bd\u07cb\n\u00bd\3\u00bd\7\u00bd\u07ce\n\u00bd\f\u00bd\16"+
18755 "\u00bd\u07d1\13\u00bd\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be"+
18756 "\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be"+
18757 "\3\u00be\5\u00be\u07e3\n\u00be\3\u00bf\3\u00bf\3\u00c0\3\u00c0\3\u00c0"+
18758 "\3\u00c0\7\u00c0\u07eb\n\u00c0\f\u00c0\16\u00c0\u07ee\13\u00c0\3\u00c0"+
18759 "\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0"+
18760 "\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0"+
18761 "\5\u00c0\u0803\n\u00c0\3\u00c1\3\u00c1\3\u00c1\3\u00c1\3\u00c1\5\u00c1"+
18762 "\u080a\n\u00c1\3\u00c2\3\u00c2\3\u00c3\3\u00c3\3\u00c3\3\u00c3\5\u00c3"+
18763 "\u0812\n\u00c3\3\u00c4\3\u00c4\3\u00c4\3\u00c4\7\u00c4\u0818\n\u00c4\f"+
18764 "\u00c4\16\u00c4\u081b\13\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4"+
18765 "\3\u00c4\7\u00c4\u0823\n\u00c4\f\u00c4\16\u00c4\u0826\13\u00c4\3\u00c4"+
18766 "\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4"+
18767 "\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4"+
18768 "\3\u00c4\5\u00c4\u083c\n\u00c4\3\u00c5\3\u00c5\3\u00c6\3\u00c6\3\u00c6"+
18769 "\3\u00c6\7\u00c6\u0844\n\u00c6\f\u00c6\16\u00c6\u0847\13\u00c6\3\u00c6"+
18770 "\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6\7\u00c6\u084f\n\u00c6\f\u00c6"+
18771 "\16\u00c6\u0852\13\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6"+
18772 "\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6"+
18773 "\3\u00c6\3\u00c6\3\u00c6\3\u00c6\5\u00c6\u0867\n\u00c6\3\u00c7\3\u00c7"+
18774 "\3\u00c7\5\u00c7\u086c\n\u00c7\3\u00c7\3\u00c7\7\u00c7\u0870\n\u00c7\f"+
18775 "\u00c7\16\u00c7\u0873\13\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7"+
18776 "\5\u00c7\u087a\n\u00c7\3\u00c8\3\u00c8\5\u00c8\u087e\n\u00c8\3\u00c8\7"+
18777 "\u00c8\u0881\n\u00c8\f\u00c8\16\u00c8\u0884\13\u00c8\3\u00c8\3\u00c8\3"+
18778 "\u00c8\7\u00c8\u0889\n\u00c8\f\u00c8\16\u00c8\u088c\13\u00c8\3\u00c8\7"+
18779 "\u00c8\u088f\n\u00c8\f\u00c8\16\u00c8\u0892\13\u00c8\3\u00c8\5\u00c8\u0895"+
18780 "\n\u00c8\3\u00c8\3\u00c8\5\u00c8\u0899\n\u00c8\3\u00c8\3\u00c8\5\u00c8"+
18781 "\u089d\n\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8\5\u00c8\u08a3\n\u00c8\3"+
18782 "\u00c8\7\u00c8\u08a6\n\u00c8\f\u00c8\16\u00c8\u08a9\13\u00c8\3\u00c8\3"+
18783 "\u00c8\5\u00c8\u08ad\n\u00c8\3\u00c8\3\u00c8\5\u00c8\u08b1\n\u00c8\3\u00c8"+
18784 "\3\u00c8\5\u00c8\u08b5\n\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8\5\u00c8"+
18785 "\u08bb\n\u00c8\3\u00c8\7\u00c8\u08be\n\u00c8\f\u00c8\16\u00c8\u08c1\13"+
18786 "\u00c8\3\u00c8\3\u00c8\5\u00c8\u08c5\n\u00c8\3\u00c8\3\u00c8\5\u00c8\u08c9"+
18787 "\n\u00c8\3\u00c8\3\u00c8\5\u00c8\u08cd\n\u00c8\5\u00c8\u08cf\n\u00c8\3"+
18788 "\u00c9\3\u00c9\3\u00c9\5\u00c9\u08d4\n\u00c9\3\u00c9\7\u00c9\u08d7\n\u00c9"+
18789 "\f\u00c9\16\u00c9\u08da\13\u00c9\3\u00c9\3\u00c9\5\u00c9\u08de\n\u00c9"+
18790 "\3\u00c9\3\u00c9\5\u00c9\u08e2\n\u00c9\3\u00c9\3\u00c9\5\u00c9\u08e6\n"+
18791 "\u00c9\3\u00ca\3\u00ca\5\u00ca\u08ea\n\u00ca\3\u00ca\7\u00ca\u08ed\n\u00ca"+
18792 "\f\u00ca\16\u00ca\u08f0\13\u00ca\3\u00ca\3\u00ca\3\u00ca\7\u00ca\u08f5"+
18793 "\n\u00ca\f\u00ca\16\u00ca\u08f8\13\u00ca\3\u00ca\7\u00ca\u08fb\n\u00ca"+
18794 "\f\u00ca\16\u00ca\u08fe\13\u00ca\3\u00ca\5\u00ca\u0901\n\u00ca\3\u00ca"+
18795 "\3\u00ca\5\u00ca\u0905\n\u00ca\3\u00ca\3\u00ca\5\u00ca\u0909\n\u00ca\3"+
18796 "\u00ca\3\u00ca\3\u00ca\3\u00ca\5\u00ca\u090f\n\u00ca\3\u00ca\7\u00ca\u0912"+
18797 "\n\u00ca\f\u00ca\16\u00ca\u0915\13\u00ca\3\u00ca\3\u00ca\5\u00ca\u0919"+
18798 "\n\u00ca\3\u00ca\3\u00ca\5\u00ca\u091d\n\u00ca\3\u00ca\3\u00ca\5\u00ca"+
18799 "\u0921\n\u00ca\5\u00ca\u0923\n\u00ca\3\u00cb\3\u00cb\3\u00cb\5\u00cb\u0928"+
18800 "\n\u00cb\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc"+
18801 "\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\5\u00cc\u0937\n\u00cc\3\u00cd"+
18802 "\3\u00cd\3\u00cd\3\u00ce\3\u00ce\3\u00ce\3\u00ce\3\u00ce\3\u00ce\3\u00ce"+
18803 "\3\u00ce\3\u00ce\5\u00ce\u0945\n\u00ce\3\u00cf\3\u00cf\3\u00cf\3\u00cf"+
18804 "\3\u00cf\3\u00cf\3\u00cf\3\u00cf\3\u00cf\3\u00cf\5\u00cf\u0951\n\u00cf"+
18805 "\3\u00cf\3\u00cf\3\u00cf\3\u00cf\3\u00cf\7\u00cf\u0958\n\u00cf\f\u00cf"+
18806 "\16\u00cf\u095b\13\u00cf\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0"+
18807 "\3\u00d0\3\u00d0\3\u00d0\3\u00d0\7\u00d0\u0967\n\u00d0\f\u00d0\16\u00d0"+
18808 "\u096a\13\u00d0\3\u00d1\3\u00d1\3\u00d1\3\u00d1\3\u00d1\3\u00d1\3\u00d1"+
18809 "\3\u00d1\3\u00d1\3\u00d1\5\u00d1\u0976\n\u00d1\3\u00d1\3\u00d1\3\u00d1"+
18810 "\3\u00d1\3\u00d1\7\u00d1\u097d\n\u00d1\f\u00d1\16\u00d1\u0980\13\u00d1"+
18811 "\3\u00d2\3\u00d2\3\u00d2\5\u00d2\u0985\n\u00d2\3\u00d2\3\u00d2\3\u00d2"+
18812 "\3\u00d2\3\u00d2\5\u00d2\u098c\n\u00d2\3\u00d2\3\u00d2\3\u00d2\5\u00d2"+
18813 "\u0991\n\u00d2\3\u00d2\3\u00d2\3\u00d2\3\u00d2\3\u00d2\5\u00d2\u0998\n"+
18814 "\u00d2\3\u00d2\3\u00d2\3\u00d2\5\u00d2\u099d\n\u00d2\3\u00d2\3\u00d2\3"+
18815 "\u00d2\3\u00d2\3\u00d2\5\u00d2\u09a4\n\u00d2\3\u00d2\3\u00d2\3\u00d2\5"+
18816 "\u00d2\u09a9\n\u00d2\3\u00d2\3\u00d2\3\u00d2\3\u00d2\3\u00d2\5\u00d2\u09b0"+
18817 "\n\u00d2\3\u00d2\3\u00d2\3\u00d2\5\u00d2\u09b5\n\u00d2\3\u00d2\3\u00d2"+
18818 "\3\u00d2\3\u00d2\3\u00d2\3\u00d2\3\u00d2\5\u00d2\u09be\n\u00d2\3\u00d2"+
18819 "\3\u00d2\3\u00d2\5\u00d2\u09c3\n\u00d2\3\u00d2\3\u00d2\5\u00d2\u09c7\n"+
18820 "\u00d2\3\u00d3\3\u00d3\5\u00d3\u09cb\n\u00d3\3\u00d3\3\u00d3\3\u00d3\5"+
18821 "\u00d3\u09d0\n\u00d3\3\u00d3\3\u00d3\3\u00d4\3\u00d4\3\u00d4\5\u00d4\u09d7"+
18822 "\n\u00d4\3\u00d4\3\u00d4\3\u00d4\3\u00d4\3\u00d4\5\u00d4\u09de\n\u00d4"+
18823 "\3\u00d4\3\u00d4\3\u00d4\5\u00d4\u09e3\n\u00d4\3\u00d4\3\u00d4\3\u00d4"+
18824 "\3\u00d4\3\u00d4\5\u00d4\u09ea\n\u00d4\3\u00d4\3\u00d4\3\u00d4\5\u00d4"+
18825 "\u09ef\n\u00d4\3\u00d4\3\u00d4\3\u00d4\3\u00d4\3\u00d4\5\u00d4\u09f6\n"+
18826 "\u00d4\3\u00d4\3\u00d4\3\u00d4\5\u00d4\u09fb\n\u00d4\3\u00d4\3\u00d4\3"+
18827 "\u00d4\3\u00d4\3\u00d4\3\u00d4\3\u00d4\5\u00d4\u0a04\n\u00d4\3\u00d4\3"+
18828 "\u00d4\3\u00d4\5\u00d4\u0a09\n\u00d4\3\u00d4\3\u00d4\5\u00d4\u0a0d\n\u00d4"+
18829 "\3\u00d5\3\u00d5\3\u00d5\7\u00d5\u0a12\n\u00d5\f\u00d5\16\u00d5\u0a15"+
18830 "\13\u00d5\3\u00d6\3\u00d6\3\u00d6\5\u00d6\u0a1a\n\u00d6\3\u00d6\3\u00d6"+
18831 "\3\u00d6\3\u00d6\3\u00d6\5\u00d6\u0a21\n\u00d6\3\u00d6\3\u00d6\3\u00d6"+
18832 "\3\u00d6\3\u00d6\5\u00d6\u0a28\n\u00d6\3\u00d6\3\u00d6\3\u00d6\3\u00d6"+
18833 "\3\u00d6\5\u00d6\u0a2f\n\u00d6\3\u00d6\3\u00d6\3\u00d6\3\u00d6\3\u00d6"+
18834 "\3\u00d6\5\u00d6\u0a37\n\u00d6\3\u00d6\3\u00d6\3\u00d6\3\u00d6\3\u00d6"+
18835 "\5\u00d6\u0a3e\n\u00d6\3\u00d6\3\u00d6\3\u00d6\3\u00d6\3\u00d6\3\u00d6"+
18836 "\5\u00d6\u0a46\n\u00d6\3\u00d7\3\u00d7\5\u00d7\u0a4a\n\u00d7\3\u00d7\3"+
18837 "\u00d7\3\u00d8\3\u00d8\3\u00d8\5\u00d8\u0a51\n\u00d8\3\u00d8\3\u00d8\3"+
18838 "\u00d8\3\u00d8\3\u00d8\5\u00d8\u0a58\n\u00d8\3\u00d8\3\u00d8\3\u00d8\3"+
18839 "\u00d8\3\u00d8\5\u00d8\u0a5f\n\u00d8\3\u00d8\3\u00d8\3\u00d8\3\u00d8\3"+
18840 "\u00d8\3\u00d8\5\u00d8\u0a67\n\u00d8\3\u00d8\3\u00d8\3\u00d8\3\u00d8\3"+
18841 "\u00d8\5\u00d8\u0a6e\n\u00d8\3\u00d8\3\u00d8\3\u00d8\3\u00d8\3\u00d8\3"+
18842 "\u00d8\5\u00d8\u0a76\n\u00d8\3\u00d9\3\u00d9\3\u00d9\3\u00d9\5\u00d9\u0a7c"+
18843 "\n\u00d9\3\u00d9\3\u00d9\3\u00d9\3\u00d9\5\u00d9\u0a82\n\u00d9\3\u00d9"+
18844 "\3\u00d9\3\u00d9\3\u00d9\3\u00d9\3\u00d9\3\u00d9\3\u00d9\3\u00d9\3\u00d9"+
18845 "\5\u00d9\u0a8e\n\u00d9\3\u00da\6\u00da\u0a91\n\u00da\r\u00da\16\u00da"+
18846 "\u0a92\3\u00db\7\u00db\u0a96\n\u00db\f\u00db\16\u00db\u0a99\13\u00db\3"+
18847 "\u00db\3\u00db\3\u00db\3\u00db\3\u00dc\3\u00dc\3\u00dd\3\u00dd\5\u00dd"+
18848 "\u0aa3\n\u00dd\3\u00de\3\u00de\3\u00de\3\u00de\3\u00df\3\u00df\3\u00df"+
18849 "\5\u00df\u0aac\n\u00df\3\u00df\3\u00df\3\u00df\3\u00df\3\u00df\5\u00df"+
18850 "\u0ab3\n\u00df\3\u00e0\3\u00e0\3\u00e0\7\u00e0\u0ab8\n\u00e0\f\u00e0\16"+
18851 "\u00e0\u0abb\13\u00e0\3\u00e1\3\u00e1\5\u00e1\u0abf\n\u00e1\3\u00e2\3"+
18852 "\u00e2\5\u00e2\u0ac3\n\u00e2\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e4\3"+
18853 "\u00e4\3\u00e4\5\u00e4\u0acc\n\u00e4\3\u00e5\3\u00e5\3\u00e6\3\u00e6\3"+
18854 "\u00e6\3\u00e6\3\u00e6\3\u00e6\3\u00e6\5\u00e6\u0ad7\n\u00e6\5\u00e6\u0ad9"+
18855 "\n\u00e6\3\u00e7\3\u00e7\3\u00e7\3\u00e7\3\u00e7\3\u00e7\7\u00e7\u0ae1"+
18856 "\n\u00e7\f\u00e7\16\u00e7\u0ae4\13\u00e7\3\u00e8\3\u00e8\3\u00e8\3\u00e8"+
18857 "\3\u00e8\3\u00e8\7\u00e8\u0aec\n\u00e8\f\u00e8\16\u00e8\u0aef\13\u00e8"+
18858 "\3\u00e9\3\u00e9\3\u00e9\3\u00e9\3\u00e9\3\u00e9\7\u00e9\u0af7\n\u00e9"+
18859 "\f\u00e9\16\u00e9\u0afa\13\u00e9\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea"+
18860 "\3\u00ea\7\u00ea\u0b02\n\u00ea\f\u00ea\16\u00ea\u0b05\13\u00ea\3\u00eb"+
18861 "\3\u00eb\3\u00eb\3\u00eb\3\u00eb\3\u00eb\7\u00eb\u0b0d\n\u00eb\f\u00eb"+
18862 "\16\u00eb\u0b10\13\u00eb\3\u00ec\3\u00ec\3\u00ec\3\u00ec\3\u00ec\3\u00ec"+
18863 "\3\u00ec\3\u00ec\3\u00ec\7\u00ec\u0b1b\n\u00ec\f\u00ec\16\u00ec\u0b1e"+
18864 "\13\u00ec\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed"+
18865 "\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed"+
18866 "\3\u00ed\7\u00ed\u0b32\n\u00ed\f\u00ed\16\u00ed\u0b35\13\u00ed\3\u00ee"+
18867 "\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee"+
18868 "\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\7\u00ee\u0b47\n\u00ee"+
18869 "\f\u00ee\16\u00ee\u0b4a\13\u00ee\3\u00ef\3\u00ef\3\u00ef\3\u00ef\3\u00ef"+
18870 "\3\u00ef\3\u00ef\3\u00ef\3\u00ef\7\u00ef\u0b55\n\u00ef\f\u00ef\16\u00ef"+
18871 "\u0b58\13\u00ef\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0"+
18872 "\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\7\u00f0\u0b66\n\u00f0\f\u00f0"+
18873 "\16\u00f0\u0b69\13\u00f0\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1"+
18874 "\3\u00f1\5\u00f1\u0b72\n\u00f1\3\u00f2\3\u00f2\3\u00f2\3\u00f3\3\u00f3"+
18875 "\3\u00f3\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4\5\u00f4\u0b80"+
18876 "\n\u00f4\3\u00f5\3\u00f5\5\u00f5\u0b84\n\u00f5\3\u00f5\3\u00f5\7\u00f5"+
18877 "\u0b88\n\u00f5\f\u00f5\16\u00f5\u0b8b\13\u00f5\3\u00f6\3\u00f6\3\u00f6"+
18878 "\3\u00f7\3\u00f7\3\u00f8\3\u00f8\3\u00f8\3\u00f9\3\u00f9\3\u00fa\3\u00fa"+
18879 "\3\u00fa\3\u00fa\3\u00fa\3\u00fa\3\u00fa\3\u00fa\7\u00fa\u0b9f\n\u00fa"+
18880 "\f\u00fa\16\u00fa\u0ba2\13\u00fa\3\u00fa\3\u00fa\3\u00fa\3\u00fa\3\u00fa"+
18881 "\3\u00fa\7\u00fa\u0baa\n\u00fa\f\u00fa\16\u00fa\u0bad\13\u00fa\3\u00fa"+
18882 "\3\u00fa\3\u00fa\5\u00fa\u0bb2\n\u00fa\3\u00fb\3\u00fb\3\u00fb\2\20\64"+
18883 "\66:@\u01cc\u01ce\u01d0\u01d2\u01d4\u01d6\u01d8\u01da\u01dc\u01de\u00fc"+
18884 "\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFH"+
18885 "JLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c"+
18886 "\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4"+
18887 "\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc"+
18888 "\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4"+
18889 "\u00d6\u00d8\u00da\u00dc\u00de\u00e0\u00e2\u00e4\u00e6\u00e8\u00ea\u00ec"+
18890 "\u00ee\u00f0\u00f2\u00f4\u00f6\u00f8\u00fa\u00fc\u00fe\u0100\u0102\u0104"+
18891 "\u0106\u0108\u010a\u010c\u010e\u0110\u0112\u0114\u0116\u0118\u011a\u011c"+
18892 "\u011e\u0120\u0122\u0124\u0126\u0128\u012a\u012c\u012e\u0130\u0132\u0134"+
18893 "\u0136\u0138\u013a\u013c\u013e\u0140\u0142\u0144\u0146\u0148\u014a\u014c"+
18894 "\u014e\u0150\u0152\u0154\u0156\u0158\u015a\u015c\u015e\u0160\u0162\u0164"+
18895 "\u0166\u0168\u016a\u016c\u016e\u0170\u0172\u0174\u0176\u0178\u017a\u017c"+
18896 "\u017e\u0180\u0182\u0184\u0186\u0188\u018a\u018c\u018e\u0190\u0192\u0194"+
18897 "\u0196\u0198\u019a\u019c\u019e\u01a0\u01a2\u01a4\u01a6\u01a8\u01aa\u01ac"+
18898 "\u01ae\u01b0\u01b2\u01b4\u01b6\u01b8\u01ba\u01bc\u01be\u01c0\u01c2\u01c4"+
18899 "\u01c6\u01c8\u01ca\u01cc\u01ce\u01d0\u01d2\u01d4\u01d6\u01d8\u01da\u01dc"+
18900 "\u01de\u01e0\u01e2\u01e4\u01e6\u01e8\u01ea\u01ec\u01ee\u01f0\u01f2\u01f4"+
18901 "\2\b\3\2@E\7\2\21\21\24\24\'\'))\61\61\4\2\32\32 \4\2\f\f\62\62\4\2R"+
18902 "Rjt\4\2\3\13uu\2\u0caf\2\u01f6\3\2\2\2\4\u0206\3\2\2\2\6\u020a\3\2\2\2"+
18903 "\b\u020c\3\2\2\2\n\u020e\3\2\2\2\f\u0213\3\2\2\2\16\u0217\3\2\2\2\20\u0236"+
18904 "\3\2\2\2\22\u0238\3\2\2\2\24\u0246\3\2\2\2\26\u024d\3\2\2\2\30\u024f\3"+
18905 "\2\2\2\32\u0251\3\2\2\2\34\u0256\3\2\2\2\36\u0264\3\2\2\2 \u0269\3\2\2"+
18906 "\2\"\u027e\3\2\2\2$\u0285\3\2\2\2&\u0291\3\2\2\2(\u0293\3\2\2\2*\u0296"+
18907 "\3\2\2\2,\u029a\3\2\2\2.\u02a4\3\2\2\2\60\u02a9\3\2\2\2\62\u02b4\3\2\2"+
18908 "\2\64\u02b6\3\2\2\2\66\u02c1\3\2\2\28\u02d1\3\2\2\2:\u02d3\3\2\2\2<\u02e3"+
18909 "\3\2\2\2>\u02e5\3\2\2\2@\u02e7\3\2\2\2B\u02f4\3\2\2\2D\u02f7\3\2\2\2F"+
18910 "\u030a\3\2\2\2H\u0312\3\2\2\2J\u0319\3\2\2\2L\u031f\3\2\2\2N\u0321\3\2"+
18911 "\2\2P\u0325\3\2\2\2R\u032b\3\2\2\2T\u0332\3\2\2\2V\u033c\3\2\2\2X\u0341"+
18912 "\3\2\2\2Z\u0357\3\2\2\2\\\u0359\3\2\2\2^\u0363\3\2\2\2`\u0372\3\2\2\2"+
18913 "b\u0381\3\2\2\2d\u0385\3\2\2\2f\u0392\3\2\2\2h\u0396\3\2\2\2j\u039b\3"+
18914 "\2\2\2l\u03b3\3\2\2\2n\u03b5\3\2\2\2p\u03b9\3\2\2\2r\u03c1\3\2\2\2t\u03c4"+
18915 "\3\2\2\2v\u03c7\3\2\2\2x\u03cf\3\2\2\2z\u03dc\3\2\2\2|\u03e3\3\2\2\2~"+
18916 "\u03e8\3\2\2\2\u0080\u03f7\3\2\2\2\u0082\u03f9\3\2\2\2\u0084\u0401\3\2"+
18917 "\2\2\u0086\u0406\3\2\2\2\u0088\u040c\3\2\2\2\u008a\u0410\3\2\2\2\u008c"+
18918 "\u0414\3\2\2\2\u008e\u0419\3\2\2\2\u0090\u041d\3\2\2\2\u0092\u0436\3\2"+
18919 "\2\2\u0094\u0438\3\2\2\2\u0096\u0443\3\2\2\2\u0098\u0447\3\2\2\2\u009a"+
18920 "\u0449\3\2\2\2\u009c\u044b\3\2\2\2\u009e\u044d\3\2\2\2\u00a0\u0458\3\2"+
18921 "\2\2\u00a2\u045d\3\2\2\2\u00a4\u046d\3\2\2\2\u00a6\u0480\3\2\2\2\u00a8"+
18922 "\u0484\3\2\2\2\u00aa\u0486\3\2\2\2\u00ac\u0495\3\2\2\2\u00ae\u04a7\3\2"+
18923 "\2\2\u00b0\u04ac\3\2\2\2\u00b2\u04b4\3\2\2\2\u00b4\u04c7\3\2\2\2\u00b6"+
18924 "\u04cc\3\2\2\2\u00b8\u04d7\3\2\2\2\u00ba\u04da\3\2\2\2\u00bc\u04e4\3\2"+
18925 "\2\2\u00be\u04e8\3\2\2\2\u00c0\u04ea\3\2\2\2\u00c2\u04ec\3\2\2\2\u00c4"+
18926 "\u04f2\3\2\2\2\u00c6\u04ff\3\2\2\2\u00c8\u0502\3\2\2\2\u00ca\u050b\3\2"+
18927 "\2\2\u00cc\u050d\3\2\2\2\u00ce\u0544\3\2\2\2\u00d0\u0549\3\2\2\2\u00d2"+
18928 "\u0553\3\2\2\2\u00d4\u055f\3\2\2\2\u00d6\u056a\3\2\2\2\u00d8\u0578\3\2"+
18929 "\2\2\u00da\u057a\3\2\2\2\u00dc\u0583\3\2\2\2\u00de\u0588\3\2\2\2\u00e0"+
18930 "\u059c\3\2\2\2\u00e2\u059e\3\2\2\2\u00e4\u05a1\3\2\2\2\u00e6\u05af\3\2"+
18931 "\2\2\u00e8\u05b4\3\2\2\2\u00ea\u05bf\3\2\2\2\u00ec\u05c4\3\2\2\2\u00ee"+
18932 "\u05d1\3\2\2\2\u00f0\u05d6\3\2\2\2\u00f2\u05de\3\2\2\2\u00f4\u05ec\3\2"+
18933 "\2\2\u00f6\u05f1\3\2\2\2\u00f8\u0603\3\2\2\2\u00fa\u0605\3\2\2\2\u00fc"+
18934 "\u060b\3\2\2\2\u00fe\u060d\3\2\2\2\u0100\u0615\3\2\2\2\u0102\u061d\3\2"+
18935 "\2\2\u0104\u0624\3\2\2\2\u0106\u0626\3\2\2\2\u0108\u062f\3\2\2\2\u010a"+
18936 "\u0637\3\2\2\2\u010c\u063a\3\2\2\2\u010e\u0640\3\2\2\2\u0110\u0649\3\2"+
18937 "\2\2\u0112\u0651\3\2\2\2\u0114\u0658\3\2\2\2\u0116\u065f\3\2\2\2\u0118"+
18938 "\u0661\3\2\2\2\u011a\u0667\3\2\2\2\u011c\u0673\3\2\2\2\u011e\u067a\3\2"+
18939 "\2\2\u0120\u0688\3\2\2\2\u0122\u068a\3\2\2\2\u0124\u068c\3\2\2\2\u0126"+
18940 "\u0690\3\2\2\2\u0128\u0694\3\2\2\2\u012a\u069e\3\2\2\2\u012c\u06a0\3\2"+
18941 "\2\2\u012e\u06a6\3\2\2\2\u0130\u06ae\3\2\2\2\u0132\u06c0\3\2\2\2\u0134"+
18942 "\u06c2\3\2\2\2\u0136\u06c8\3\2\2\2\u0138\u06d7\3\2\2\2\u013a\u06db\3\2"+
18943 "\2\2\u013c\u06e9\3\2\2\2\u013e\u06eb\3\2\2\2\u0140\u06ed\3\2\2\2\u0142"+
18944 "\u06f3\3\2\2\2\u0144\u06f9\3\2\2\2\u0146\u0703\3\2\2\2\u0148\u0707\3\2"+
18945 "\2\2\u014a\u0709\3\2\2\2\u014c\u0719\3\2\2\2\u014e\u072b\3\2\2\2\u0150"+
18946 "\u072d\3\2\2\2\u0152\u072f\3\2\2\2\u0154\u0737\3\2\2\2\u0156\u0746\3\2"+
18947 "\2\2\u0158\u0755\3\2\2\2\u015a\u075b\3\2\2\2\u015c\u0761\3\2\2\2\u015e"+
18948 "\u0767\3\2\2\2\u0160\u076b\3\2\2\2\u0162\u077d\3\2\2\2\u0164\u0780\3\2"+
18949 "\2\2\u0166\u0784\3\2\2\2\u0168\u078d\3\2\2\2\u016a\u0793\3\2\2\2\u016c"+
18950 "\u079b\3\2\2\2\u016e\u079e\3\2\2\2\u0170\u07a7\3\2\2\2\u0172\u07ae\3\2"+
18951 "\2\2\u0174\u07c2\3\2\2\2\u0176\u07c6\3\2\2\2\u0178\u07ca\3\2\2\2\u017a"+
18952 "\u07e2\3\2\2\2\u017c\u07e4\3\2\2\2\u017e\u0802\3\2\2\2\u0180\u0809\3\2"+
18953 "\2\2\u0182\u080b\3\2\2\2\u0184\u0811\3\2\2\2\u0186\u083b\3\2\2\2\u0188"+
18954 "\u083d\3\2\2\2\u018a\u0866\3\2\2\2\u018c\u0879\3\2\2\2\u018e\u08ce\3\2"+
18955 "\2\2\u0190\u08d0\3\2\2\2\u0192\u0922\3\2\2\2\u0194\u0927\3\2\2\2\u0196"+
18956 "\u0936\3\2\2\2\u0198\u0938\3\2\2\2\u019a\u0944\3\2\2\2\u019c\u0950\3\2"+
18957 "\2\2\u019e\u095c\3\2\2\2\u01a0\u0975\3\2\2\2\u01a2\u09c6\3\2\2\2\u01a4"+
18958 "\u09c8\3\2\2\2\u01a6\u0a0c\3\2\2\2\u01a8\u0a0e\3\2\2\2\u01aa\u0a45\3\2"+
18959 "\2\2\u01ac\u0a47\3\2\2\2\u01ae\u0a75\3\2\2\2\u01b0\u0a8d\3\2\2\2\u01b2"+
18960 "\u0a90\3\2\2\2\u01b4\u0a97\3\2\2\2\u01b6\u0a9e\3\2\2\2\u01b8\u0aa2\3\2"+
18961 "\2\2\u01ba\u0aa4\3\2\2\2\u01bc\u0ab2\3\2\2\2\u01be\u0ab4\3\2\2\2\u01c0"+
18962 "\u0abe\3\2\2\2\u01c2\u0ac2\3\2\2\2\u01c4\u0ac4\3\2\2\2\u01c6\u0acb\3\2"+
18963 "\2\2\u01c8\u0acd\3\2\2\2\u01ca\u0ad8\3\2\2\2\u01cc\u0ada\3\2\2\2\u01ce"+
18964 "\u0ae5\3\2\2\2\u01d0\u0af0\3\2\2\2\u01d2\u0afb\3\2\2\2\u01d4\u0b06\3\2"+
18965 "\2\2\u01d6\u0b11\3\2\2\2\u01d8\u0b1f\3\2\2\2\u01da\u0b36\3\2\2\2\u01dc"+
18966 "\u0b4b\3\2\2\2\u01de\u0b59\3\2\2\2\u01e0\u0b71\3\2\2\2\u01e2\u0b73\3\2"+
18967 "\2\2\u01e4\u0b76\3\2\2\2\u01e6\u0b7f\3\2\2\2\u01e8\u0b83\3\2\2\2\u01ea"+
18968 "\u0b8c\3\2\2\2\u01ec\u0b8f\3\2\2\2\u01ee\u0b91\3\2\2\2\u01f0\u0b94\3\2"+
18969 "\2\2\u01f2\u0bb1\3\2\2\2\u01f4\u0bb3\3\2\2\2\u01f6\u01f7\t\2\2\2\u01f7"+
18970 "\3\3\2\2\2\u01f8\u01fa\5\u00fc\177\2\u01f9\u01f8\3\2\2\2\u01fa\u01fd\3"+
18971 "\2\2\2\u01fb\u01f9\3\2\2\2\u01fb\u01fc\3\2\2\2\u01fc\u01fe\3\2\2\2\u01fd"+
18972 "\u01fb\3\2\2\2\u01fe\u0207\5\6\4\2\u01ff\u0201\5\u00fc\177\2\u0200\u01ff"+
18973 "\3\2\2\2\u0201\u0204\3\2\2\2\u0202\u0200\3\2\2\2\u0202\u0203\3\2\2\2\u0203"+
18974 "\u0205\3\2\2\2\u0204\u0202\3\2\2\2\u0205\u0207\7\17\2\2\u0206\u01fb\3"+
18975 "\2\2\2\u0206\u0202\3\2\2\2\u0207\5\3\2\2\2\u0208\u020b\5\b\5\2\u0209\u020b"+
18976 "\5\n\6\2\u020a\u0208\3\2\2\2\u020a\u0209\3\2\2\2\u020b\7\3\2\2\2\u020c"+
18977 "\u020d\t\3\2\2\u020d\t\3\2\2\2\u020e\u020f\t\4\2\2\u020f\13\3\2\2\2\u0210"+
18978 "\u0214\5\16\b\2\u0211\u0214\5\34\17\2\u0212\u0214\5\36\20\2\u0213\u0210"+
18979 "\3\2\2\2\u0213\u0211\3\2\2\2\u0213\u0212\3\2\2\2\u0214\r\3\2\2\2\u0215"+
18980 "\u0218\5\24\13\2\u0216\u0218\5\32\16\2\u0217\u0215\3\2\2\2\u0217\u0216"+
18981 "\3\2\2\2\u0218\u021d\3\2\2\2\u0219\u021c\5\22\n\2\u021a\u021c\5\30\r\2"+
18982 "\u021b\u0219\3\2\2\2\u021b\u021a\3\2\2\2\u021c\u021f\3\2\2\2\u021d\u021b"+
18983 "\3\2\2\2\u021d\u021e\3\2\2\2\u021e\17\3\2\2\2\u021f\u021d\3\2\2\2\u0220"+
18984 "\u0222\5\u00fc\177\2\u0221\u0220\3\2\2\2\u0222\u0225\3\2\2\2\u0223\u0221"+
18985 "\3\2\2\2\u0223\u0224\3\2\2\2\u0224\u0226\3\2\2\2\u0225\u0223\3\2\2\2\u0226"+
18986 "\u0228\5\u01f4\u00fb\2\u0227\u0229\5*\26\2\u0228\u0227\3\2\2\2\u0228\u0229"+
18987 "\3\2\2\2\u0229\u0237\3\2\2\2\u022a\u022b\5\16\b\2\u022b\u022f\7N\2\2\u022c"+
18988 "\u022e\5\u00fc\177\2\u022d\u022c\3\2\2\2\u022e\u0231\3\2\2\2\u022f\u022d"+
18989 "\3\2\2\2\u022f\u0230\3\2\2\2\u0230\u0232\3\2\2\2\u0231\u022f\3\2\2\2\u0232"+
18990 "\u0234\5\u01f4\u00fb\2\u0233\u0235\5*\26\2\u0234\u0233\3\2\2\2\u0234\u0235"+
18991 "\3\2\2\2\u0235\u0237\3\2\2\2\u0236\u0223\3\2\2\2\u0236\u022a\3\2\2\2\u0237"+
18992 "\21\3\2\2\2\u0238\u023c\7N\2\2\u0239\u023b\5\u00fc\177\2\u023a\u0239\3"+
18993 "\2\2\2\u023b\u023e\3\2\2\2\u023c\u023a\3\2\2\2\u023c\u023d\3\2\2\2\u023d"+
18994 "\u023f\3\2\2\2\u023e\u023c\3\2\2\2\u023f\u0241\5\u01f4\u00fb\2\u0240\u0242"+
18995 "\5*\26\2\u0241\u0240\3\2\2\2\u0241\u0242\3\2\2\2\u0242\23\3\2\2\2\u0243"+
18996 "\u0245\5\u00fc\177\2\u0244\u0243\3\2\2\2\u0245\u0248\3\2\2\2\u0246\u0244"+
18997 "\3\2\2\2\u0246\u0247\3\2\2\2\u0247\u0249\3\2\2\2\u0248\u0246\3\2\2\2\u0249"+
18998 "\u024b\5\u01f4\u00fb\2\u024a\u024c\5*\26\2\u024b\u024a\3\2\2\2\u024b\u024c"+
18999 "\3\2\2\2\u024c\25\3\2\2\2\u024d\u024e\5\20\t\2\u024e\27\3\2\2\2\u024f"+
19000 "\u0250\5\22\n\2\u0250\31\3\2\2\2\u0251\u0252\5\24\13\2\u0252\33\3\2\2"+
19001 "\2\u0253\u0255\5\u00fc\177\2\u0254\u0253\3\2\2\2\u0255\u0258\3\2\2\2\u0256"+
19002 "\u0254\3\2\2\2\u0256\u0257\3\2\2\2\u0257\u0259\3\2\2\2\u0258\u0256\3\2"+
19003 "\2\2\u0259\u025a\5\u01f4\u00fb\2\u025a\35\3\2\2\2\u025b\u025c\5\4\3\2"+
19004 "\u025c\u025d\5 \21\2\u025d\u0265\3\2\2\2\u025e\u025f\5\16\b\2\u025f\u0260"+
19005 "\5 \21\2\u0260\u0265\3\2\2\2\u0261\u0262\5\34\17\2\u0262\u0263\5 \21\2"+
19006 "\u0263\u0265\3\2\2\2\u0264\u025b\3\2\2\2\u0264\u025e\3\2\2\2\u0264\u0261"+
19007 "\3\2\2\2\u0265\37\3\2\2\2\u0266\u0268\5\u00fc\177\2\u0267\u0266\3\2\2"+
19008 "\2\u0268\u026b\3\2\2\2\u0269\u0267\3\2\2\2\u0269\u026a\3\2\2\2\u026a\u026c"+
19009 "\3\2\2\2\u026b\u0269\3\2\2\2\u026c\u026d\7J\2\2\u026d\u0278\7K\2\2\u026e"+
19010 "\u0270\5\u00fc\177\2\u026f\u026e\3\2\2\2\u0270\u0273\3\2\2\2\u0271\u026f"+
19011 "\3\2\2\2\u0271\u0272\3\2\2\2\u0272\u0274\3\2\2\2\u0273\u0271\3\2\2\2\u0274"+
19012 "\u0275\7J\2\2\u0275\u0277\7K\2\2\u0276\u0271\3\2\2\2\u0277\u027a\3\2\2"+
19013 "\2\u0278\u0276\3\2\2\2\u0278\u0279\3\2\2\2\u0279!\3\2\2\2\u027a\u0278"+
19014 "\3\2\2\2\u027b\u027d\5$\23\2\u027c\u027b\3\2\2\2\u027d\u0280\3\2\2\2\u027e"+
19015 "\u027c\3\2\2\2\u027e\u027f\3\2\2\2\u027f\u0281\3\2\2\2\u0280\u027e\3\2"+
19016 "\2\2\u0281\u0283\5\u01f4\u00fb\2\u0282\u0284\5&\24\2\u0283\u0282\3\2\2"+
19017 "\2\u0283\u0284\3\2\2\2\u0284#\3\2\2\2\u0285\u0286\5\u00fc\177\2\u0286"+
19018 "%\3\2\2\2\u0287\u0288\7\35\2\2\u0288\u0292\5\34\17\2\u0289\u028a\7\35"+
19019 "\2\2\u028a\u028e\5\16\b\2\u028b\u028d\5(\25\2\u028c\u028b\3\2\2\2\u028d"+
19020 "\u0290\3\2\2\2\u028e\u028c\3\2\2\2\u028e\u028f\3\2\2\2\u028f\u0292\3\2"+
19021 "\2\2\u0290\u028e\3\2\2\2\u0291\u0287\3\2\2\2\u0291\u0289\3\2\2\2\u0292"+
19022 "\'\3\2\2\2\u0293\u0294\7f\2\2\u0294\u0295\5\26\f\2\u0295)\3\2\2\2\u0296"+
19023 "\u0297\7T\2\2\u0297\u0298\5,\27\2\u0298\u0299\7S\2\2\u0299+\3\2\2\2\u029a"+
19024 "\u029f\5.\30\2\u029b\u029c\7M\2\2\u029c\u029e\5.\30\2\u029d\u029b\3\2"+
19025 "\2\2\u029e\u02a1\3\2\2\2\u029f\u029d\3\2\2\2\u029f\u02a0\3\2\2\2\u02a0"+
19026 "-\3\2\2\2\u02a1\u029f\3\2\2\2\u02a2\u02a5\5\f\7\2\u02a3\u02a5\5\60\31"+
19027 "\2\u02a4\u02a2\3\2\2\2\u02a4\u02a3\3\2\2\2\u02a5/\3\2\2\2\u02a6\u02a8"+
19028 "\5\u00fc\177\2\u02a7\u02a6\3\2\2\2\u02a8\u02ab\3\2\2\2\u02a9\u02a7\3\2"+
19029 "\2\2\u02a9\u02aa\3\2\2\2\u02aa\u02ac\3\2\2\2\u02ab\u02a9\3\2\2\2\u02ac"+
19030 "\u02ae\7W\2\2\u02ad\u02af\5\62\32\2\u02ae\u02ad\3\2\2\2\u02ae\u02af\3"+
19031 "\2\2\2\u02af\61\3\2\2\2\u02b0\u02b1\7\35\2\2\u02b1\u02b5\5\f\7\2\u02b2"+
19032 "\u02b3\7\64\2\2\u02b3\u02b5\5\f\7\2\u02b4\u02b0\3\2\2\2\u02b4\u02b2\3"+
19033 "\2\2\2\u02b5\63\3\2\2\2\u02b6\u02b7\b\33\1\2\u02b7\u02b8\5\u01f4\u00fb"+
19034 "\2\u02b8\u02be\3\2\2\2\u02b9\u02ba\f\3\2\2\u02ba\u02bb\7N\2\2\u02bb\u02bd"+
19035 "\5\u01f4\u00fb\2\u02bc\u02b9\3\2\2\2\u02bd\u02c0\3\2\2\2\u02be\u02bc\3"+
19036 "\2\2\2\u02be\u02bf\3\2\2\2\u02bf\65\3\2\2\2\u02c0\u02be\3\2\2\2\u02c1"+
19037 "\u02c2\b\34\1\2\u02c2\u02c3\5\u01f4\u00fb\2\u02c3\u02c9\3\2\2\2\u02c4"+
19038 "\u02c5\f\3\2\2\u02c5\u02c6\7N\2\2\u02c6\u02c8\5\u01f4\u00fb\2\u02c7\u02c4"+
19039 "\3\2\2\2\u02c8\u02cb\3\2\2\2\u02c9\u02c7\3\2\2\2\u02c9\u02ca\3\2\2\2\u02ca"+
19040 "\67\3\2\2\2\u02cb\u02c9\3\2\2\2\u02cc\u02d2\5\u01f4\u00fb\2\u02cd\u02ce"+
19041 "\5:\36\2\u02ce\u02cf\7N\2\2\u02cf\u02d0\5\u01f4\u00fb\2\u02d0\u02d2\3"+
19042 "\2\2\2\u02d1\u02cc\3\2\2\2\u02d1\u02cd\3\2\2\2\u02d29\3\2\2\2\u02d3\u02d4"+
19043 "\b\36\1\2\u02d4\u02d5\5\u01f4\u00fb\2\u02d5\u02db\3\2\2\2\u02d6\u02d7"+
19044 "\f\3\2\2\u02d7\u02d8\7N\2\2\u02d8\u02da\5\u01f4\u00fb\2\u02d9\u02d6\3"+
19045 "\2\2\2\u02da\u02dd\3\2\2\2\u02db\u02d9\3\2\2\2\u02db\u02dc\3\2\2\2\u02dc"+
19046 ";\3\2\2\2\u02dd\u02db\3\2\2\2\u02de\u02e4\5\u01f4\u00fb\2\u02df\u02e0"+
19047 "\5@!\2\u02e0\u02e1\7N\2\2\u02e1\u02e2\5\u01f4\u00fb\2\u02e2\u02e4\3\2"+
19048 "\2\2\u02e3\u02de\3\2\2\2\u02e3\u02df\3\2\2\2\u02e4=\3\2\2\2\u02e5\u02e6"+
19049 "\5\u01f4\u00fb\2\u02e6?\3\2\2\2\u02e7\u02e8\b!\1\2\u02e8\u02e9\5\u01f4"+
19050 "\u00fb\2\u02e9\u02ef\3\2\2\2\u02ea\u02eb\f\3\2\2\u02eb\u02ec\7N\2\2\u02ec"+
19051 "\u02ee\5\u01f4\u00fb\2\u02ed\u02ea\3\2\2\2\u02ee\u02f1\3\2\2\2\u02ef\u02ed"+
19052 "\3\2\2\2\u02ef\u02f0\3\2\2\2\u02f0A\3\2\2\2\u02f1\u02ef\3\2\2\2\u02f2"+
19053 "\u02f5\5D#\2\u02f3\u02f5\5F$\2\u02f4\u02f2\3\2\2\2\u02f4\u02f3\3\2\2\2"+
19054 "\u02f5C\3\2\2\2\u02f6\u02f8\5H%\2\u02f7\u02f6\3\2\2\2\u02f7\u02f8\3\2"+
19055 "\2\2\u02f8\u02fc\3\2\2\2\u02f9\u02fb\5L\'\2\u02fa\u02f9\3\2\2\2\u02fb"+
19056 "\u02fe\3\2\2\2\u02fc\u02fa\3\2\2\2\u02fc\u02fd\3\2\2\2\u02fd\u0302\3\2"+
19057 "\2\2\u02fe\u02fc\3\2\2\2\u02ff\u0301\5V,\2\u0300\u02ff\3\2\2\2\u0301\u0304"+
19058 "\3\2\2\2\u0302\u0300\3\2\2\2\u0302\u0303\3\2\2\2\u0303\u0305\3\2\2\2\u0304"+
19059 "\u0302\3\2\2\2\u0305\u0306\7\2\2\3\u0306E\3\2\2\2\u0307\u0309\5L\'\2\u0308"+
19060 "\u0307\3\2\2\2\u0309\u030c\3\2\2\2\u030a\u0308\3\2\2\2\u030a\u030b\3\2"+
19061 "\2\2\u030b\u030d\3\2\2\2\u030c\u030a\3\2\2\2\u030d\u030e\5X-\2\u030eG"+
19062 "\3\2\2\2\u030f\u0311\5J&\2\u0310\u030f\3\2\2\2\u0311\u0314\3\2\2\2\u0312"+
19063 "\u0310\3\2\2\2\u0312\u0313\3\2\2\2\u0313\u0315\3\2\2\2\u0314\u0312\3\2"+
19064 "\2\2\u0315\u0316\7,\2\2\u0316\u0317\5\66\34\2\u0317\u0318\7L\2\2\u0318"+
19065 "I\3\2\2\2\u0319\u031a\5\u00fc\177\2\u031aK\3\2\2\2\u031b\u0320\5N(\2\u031c"+
19066 "\u0320\5P)\2\u031d\u0320\5R*\2\u031e\u0320\5T+\2\u031f\u031b\3\2\2\2\u031f"+
19067 "\u031c\3\2\2\2\u031f\u031d\3\2\2\2\u031f\u031e\3\2\2\2\u0320M\3\2\2\2"+
19068 "\u0321\u0322\7%\2\2\u0322\u0323\58\35\2\u0323\u0324\7L\2\2\u0324O\3\2"+
19069 "\2\2\u0325\u0326\7%\2\2\u0326\u0327\5:\36\2\u0327\u0328\7N\2\2\u0328\u0329"+
19070 "\7d\2\2\u0329\u032a\7L\2\2\u032aQ\3\2\2\2\u032b\u032c\7%\2\2\u032c\u032d"+
19071 "\7\62\2\2\u032d\u032e\58\35\2\u032e\u032f\7N\2\2\u032f\u0330\5\u01f4\u00fb"+
19072 "\2\u0330\u0331\7L\2\2\u0331S\3\2\2\2\u0332\u0333\7%\2\2\u0333\u0334\7"+
19073 "\62\2\2\u0334\u0335\58\35\2\u0335\u0336\7N\2\2\u0336\u0337\7d\2\2\u0337"+
19074 "\u0338\7L\2\2\u0338U\3\2\2\2\u0339\u033d\5h\65\2\u033a\u033d\5\u00dco"+
19075 "\2\u033b\u033d\7L\2\2\u033c\u0339\3\2\2\2\u033c\u033a\3\2\2\2\u033c\u033b"+
19076 "\3\2\2\2\u033dW\3\2\2\2\u033e\u0340\5\u00fc\177\2\u033f\u033e\3\2\2\2"+
19077 "\u0340\u0343\3\2\2\2\u0341\u033f\3\2\2\2\u0341\u0342\3\2\2\2\u0342\u0345"+
19078 "\3\2\2\2\u0343\u0341\3\2\2\2\u0344\u0346\7\3\2\2\u0345\u0344\3\2\2\2\u0345"+
19079 "\u0346\3\2\2\2\u0346\u0347\3\2\2\2\u0347\u0348\7\4\2\2\u0348\u0349\5\64"+
19080 "\33\2\u0349\u034d\7H\2\2\u034a\u034c\5Z.\2\u034b\u034a\3\2\2\2\u034c\u034f"+
19081 "\3\2\2\2\u034d\u034b\3\2\2\2\u034d\u034e\3\2\2\2\u034e\u0350\3\2\2\2\u034f"+
19082 "\u034d\3\2\2\2\u0350\u0351\7I\2\2\u0351Y\3\2\2\2\u0352\u0358\5\\/\2\u0353"+
19083 "\u0358\5^\60\2\u0354\u0358\5`\61\2\u0355\u0358\5b\62\2\u0356\u0358\5d"+
19084 "\63\2\u0357\u0352\3\2\2\2\u0357\u0353\3\2\2\2\u0357\u0354\3\2\2\2\u0357"+
19085 "\u0355\3\2\2\2\u0357\u0356\3\2\2\2\u0358[\3\2\2\2\u0359\u035d\7\5\2\2"+
19086 "\u035a\u035c\5f\64\2\u035b\u035a\3\2\2\2\u035c\u035f\3\2\2\2\u035d\u035b"+
19087 "\3\2\2\2\u035d\u035e\3\2\2\2\u035e\u0360\3\2\2\2\u035f\u035d\3\2\2\2\u0360"+
19088 "\u0361\5\64\33\2\u0361\u0362\7L\2\2\u0362]\3\2\2\2\u0363\u0364\7\6\2\2"+
19089 "\u0364\u036e\5\66\34\2\u0365\u0366\7\7\2\2\u0366\u036b\5\64\33\2\u0367"+
19090 "\u0368\7M\2\2\u0368\u036a\5\64\33\2\u0369\u0367\3\2\2\2\u036a\u036d\3"+
19091 "\2\2\2\u036b\u0369\3\2\2\2\u036b\u036c\3\2\2\2\u036c\u036f\3\2\2\2\u036d"+
19092 "\u036b\3\2\2\2\u036e\u0365\3\2\2\2\u036e\u036f\3\2\2\2\u036f\u0370\3\2"+
19093 "\2\2\u0370\u0371\7L\2\2\u0371_\3\2\2\2\u0372\u0373\7\b\2\2\u0373\u037d"+
19094 "\5\66\34\2\u0374\u0375\7\7\2\2\u0375\u037a\5\64\33\2\u0376\u0377\7M\2"+
19095 "\2\u0377\u0379\5\64\33\2\u0378\u0376\3\2\2\2\u0379\u037c\3\2\2\2\u037a"+
19096 "\u0378\3\2\2\2\u037a\u037b\3\2\2\2\u037b\u037e\3\2\2\2\u037c\u037a\3\2"+
19097 "\2\2\u037d\u0374\3\2\2\2\u037d\u037e\3\2\2\2\u037e\u037f\3\2\2\2\u037f"+
19098 "\u0380\7L\2\2\u0380a\3\2\2\2\u0381\u0382\7\t\2\2\u0382\u0383\58\35\2\u0383"+
19099 "\u0384\7L\2\2\u0384c\3\2\2\2\u0385\u0386\7\n\2\2\u0386\u0387\58\35\2\u0387"+
19100 "\u0388\7\13\2\2\u0388\u038d\58\35\2\u0389\u038a\7M\2\2\u038a\u038c\58"+
19101 "\35\2\u038b\u0389\3\2\2\2\u038c\u038f\3\2\2\2\u038d\u038b\3\2\2\2\u038d"+
19102 "\u038e\3\2\2\2\u038e\u0390\3\2\2\2\u038f\u038d\3\2\2\2\u0390\u0391\7L"+
19103 "\2\2\u0391e\3\2\2\2\u0392\u0393\t\5\2\2\u0393g\3\2\2\2\u0394\u0397\5j"+
19104 "\66\2\u0395\u0397\5\u00d0i\2\u0396\u0394\3\2\2\2\u0396\u0395\3\2\2\2\u0397"+
19105 "i\3\2\2\2\u0398\u039a\5l\67\2\u0399\u0398\3\2\2\2\u039a\u039d\3\2\2\2"+
19106 "\u039b\u0399\3\2\2\2\u039b\u039c\3\2\2\2\u039c\u039e\3\2\2\2\u039d\u039b"+
19107 "\3\2\2\2\u039e\u039f\7\25\2\2\u039f\u03a1\5\u01f4\u00fb\2\u03a0\u03a2"+
19108 "\5n8\2\u03a1\u03a0\3\2\2\2\u03a1\u03a2\3\2\2\2\u03a2\u03a4\3\2\2\2\u03a3"+
19109 "\u03a5\5r:\2\u03a4\u03a3\3\2\2\2\u03a4\u03a5\3\2\2\2\u03a5\u03a7\3\2\2"+
19110 "\2\u03a6\u03a8\5t;\2\u03a7\u03a6\3\2\2\2\u03a7\u03a8\3\2\2\2\u03a8\u03a9"+
19111 "\3\2\2\2\u03a9\u03aa\5x=\2\u03aak\3\2\2\2\u03ab\u03b4\5\u00fc\177\2\u03ac"+
19112 "\u03b4\7/\2\2\u03ad\u03b4\7.\2\2\u03ae\u03b4\7-\2\2\u03af\u03b4\7\r\2"+
19113 "\2\u03b0\u03b4\7\62\2\2\u03b1\u03b4\7\36\2\2\u03b2\u03b4\7\63\2\2\u03b3"+
19114 "\u03ab\3\2\2\2\u03b3\u03ac\3\2\2\2\u03b3\u03ad\3\2\2\2\u03b3\u03ae\3\2"+
19115 "\2\2\u03b3\u03af\3\2\2\2\u03b3\u03b0\3\2\2\2\u03b3\u03b1\3\2\2\2\u03b3"+
19116 "\u03b2\3\2\2\2\u03b4m\3\2\2\2\u03b5\u03b6\7T\2\2\u03b6\u03b7\5p9\2\u03b7"+
19117 "\u03b8\7S\2\2\u03b8o\3\2\2\2\u03b9\u03be\5\"\22\2\u03ba\u03bb\7M\2\2\u03bb"+
19118 "\u03bd\5\"\22\2\u03bc\u03ba\3\2\2\2\u03bd\u03c0\3\2\2\2\u03be\u03bc\3"+
19119 "\2\2\2\u03be\u03bf\3\2\2\2\u03bfq\3\2\2\2\u03c0\u03be\3\2\2\2\u03c1\u03c2"+
19120 "\7\35\2\2\u03c2\u03c3\5\20\t\2\u03c3s\3\2\2\2\u03c4\u03c5\7$\2\2\u03c5"+
19121 "\u03c6\5v<\2\u03c6u\3\2\2\2\u03c7\u03cc\5\26\f\2\u03c8\u03c9\7M\2\2\u03c9"+
19122 "\u03cb\5\26\f\2\u03ca\u03c8\3\2\2\2\u03cb\u03ce\3\2\2\2\u03cc\u03ca\3"+
19123 "\2\2\2\u03cc\u03cd\3\2\2\2\u03cdw\3\2\2\2\u03ce\u03cc\3\2\2\2\u03cf\u03d3"+
19124 "\7H\2\2\u03d0\u03d2\5z>\2\u03d1\u03d0\3\2\2\2\u03d2\u03d5\3\2\2\2\u03d3"+
19125 "\u03d1\3\2\2\2\u03d3\u03d4\3\2\2\2\u03d4\u03d6\3\2\2\2\u03d5\u03d3\3\2"+
19126 "\2\2\u03d6\u03d7\7I\2\2\u03d7y\3\2\2\2\u03d8\u03dd\5|?\2\u03d9\u03dd\5"+
19127 "\u00c0a\2\u03da\u03dd\5\u00c2b\2\u03db\u03dd\5\u00c4c\2\u03dc\u03d8\3"+
19128 "\2\2\2\u03dc\u03d9\3\2\2\2\u03dc\u03da\3\2\2\2\u03dc\u03db\3\2\2\2\u03dd"+
19129 "{\3\2\2\2\u03de\u03e4\5~@\2\u03df\u03e4\5\u00a2R\2\u03e0\u03e4\5h\65\2"+
19130 "\u03e1\u03e4\5\u00dco\2\u03e2\u03e4\7L\2\2\u03e3\u03de\3\2\2\2\u03e3\u03df"+
19131 "\3\2\2\2\u03e3\u03e0\3\2\2\2\u03e3\u03e1\3\2\2\2\u03e3\u03e2\3\2\2\2\u03e4"+
19132 "}\3\2\2\2\u03e5\u03e7\5\u0080A\2\u03e6\u03e5\3\2\2\2\u03e7\u03ea\3\2\2"+
19133 "\2\u03e8\u03e6\3\2\2\2\u03e8\u03e9\3\2\2\2\u03e9\u03eb\3\2\2\2\u03ea\u03e8"+
19134 "\3\2\2\2\u03eb\u03ec\5\u008aF\2\u03ec\u03ed\5\u0082B\2\u03ed\u03ee\7L"+
19135 "\2\2\u03ee\177\3\2\2\2\u03ef\u03f8\5\u00fc\177\2\u03f0\u03f8\7/\2\2\u03f1"+
19136 "\u03f8\7.\2\2\u03f2\u03f8\7-\2\2\u03f3\u03f8\7\62\2\2\u03f4\u03f8\7\36"+
19137 "\2\2\u03f5\u03f8\7:\2\2\u03f6\u03f8\7=\2\2\u03f7\u03ef\3\2\2\2\u03f7\u03f0"+
19138 "\3\2\2\2\u03f7\u03f1\3\2\2\2\u03f7\u03f2\3\2\2\2\u03f7\u03f3\3\2\2\2\u03f7"+
19139 "\u03f4\3\2\2\2\u03f7\u03f5\3\2\2\2\u03f7\u03f6\3\2\2\2\u03f8\u0081\3\2"+
19140 "\2\2\u03f9\u03fe\5\u0084C\2\u03fa\u03fb\7M\2\2\u03fb\u03fd\5\u0084C\2"+
19141 "\u03fc\u03fa\3\2\2\2\u03fd\u0400\3\2\2\2\u03fe\u03fc\3\2\2\2\u03fe\u03ff"+
19142 "\3\2\2\2\u03ff\u0083\3\2\2\2\u0400\u03fe\3\2\2\2\u0401\u0404\5\u0086D"+
19143 "\2\u0402\u0403\7R\2\2\u0403\u0405\5\u0088E\2\u0404\u0402\3\2\2\2\u0404"+
19144 "\u0405\3\2\2\2\u0405\u0085\3\2\2\2\u0406\u0408\5\u01f4\u00fb\2\u0407\u0409"+
19145 "\5 \21\2\u0408\u0407\3\2\2\2\u0408\u0409\3\2\2\2\u0409\u0087\3\2\2\2\u040a"+
19146 "\u040d\5\u01b8\u00dd\2\u040b\u040d\5\u010e\u0088\2\u040c\u040a\3\2\2\2"+
19147 "\u040c\u040b\3\2\2\2\u040d\u0089\3\2\2\2\u040e\u0411\5\u008cG\2\u040f"+
19148 "\u0411\5\u008eH\2\u0410\u040e\3\2\2\2\u0410\u040f\3\2\2\2\u0411\u008b"+
19149 "\3\2\2\2\u0412\u0415\5\6\4\2\u0413\u0415\7\17\2\2\u0414\u0412\3\2\2\2"+
19150 "\u0414\u0413\3\2\2\2\u0415\u008d\3\2\2\2\u0416\u041a\5\u0090I\2\u0417"+
19151 "\u041a\5\u009eP\2\u0418\u041a\5\u00a0Q\2\u0419\u0416\3\2\2\2\u0419\u0417"+
19152 "\3\2\2\2\u0419\u0418\3\2\2\2\u041a\u008f\3\2\2\2\u041b\u041e\5\u0096L"+
19153 "\2\u041c\u041e\5\u009cO\2\u041d\u041b\3\2\2\2\u041d\u041c\3\2\2\2\u041e"+
19154 "\u0423\3\2\2\2\u041f\u0422\5\u0094K\2\u0420\u0422\5\u009aN\2\u0421\u041f"+
19155 "\3\2\2\2\u0421\u0420\3\2\2\2\u0422\u0425\3\2\2\2\u0423\u0421\3\2\2\2\u0423"+
19156 "\u0424\3\2\2\2\u0424\u0091\3\2\2\2\u0425\u0423\3\2\2\2\u0426\u0428\5\u01f4"+
19157 "\u00fb\2\u0427\u0429\5*\26\2\u0428\u0427\3\2\2\2\u0428\u0429\3\2\2\2\u0429"+
19158 "\u0437\3\2\2\2\u042a\u042b\5\u0090I\2\u042b\u042f\7N\2\2\u042c\u042e\5"+
19159 "\u00fc\177\2\u042d\u042c\3\2\2\2\u042e\u0431\3\2\2\2\u042f\u042d\3\2\2"+
19160 "\2\u042f\u0430\3\2\2\2\u0430\u0432\3\2\2\2\u0431\u042f\3\2\2\2\u0432\u0434"+
19161 "\5\u01f4\u00fb\2\u0433\u0435\5*\26\2\u0434\u0433\3\2\2\2\u0434\u0435\3"+
19162 "\2\2\2\u0435\u0437\3\2\2\2\u0436\u0426\3\2\2\2\u0436\u042a\3\2\2\2\u0437"+
19163 "\u0093\3\2\2\2\u0438\u043c\7N\2\2\u0439\u043b\5\u00fc\177\2\u043a\u0439"+
19164 "\3\2\2\2\u043b\u043e\3\2\2\2\u043c\u043a\3\2\2\2\u043c\u043d\3\2\2\2\u043d"+
19165 "\u043f\3\2\2\2\u043e\u043c\3\2\2\2\u043f\u0441\5\u01f4\u00fb\2\u0440\u0442"+
19166 "\5*\26\2\u0441\u0440\3\2\2\2\u0441\u0442\3\2\2\2\u0442\u0095\3\2\2\2\u0443"+
19167 "\u0445\5\u01f4\u00fb\2\u0444\u0446\5*\26\2\u0445\u0444\3\2\2\2\u0445\u0446"+
19168 "\3\2\2\2\u0446\u0097\3\2\2\2\u0447\u0448\5\u0092J\2\u0448\u0099\3\2\2"+
19169 "\2\u0449\u044a\5\u0094K\2\u044a\u009b\3\2\2\2\u044b\u044c\5\u0096L\2\u044c"+
19170 "\u009d\3\2\2\2\u044d\u044e\5\u01f4\u00fb\2\u044e\u009f\3\2\2\2\u044f\u0450"+
19171 "\5\u008cG\2\u0450\u0451\5 \21\2\u0451\u0459\3\2\2\2\u0452\u0453\5\u0090"+
19172 "I\2\u0453\u0454\5 \21\2\u0454\u0459\3\2\2\2\u0455\u0456\5\u009eP\2\u0456"+
19173 "\u0457\5 \21\2\u0457\u0459\3\2\2\2\u0458\u044f\3\2\2\2\u0458\u0452\3\2"+
19174 "\2\2\u0458\u0455\3\2\2\2\u0459\u00a1\3\2\2\2\u045a\u045c\5\u00a4S\2\u045b"+
19175 "\u045a\3\2\2\2\u045c\u045f\3\2\2\2\u045d\u045b\3\2\2\2\u045d\u045e\3\2"+
19176 "\2\2\u045e\u0460\3\2\2\2\u045f\u045d\3\2\2\2\u0460\u0461\5\u00a6T\2\u0461"+
19177 "\u0462\5\u00be`\2\u0462\u00a3\3\2\2\2\u0463\u046e\5\u00fc\177\2\u0464"+
19178 "\u046e\7/\2\2\u0465\u046e\7.\2\2\u0466\u046e\7-\2\2\u0467\u046e\7\r\2"+
19179 "\2\u0468\u046e\7\62\2\2\u0469\u046e\7\36\2\2\u046a\u046e\7\66\2\2\u046b"+
19180 "\u046e\7*\2\2\u046c\u046e\7\63\2\2\u046d\u0463\3\2\2\2\u046d\u0464\3\2"+
19181 "\2\2\u046d\u0465\3\2\2\2\u046d\u0466\3\2\2\2\u046d\u0467\3\2\2\2\u046d"+
19182 "\u0468\3\2\2\2\u046d\u0469\3\2\2\2\u046d\u046a\3\2\2\2\u046d\u046b\3\2"+
19183 "\2\2\u046d\u046c\3\2\2\2\u046e\u00a5\3\2\2\2\u046f\u0470\5\u00a8U\2\u0470"+
19184 "\u0472\5\u00aaV\2\u0471\u0473\5\u00b8]\2\u0472\u0471\3\2\2\2\u0472\u0473"+
19185 "\3\2\2\2\u0473\u0481\3\2\2\2\u0474\u0478\5n8\2\u0475\u0477\5\u00fc\177"+
19186 "\2\u0476\u0475\3\2\2\2\u0477\u047a\3\2\2\2\u0478\u0476\3\2\2\2\u0478\u0479"+
19187 "\3\2\2\2\u0479\u047b\3\2\2\2\u047a\u0478\3\2\2\2\u047b\u047c\5\u00a8U"+
19188 "\2\u047c\u047e\5\u00aaV\2\u047d\u047f\5\u00b8]\2\u047e\u047d\3\2\2\2\u047e"+
19189 "\u047f\3\2\2\2\u047f\u0481\3\2\2\2\u0480\u046f\3\2\2\2\u0480\u0474\3\2"+
19190 "\2\2\u0481\u00a7\3\2\2\2\u0482\u0485\5\u008aF\2\u0483\u0485\7<\2\2\u0484"+
19191 "\u0482\3\2\2\2\u0484\u0483\3\2\2\2\u0485\u00a9\3\2\2\2\u0486\u0487\5\u01f4"+
19192 "\u00fb\2\u0487\u0489\7F\2\2\u0488\u048a\5\u00acW\2\u0489\u0488\3\2\2\2"+
19193 "\u0489\u048a\3\2\2\2\u048a\u048b\3\2\2\2\u048b\u048d\7G\2\2\u048c\u048e"+
19194 "\5 \21\2\u048d\u048c\3\2\2\2\u048d\u048e\3\2\2\2\u048e\u00ab\3\2\2\2\u048f"+
19195 "\u0490\5\u00aeX\2\u0490\u0491\7M\2\2\u0491\u0492\5\u00b4[\2\u0492\u0496"+
19196 "\3\2\2\2\u0493\u0496\5\u00b4[\2\u0494\u0496\5\u00b6\\\2\u0495\u048f\3"+
19197 "\2\2\2\u0495\u0493\3\2\2\2\u0495\u0494\3\2\2\2\u0496\u00ad\3\2\2\2\u0497"+
19198 "\u049c\5\u00b0Y\2\u0498\u0499\7M\2\2\u0499\u049b\5\u00b0Y\2\u049a\u0498"+
19199 "\3\2\2\2\u049b\u049e\3\2\2\2\u049c\u049a\3\2\2\2\u049c\u049d\3\2\2\2\u049d"+
19200 "\u04a8\3\2\2\2\u049e\u049c\3\2\2\2\u049f\u04a4\5\u00b6\\\2\u04a0\u04a1"+
19201 "\7M\2\2\u04a1\u04a3\5\u00b0Y\2\u04a2\u04a0\3\2\2\2\u04a3\u04a6\3\2\2\2"+
19202 "\u04a4\u04a2\3\2\2\2\u04a4\u04a5\3\2\2\2\u04a5\u04a8\3\2\2\2\u04a6\u04a4"+
19203 "\3\2\2\2\u04a7\u0497\3\2\2\2\u04a7\u049f\3\2\2\2\u04a8\u00af\3\2\2\2\u04a9"+
19204 "\u04ab\5\u00b2Z\2\u04aa\u04a9\3\2\2\2\u04ab\u04ae\3\2\2\2\u04ac\u04aa"+
19205 "\3\2\2\2\u04ac\u04ad\3\2\2\2\u04ad\u04af\3\2\2\2\u04ae\u04ac\3\2\2\2\u04af"+
19206 "\u04b0\5\u008aF\2\u04b0\u04b1\5\u0086D\2\u04b1\u00b1\3\2\2\2\u04b2\u04b5"+
19207 "\5\u00fc\177\2\u04b3\u04b5\7\36\2\2\u04b4\u04b2\3\2\2\2\u04b4\u04b3\3"+
19208 "\2\2\2\u04b5\u00b3\3\2\2\2\u04b6\u04b8\5\u00b2Z\2\u04b7\u04b6\3\2\2\2"+
19209 "\u04b8\u04bb\3\2\2\2\u04b9\u04b7\3\2\2\2\u04b9\u04ba\3\2\2\2\u04ba\u04bc"+
19210 "\3\2\2\2\u04bb\u04b9\3\2\2\2\u04bc\u04c0\5\u008aF\2\u04bd\u04bf\5\u00fc"+
19211 "\177\2\u04be\u04bd\3\2\2\2\u04bf\u04c2\3\2\2\2\u04c0\u04be\3\2\2\2\u04c0"+
19212 "\u04c1\3\2\2\2\u04c1\u04c3\3\2\2\2\u04c2\u04c0\3\2\2\2\u04c3\u04c4\7O"+
19213 "\2\2\u04c4\u04c5\5\u0086D\2\u04c5\u04c8\3\2\2\2\u04c6\u04c8\5\u00b0Y\2"+
19214 "\u04c7\u04b9\3\2\2\2\u04c7\u04c6\3\2\2\2\u04c8\u00b5\3\2\2\2\u04c9\u04cb"+
19215 "\5\u00fc\177\2\u04ca\u04c9\3\2\2\2\u04cb\u04ce\3\2\2\2\u04cc\u04ca\3\2"+
19216 "\2\2\u04cc\u04cd\3\2\2\2\u04cd\u04cf\3\2\2\2\u04ce\u04cc\3\2\2\2\u04cf"+
19217 "\u04d3\5\u008aF\2\u04d0\u04d1\5\u01f4\u00fb\2\u04d1\u04d2\7N\2\2\u04d2"+
19218 "\u04d4\3\2\2\2\u04d3\u04d0\3\2\2\2\u04d3\u04d4\3\2\2\2\u04d4\u04d5\3\2"+
19219 "\2\2\u04d5\u04d6\7\67\2\2\u04d6\u00b7\3\2\2\2\u04d7\u04d8\79\2\2\u04d8"+
19220 "\u04d9\5\u00ba^\2\u04d9\u00b9\3\2\2\2\u04da\u04df\5\u00bc_\2\u04db\u04dc"+
19221 "\7M\2\2\u04dc\u04de\5\u00bc_\2\u04dd\u04db\3\2\2\2\u04de\u04e1\3\2\2\2"+
19222 "\u04df\u04dd\3\2\2\2\u04df\u04e0\3\2\2\2\u04e0\u00bb\3\2\2\2\u04e1\u04df"+
19223 "\3\2\2\2\u04e2\u04e5\5\20\t\2\u04e3\u04e5\5\34\17\2\u04e4\u04e2\3\2\2"+
19224 "\2\u04e4\u04e3\3\2\2\2\u04e5\u00bd\3\2\2\2\u04e6\u04e9\5\u0112\u008a\2"+
19225 "\u04e7\u04e9\7L\2\2\u04e8\u04e6\3\2\2\2\u04e8\u04e7\3\2\2\2\u04e9\u00bf"+
19226 "\3\2\2\2\u04ea\u04eb\5\u0112\u008a\2\u04eb\u00c1\3\2\2\2\u04ec\u04ed\7"+
19227 "\62\2\2\u04ed\u04ee\5\u0112\u008a\2\u04ee\u00c3\3\2\2\2\u04ef\u04f1\5"+
19228 "\u00c6d\2\u04f0\u04ef\3\2\2\2\u04f1\u04f4\3\2\2\2\u04f2\u04f0\3\2\2\2"+
19229 "\u04f2\u04f3\3\2\2\2\u04f3\u04f5\3\2\2\2\u04f4\u04f2\3\2\2\2\u04f5\u04f7"+
19230 "\5\u00c8e\2\u04f6\u04f8\5\u00b8]\2\u04f7\u04f6\3\2\2\2\u04f7\u04f8\3\2"+
19231 "\2\2\u04f8\u04f9\3\2\2\2\u04f9\u04fa\5\u00ccg\2\u04fa\u00c5\3\2\2\2\u04fb"+
19232 "\u0500\5\u00fc\177\2\u04fc\u0500\7/\2\2\u04fd\u0500\7.\2\2\u04fe\u0500"+
19233 "\7-\2\2\u04ff\u04fb\3\2\2\2\u04ff\u04fc\3\2\2\2\u04ff\u04fd\3\2\2\2\u04ff"+
19234 "\u04fe\3\2\2\2\u0500\u00c7\3\2\2\2\u0501\u0503\5n8\2\u0502\u0501\3\2\2"+
19235 "\2\u0502\u0503\3\2\2\2\u0503\u0504\3\2\2\2\u0504\u0505\5\u00caf\2\u0505"+
19236 "\u0507\7F\2\2\u0506\u0508\5\u00acW\2\u0507\u0506\3\2\2\2\u0507\u0508\3"+
19237 "\2\2\2\u0508\u0509\3\2\2\2\u0509\u050a\7G\2\2\u050a\u00c9\3\2\2\2\u050b"+
19238 "\u050c\5\u01f4\u00fb\2\u050c\u00cb\3\2\2\2\u050d\u050f\7H\2\2\u050e\u0510"+
19239 "\5\u00ceh\2\u050f\u050e\3\2\2\2\u050f\u0510\3\2\2\2\u0510\u0512\3\2\2"+
19240 "\2\u0511\u0513\5\u0114\u008b\2\u0512\u0511\3\2\2\2\u0512\u0513\3\2\2\2"+
19241 "\u0513\u0514\3\2\2\2\u0514\u0515\7I\2\2\u0515\u00cd\3\2\2\2\u0516\u0518"+
19242 "\5*\26\2\u0517\u0516\3\2\2\2\u0517\u0518\3\2\2\2\u0518\u0519\3\2\2\2\u0519"+
19243 "\u051a\7\67\2\2\u051a\u051c\7F\2\2\u051b\u051d\5\u01a8\u00d5\2\u051c\u051b"+
19244 "\3\2\2\2\u051c\u051d\3\2\2\2\u051d\u051e\3\2\2\2\u051e\u051f\7G\2\2\u051f"+
19245 "\u0545\7L\2\2\u0520\u0522\5*\26\2\u0521\u0520\3\2\2\2\u0521\u0522\3\2"+
19246 "\2\2\u0522\u0523\3\2\2\2\u0523\u0524\7\64\2\2\u0524\u0526\7F\2\2\u0525"+
19247 "\u0527\5\u01a8\u00d5\2\u0526\u0525\3\2\2\2\u0526\u0527\3\2\2\2\u0527\u0528"+
19248 "\3\2\2\2\u0528\u0529\7G\2\2\u0529\u0545\7L\2\2\u052a\u052b\5<\37\2\u052b"+
19249 "\u052d\7N\2\2\u052c\u052e\5*\26\2\u052d\u052c\3\2\2\2\u052d\u052e\3\2"+
19250 "\2\2\u052e\u052f\3\2\2\2\u052f\u0530\7\64\2\2\u0530\u0532\7F\2\2\u0531"+
19251 "\u0533\5\u01a8\u00d5\2\u0532\u0531\3\2\2\2\u0532\u0533\3\2\2\2\u0533\u0534"+
19252 "\3\2\2\2\u0534\u0535\7G\2\2\u0535\u0536\7L\2\2\u0536\u0545\3\2\2\2\u0537"+
19253 "\u0538\5\u0178\u00bd\2\u0538\u053a\7N\2\2\u0539\u053b\5*\26\2\u053a\u0539"+
19254 "\3\2\2\2\u053a\u053b\3\2\2\2\u053b\u053c\3\2\2\2\u053c\u053d\7\64\2\2"+
19255 "\u053d\u053f\7F\2\2\u053e\u0540\5\u01a8\u00d5\2\u053f\u053e\3\2\2\2\u053f"+
19256 "\u0540\3\2\2\2\u0540\u0541\3\2\2\2\u0541\u0542\7G\2\2\u0542\u0543\7L\2"+
19257 "\2\u0543\u0545\3\2\2\2\u0544\u0517\3\2\2\2\u0544\u0521\3\2\2\2\u0544\u052a"+
19258 "\3\2\2\2\u0544\u0537\3\2\2\2\u0545\u00cf\3\2\2\2\u0546\u0548\5l\67\2\u0547"+
19259 "\u0546\3\2\2\2\u0548\u054b\3\2\2\2\u0549\u0547\3\2\2\2\u0549\u054a\3\2"+
19260 "\2\2\u054a\u054c\3\2\2\2\u054b\u0549\3\2\2\2\u054c\u054d\7\34\2\2\u054d"+
19261 "\u054f\5\u01f4\u00fb\2\u054e\u0550\5t;\2\u054f\u054e\3\2\2\2\u054f\u0550"+
19262 "\3\2\2\2\u0550\u0551\3\2\2\2\u0551\u0552\5\u00d2j\2\u0552\u00d1\3\2\2"+
19263 "\2\u0553\u0555\7H\2\2\u0554\u0556\5\u00d4k\2\u0555\u0554\3\2\2\2\u0555"+
19264 "\u0556\3\2\2\2\u0556\u0558\3\2\2\2\u0557\u0559\7M\2\2\u0558\u0557\3\2"+
19265 "\2\2\u0558\u0559\3\2\2\2\u0559\u055b\3\2\2\2\u055a\u055c\5\u00dan\2\u055b"+
19266 "\u055a\3\2\2\2\u055b\u055c\3\2\2\2\u055c\u055d\3\2\2\2\u055d\u055e\7I"+
19267 "\2\2\u055e\u00d3\3\2\2\2\u055f\u0564\5\u00d6l\2\u0560\u0561\7M\2\2\u0561"+
19268 "\u0563\5\u00d6l\2\u0562\u0560\3\2\2\2\u0563\u0566\3\2\2\2\u0564\u0562"+
19269 "\3\2\2\2\u0564\u0565\3\2\2\2\u0565\u00d5\3\2\2\2\u0566\u0564\3\2\2\2\u0567"+
19270 "\u0569\5\u00d8m\2\u0568\u0567\3\2\2\2\u0569\u056c\3\2\2\2\u056a\u0568"+
19271 "\3\2\2\2\u056a\u056b\3\2\2\2\u056b\u056d\3\2\2\2\u056c\u056a\3\2\2\2\u056d"+
19272 "\u0573\5\u01f4\u00fb\2\u056e\u0570\7F\2\2\u056f\u0571\5\u01a8\u00d5\2"+
19273 "\u0570\u056f\3\2\2\2\u0570\u0571\3\2\2\2\u0571\u0572\3\2\2\2\u0572\u0574"+
19274 "\7G\2\2\u0573\u056e\3\2\2\2\u0573\u0574\3\2\2\2\u0574\u0576\3\2\2\2\u0575"+
19275 "\u0577\5x=\2\u0576\u0575\3\2\2\2\u0576\u0577\3\2\2\2\u0577\u00d7\3\2\2"+
19276 "\2\u0578\u0579\5\u00fc\177\2\u0579\u00d9\3\2\2\2\u057a\u057e\7L\2\2\u057b"+
19277 "\u057d\5z>\2\u057c\u057b\3\2\2\2\u057d\u0580\3\2\2\2\u057e\u057c\3\2\2"+
19278 "\2\u057e\u057f\3\2\2\2\u057f\u00db\3\2\2\2\u0580\u057e\3\2\2\2\u0581\u0584"+
19279 "\5\u00dep\2\u0582\u0584\5\u00f0y\2\u0583\u0581\3\2\2\2\u0583\u0582\3\2"+
19280 "\2\2\u0584\u00dd\3\2\2\2\u0585\u0587\5\u00e0q\2\u0586\u0585\3\2\2\2\u0587"+
19281 "\u058a\3\2\2\2\u0588\u0586\3\2\2\2\u0588\u0589\3\2\2\2\u0589\u058b\3\2"+
19282 "\2\2\u058a\u0588\3\2\2\2\u058b\u058c\7(\2\2\u058c\u058e\5\u01f4\u00fb"+
19283 "\2\u058d\u058f\5n8\2\u058e\u058d\3\2\2\2\u058e\u058f\3\2\2\2\u058f\u0591"+
19284 "\3\2\2\2\u0590\u0592\5\u00e2r\2\u0591\u0590\3\2\2\2\u0591\u0592\3\2\2"+
19285 "\2\u0592\u0593\3\2\2\2\u0593\u0594\5\u00e4s\2\u0594\u00df\3\2\2\2\u0595"+
19286 "\u059d\5\u00fc\177\2\u0596\u059d\7/\2\2\u0597\u059d\7.\2\2\u0598\u059d"+
19287 "\7-\2\2\u0599\u059d\7\r\2\2\u059a\u059d\7\62\2\2\u059b\u059d\7\63\2\2"+
19288 "\u059c\u0595\3\2\2\2\u059c\u0596\3\2\2\2\u059c\u0597\3\2\2\2\u059c\u0598"+
19289 "\3\2\2\2\u059c\u0599\3\2\2\2\u059c\u059a\3\2\2\2\u059c\u059b\3\2\2\2\u059d"+
19290 "\u00e1\3\2\2\2\u059e\u059f\7\35\2\2\u059f\u05a0\5v<\2\u05a0\u00e3\3\2"+
19291 "\2\2\u05a1\u05a5\7H\2\2\u05a2\u05a4\5\u00e6t\2\u05a3\u05a2\3\2\2\2\u05a4"+
19292 "\u05a7\3\2\2\2\u05a5\u05a3\3\2\2\2\u05a5\u05a6\3\2\2\2\u05a6\u05a8\3\2"+
19293 "\2\2\u05a7\u05a5\3\2\2\2\u05a8\u05a9\7I\2\2\u05a9\u00e5\3\2\2\2\u05aa"+
19294 "\u05b0\5\u00e8u\2\u05ab\u05b0\5\u00ecw\2\u05ac\u05b0\5h\65\2\u05ad\u05b0"+
19295 "\5\u00dco\2\u05ae\u05b0\7L\2\2\u05af\u05aa\3\2\2\2\u05af\u05ab\3\2\2\2"+
19296 "\u05af\u05ac\3\2\2\2\u05af\u05ad\3\2\2\2\u05af\u05ae\3\2\2\2\u05b0\u00e7"+
19297 "\3\2\2\2\u05b1\u05b3\5\u00eav\2\u05b2\u05b1\3\2\2\2\u05b3\u05b6\3\2\2"+
19298 "\2\u05b4\u05b2\3\2\2\2\u05b4\u05b5\3\2\2\2\u05b5\u05b7\3\2\2\2\u05b6\u05b4"+
19299 "\3\2\2\2\u05b7\u05b8\5\u008aF\2\u05b8\u05b9\5\u0082B\2\u05b9\u05ba\7L"+
19300 "\2\2\u05ba\u00e9\3\2\2\2\u05bb\u05c0\5\u00fc\177\2\u05bc\u05c0\7/\2\2"+
19301 "\u05bd\u05c0\7\62\2\2\u05be\u05c0\7\36\2\2\u05bf\u05bb\3\2\2\2\u05bf\u05bc"+
19302 "\3\2\2\2\u05bf\u05bd\3\2\2\2\u05bf\u05be\3\2\2\2\u05c0\u00eb\3\2\2\2\u05c1"+
19303 "\u05c3\5\u00eex\2\u05c2\u05c1\3\2\2\2\u05c3\u05c6\3\2\2\2\u05c4\u05c2"+
19304 "\3\2\2\2\u05c4\u05c5\3\2\2\2\u05c5\u05c7\3\2\2\2\u05c6\u05c4\3\2\2\2\u05c7"+
19305 "\u05c8\5\u00a6T\2\u05c8\u05c9\5\u00be`\2\u05c9\u00ed\3\2\2\2\u05ca\u05d2"+
19306 "\5\u00fc\177\2\u05cb\u05d2\7/\2\2\u05cc\u05d2\7-\2\2\u05cd\u05d2\7\r\2"+
19307 "\2\u05ce\u05d2\7\30\2\2\u05cf\u05d2\7\62\2\2\u05d0\u05d2\7\63\2\2\u05d1"+
19308 "\u05ca\3\2\2\2\u05d1\u05cb\3\2\2\2\u05d1\u05cc\3\2\2\2\u05d1\u05cd\3\2"+
19309 "\2\2\u05d1\u05ce\3\2\2\2\u05d1\u05cf\3\2\2\2\u05d1\u05d0\3\2\2\2\u05d2"+
19310 "\u00ef\3\2\2\2\u05d3\u05d5\5\u00e0q\2\u05d4\u05d3\3\2\2\2\u05d5\u05d8"+
19311 "\3\2\2\2\u05d6\u05d4\3\2\2\2\u05d6\u05d7\3\2\2\2\u05d7\u05d9\3\2\2\2\u05d8"+
19312 "\u05d6\3\2\2\2\u05d9\u05da\7P\2\2\u05da\u05db\7(\2\2\u05db\u05dc\5\u01f4"+
19313 "\u00fb\2\u05dc\u05dd\5\u00f2z\2\u05dd\u00f1\3\2\2\2\u05de\u05e2\7H\2\2"+
19314 "\u05df\u05e1\5\u00f4{\2\u05e0\u05df\3\2\2\2\u05e1\u05e4\3\2\2\2\u05e2"+
19315 "\u05e0\3\2\2\2\u05e2\u05e3\3\2\2\2\u05e3\u05e5\3\2\2\2\u05e4\u05e2\3\2"+
19316 "\2\2\u05e5\u05e6\7I\2\2\u05e6\u00f3\3\2\2\2\u05e7\u05ed\5\u00f6|\2\u05e8"+
19317 "\u05ed\5\u00e8u\2\u05e9\u05ed\5h\65\2\u05ea\u05ed\5\u00dco\2\u05eb\u05ed"+
19318 "\7L\2\2\u05ec\u05e7\3\2\2\2\u05ec\u05e8\3\2\2\2\u05ec\u05e9\3\2\2\2\u05ec"+
19319 "\u05ea\3\2\2\2\u05ec\u05eb\3\2\2\2\u05ed\u00f5\3\2\2\2\u05ee\u05f0\5\u00f8"+
19320 "}\2\u05ef\u05ee\3\2\2\2\u05f0\u05f3\3\2\2\2\u05f1\u05ef\3\2\2\2\u05f1"+
19321 "\u05f2\3\2\2\2\u05f2\u05f4\3\2\2\2\u05f3\u05f1\3\2\2\2\u05f4\u05f5\5\u008a"+
19322 "F\2\u05f5\u05f6\5\u01f4\u00fb\2\u05f6\u05f7\7F\2\2\u05f7\u05f9\7G\2\2"+
19323 "\u05f8\u05fa\5 \21\2\u05f9\u05f8\3\2\2\2\u05f9\u05fa\3\2\2\2\u05fa\u05fc"+
19324 "\3\2\2\2\u05fb\u05fd\5\u00fa~\2\u05fc\u05fb\3\2\2\2\u05fc\u05fd\3\2\2"+
19325 "\2\u05fd\u05fe\3\2\2\2\u05fe\u05ff\7L\2\2\u05ff\u00f7\3\2\2\2\u0600\u0604"+
19326 "\5\u00fc\177\2\u0601\u0604\7/\2\2\u0602\u0604\7\r\2\2\u0603\u0600\3\2"+
19327 "\2\2\u0603\u0601\3\2\2\2\u0603\u0602\3\2\2\2\u0604\u00f9\3\2\2\2\u0605"+
19328 "\u0606\7\30\2\2\u0606\u0607\5\u0104\u0083\2\u0607\u00fb\3\2\2\2\u0608"+
19329 "\u060c\5\u00fe\u0080\2\u0609\u060c\5\u010a\u0086\2\u060a\u060c\5\u010c"+
19330 "\u0087\2\u060b\u0608\3\2\2\2\u060b\u0609\3\2\2\2\u060b\u060a\3\2\2\2\u060c"+
19331 "\u00fd\3\2\2\2\u060d\u060e\7P\2\2\u060e\u060f\58\35\2\u060f\u0611\7F\2"+
19332 "\2\u0610\u0612\5\u0100\u0081\2\u0611\u0610\3\2\2\2\u0611\u0612\3\2\2\2"+
19333 "\u0612\u0613\3\2\2\2\u0613\u0614\7G\2\2\u0614\u00ff\3\2\2\2\u0615\u061a"+
19334 "\5\u0102\u0082\2\u0616\u0617\7M\2\2\u0617\u0619\5\u0102\u0082\2\u0618"+
19335 "\u0616\3\2\2\2\u0619\u061c\3\2\2\2\u061a\u0618\3\2\2\2\u061a\u061b\3\2"+
19336 "\2\2\u061b\u0101\3\2\2\2\u061c\u061a\3\2\2\2\u061d\u061e\5\u01f4\u00fb"+
19337 "\2\u061e\u061f\7R\2\2\u061f\u0620\5\u0104\u0083\2\u0620\u0103\3\2\2\2"+
19338 "\u0621\u0625\5\u01ca\u00e6\2\u0622\u0625\5\u0106\u0084\2\u0623\u0625\5"+
19339 "\u00fc\177\2\u0624\u0621\3\2\2\2\u0624\u0622\3\2\2\2\u0624\u0623\3\2\2"+
19340 "\2\u0625\u0105\3\2\2\2\u0626\u0628\7H\2\2\u0627\u0629\5\u0108\u0085\2"+
19341 "\u0628\u0627\3\2\2\2\u0628\u0629\3\2\2\2\u0629\u062b\3\2\2\2\u062a\u062c"+
19342 "\7M\2\2\u062b\u062a\3\2\2\2\u062b\u062c\3\2\2\2\u062c\u062d\3\2\2\2\u062d"+
19343 "\u062e\7I\2\2\u062e\u0107\3\2\2\2\u062f\u0634\5\u0104\u0083\2\u0630\u0631"+
19344 "\7M\2\2\u0631\u0633\5\u0104\u0083\2\u0632\u0630\3\2\2\2\u0633\u0636\3"+
19345 "\2\2\2\u0634\u0632\3\2\2\2\u0634\u0635\3\2\2\2\u0635\u0109\3\2\2\2\u0636"+
19346 "\u0634\3\2\2\2\u0637\u0638\7P\2\2\u0638\u0639\58\35\2\u0639\u010b\3\2"+
19347 "\2\2\u063a\u063b\7P\2\2\u063b\u063c\58\35\2\u063c\u063d\7F\2\2\u063d\u063e"+
19348 "\5\u0104\u0083\2\u063e\u063f\7G\2\2\u063f\u010d\3\2\2\2\u0640\u0642\7"+
19349 "H\2\2\u0641\u0643\5\u0110\u0089\2\u0642\u0641\3\2\2\2\u0642\u0643\3\2"+
19350 "\2\2\u0643\u0645\3\2\2\2\u0644\u0646\7M\2\2\u0645\u0644\3\2\2\2\u0645"+
19351 "\u0646\3\2\2\2\u0646\u0647\3\2\2\2\u0647\u0648\7I\2\2\u0648\u010f\3\2"+
19352 "\2\2\u0649\u064e\5\u0088E\2\u064a\u064b\7M\2\2\u064b\u064d\5\u0088E\2"+
19353 "\u064c\u064a\3\2\2\2\u064d\u0650\3\2\2\2\u064e\u064c\3\2\2\2\u064e\u064f"+
19354 "\3\2\2\2\u064f\u0111\3\2\2\2\u0650\u064e\3\2\2\2\u0651\u0653\7H\2\2\u0652"+
19355 "\u0654\5\u0114\u008b\2\u0653\u0652\3\2\2\2\u0653\u0654\3\2\2\2\u0654\u0655"+
19356 "\3\2\2\2\u0655\u0656\7I\2\2\u0656\u0113\3\2\2\2\u0657\u0659\5\u0116\u008c"+
19357 "\2\u0658\u0657\3\2\2\2\u0659\u065a\3\2\2\2\u065a\u0658\3\2\2\2\u065a\u065b"+
19358 "\3\2\2\2\u065b\u0115\3\2\2\2\u065c\u0660\5\u0118\u008d\2\u065d\u0660\5"+
19359 "h\65\2\u065e\u0660\5\u011c\u008f\2\u065f\u065c\3\2\2\2\u065f\u065d\3\2"+
19360 "\2\2\u065f\u065e\3\2\2\2\u0660\u0117\3\2\2\2\u0661\u0662\5\u011a\u008e"+
19361 "\2\u0662\u0663\7L\2\2\u0663\u0119\3\2\2\2\u0664\u0666\5\u00b2Z\2\u0665"+
19362 "\u0664\3\2\2\2\u0666\u0669\3\2\2\2\u0667\u0665\3\2\2\2\u0667\u0668\3\2"+
19363 "\2\2\u0668\u066a\3\2\2\2\u0669\u0667\3\2\2\2\u066a\u066b\5\u008aF\2\u066b"+
19364 "\u066c\5\u0082B\2\u066c\u011b\3\2\2\2\u066d\u0674\5\u0120\u0091\2\u066e"+
19365 "\u0674\5\u0124\u0093\2\u066f\u0674\5\u012c\u0097\2\u0670\u0674\5\u012e"+
19366 "\u0098\2\u0671\u0674\5\u0140\u00a1\2\u0672\u0674\5\u0146\u00a4\2\u0673"+
19367 "\u066d\3\2\2\2\u0673\u066e\3\2\2\2\u0673\u066f\3\2\2\2\u0673\u0670\3\2"+
19368 "\2\2\u0673\u0671\3\2\2\2\u0673\u0672\3\2\2\2\u0674\u011d\3\2\2\2\u0675"+
19369 "\u067b\5\u0120\u0091\2\u0676\u067b\5\u0126\u0094\2\u0677\u067b\5\u0130"+
19370 "\u0099\2\u0678\u067b\5\u0142\u00a2\2\u0679\u067b\5\u0148\u00a5\2\u067a"+
19371 "\u0675\3\2\2\2\u067a\u0676\3\2\2\2\u067a\u0677\3\2\2\2\u067a\u0678\3\2"+
19372 "\2\2\u067a\u0679\3\2\2\2\u067b\u011f\3\2\2\2\u067c\u0689\5\u0112\u008a"+
19373 "\2\u067d\u0689\5\u0122\u0092\2\u067e\u0689\5\u0128\u0095\2\u067f\u0689"+
19374 "\5\u0132\u009a\2\u0680\u0689\5\u0134\u009b\2\u0681\u0689\5\u0144\u00a3"+
19375 "\2\u0682\u0689\5\u0158\u00ad\2\u0683\u0689\5\u015a\u00ae\2\u0684\u0689"+
19376 "\5\u015c\u00af\2\u0685\u0689\5\u0160\u00b1\2\u0686\u0689\5\u015e\u00b0"+
19377 "\2\u0687\u0689\5\u0162\u00b2\2\u0688\u067c\3\2\2\2\u0688\u067d\3\2\2\2"+
19378 "\u0688\u067e\3\2\2\2\u0688\u067f\3\2\2\2\u0688\u0680\3\2\2\2\u0688\u0681"+
19379 "\3\2\2\2\u0688\u0682\3\2\2\2\u0688\u0683\3\2\2\2\u0688\u0684\3\2\2\2\u0688"+
19380 "\u0685\3\2\2\2\u0688\u0686\3\2\2\2\u0688\u0687\3\2\2\2\u0689\u0121\3\2"+
19381 "\2\2\u068a\u068b\7L\2\2\u068b\u0123\3\2\2\2\u068c\u068d\5\u01f4\u00fb"+
19382 "\2\u068d\u068e\7X\2\2\u068e\u068f\5\u011c\u008f\2\u068f\u0125\3\2\2\2"+
19383 "\u0690\u0691\5\u01f4\u00fb\2\u0691\u0692\7X\2\2\u0692\u0693\5\u011e\u0090"+
19384 "\2\u0693\u0127\3\2\2\2\u0694\u0695\5\u012a\u0096\2\u0695\u0696\7L\2\2"+
19385 "\u0696\u0129\3\2\2\2\u0697\u069f\5\u01c4\u00e3\2\u0698\u069f\5\u01e2\u00f2"+
19386 "\2\u0699\u069f\5\u01e4\u00f3\2\u069a\u069f\5\u01ea\u00f6\2\u069b\u069f"+
19387 "\5\u01ee\u00f8\2\u069c\u069f\5\u01a2\u00d2\2\u069d\u069f\5\u018e\u00c8"+
19388 "\2\u069e\u0697\3\2\2\2\u069e\u0698\3\2\2\2\u069e\u0699\3\2\2\2\u069e\u069a"+
19389 "\3\2\2\2\u069e\u069b\3\2\2\2\u069e\u069c\3\2\2\2\u069e\u069d\3\2\2\2\u069f"+
19390 "\u012b\3\2\2\2\u06a0\u06a1\7\"\2\2\u06a1\u06a2\7F\2\2\u06a2\u06a3\5\u01b8"+
19391 "\u00dd\2\u06a3\u06a4\7G\2\2\u06a4\u06a5\5\u011c\u008f\2\u06a5\u012d\3"+
19392 "\2\2\2\u06a6\u06a7\7\"\2\2\u06a7\u06a8\7F\2\2\u06a8\u06a9\5\u01b8\u00dd"+
19393 "\2\u06a9\u06aa\7G\2\2\u06aa\u06ab\5\u011e\u0090\2\u06ab\u06ac\7\33\2\2"+
19394 "\u06ac\u06ad\5\u011c\u008f\2\u06ad\u012f\3\2\2\2\u06ae\u06af\7\"\2\2\u06af"+
19395 "\u06b0\7F\2\2\u06b0\u06b1\5\u01b8\u00dd\2\u06b1\u06b2\7G\2\2\u06b2\u06b3"+
19396 "\5\u011e\u0090\2\u06b3\u06b4\7\33\2\2\u06b4\u06b5\5\u011e\u0090\2\u06b5"+
19397 "\u0131\3\2\2\2\u06b6\u06b7\7\16\2\2\u06b7\u06b8\5\u01b8\u00dd\2\u06b8"+
19398 "\u06b9\7L\2\2\u06b9\u06c1\3\2\2\2\u06ba\u06bb\7\16\2\2\u06bb\u06bc\5\u01b8"+
19399 "\u00dd\2\u06bc\u06bd\7X\2\2\u06bd\u06be\5\u01b8\u00dd\2\u06be\u06bf\7"+
19400 "L\2\2\u06bf\u06c1\3\2\2\2\u06c0\u06b6\3\2\2\2\u06c0\u06ba\3\2\2\2\u06c1"+
19401 "\u0133\3\2\2\2\u06c2\u06c3\7\65\2\2\u06c3\u06c4\7F\2\2\u06c4\u06c5\5\u01b8"+
19402 "\u00dd\2\u06c5\u06c6\7G\2\2\u06c6\u06c7\5\u0136\u009c\2\u06c7\u0135\3"+
19403 "\2\2\2\u06c8\u06cc\7H\2\2\u06c9\u06cb\5\u0138\u009d\2\u06ca\u06c9\3\2"+
19404 "\2\2\u06cb\u06ce\3\2\2\2\u06cc\u06ca\3\2\2\2\u06cc\u06cd\3\2\2\2\u06cd"+
19405 "\u06d2\3\2\2\2\u06ce\u06cc\3\2\2\2\u06cf\u06d1\5\u013c\u009f\2\u06d0\u06cf"+
19406 "\3\2\2\2\u06d1\u06d4\3\2\2\2\u06d2\u06d0\3\2\2\2\u06d2\u06d3\3\2\2\2\u06d3"+
19407 "\u06d5\3\2\2\2\u06d4\u06d2\3\2\2\2\u06d5\u06d6\7I\2\2\u06d6\u0137\3\2"+
19408 "\2\2\u06d7\u06d8\5\u013a\u009e\2\u06d8\u06d9\5\u0114\u008b\2\u06d9\u0139"+
19409 "\3\2\2\2\u06da\u06dc\5\u013c\u009f\2\u06db\u06da\3\2\2\2\u06dc\u06dd\3"+
19410 "\2\2\2\u06dd\u06db\3\2\2\2\u06dd\u06de\3\2\2\2\u06de\u013b\3\2\2\2\u06df"+
19411 "\u06e0\7\22\2\2\u06e0\u06e1\5\u01b6\u00dc\2\u06e1\u06e2\7X\2\2\u06e2\u06ea"+
19412 "\3\2\2\2\u06e3\u06e4\7\22\2\2\u06e4\u06e5\5\u013e\u00a0\2\u06e5\u06e6"+
19413 "\7X\2\2\u06e6\u06ea\3\2\2\2\u06e7\u06e8\7\30\2\2\u06e8\u06ea\7X\2\2\u06e9"+
19414 "\u06df\3\2\2\2\u06e9\u06e3\3\2\2\2\u06e9\u06e7\3\2\2\2\u06ea\u013d\3\2"+
19415 "\2\2\u06eb\u06ec\5\u01f4\u00fb\2\u06ec\u013f\3\2\2\2\u06ed\u06ee\7>\2"+
19416 "\2\u06ee\u06ef\7F\2\2\u06ef\u06f0\5\u01b8\u00dd\2\u06f0\u06f1\7G\2\2\u06f1"+
19417 "\u06f2\5\u011c\u008f\2\u06f2\u0141\3\2\2\2\u06f3\u06f4\7>\2\2\u06f4\u06f5"+
19418 "\7F\2\2\u06f5\u06f6\5\u01b8\u00dd\2\u06f6\u06f7\7G\2\2\u06f7\u06f8\5\u011e"+
19419 "\u0090\2\u06f8\u0143\3\2\2\2\u06f9\u06fa\7\31\2\2\u06fa\u06fb\5\u011c"+
19420 "\u008f\2\u06fb\u06fc\7>\2\2\u06fc\u06fd\7F\2\2\u06fd\u06fe\5\u01b8\u00dd"+
19421 "\2\u06fe\u06ff\7G\2\2\u06ff\u0700\7L\2\2\u0700\u0145\3\2\2\2\u0701\u0704"+
19422 "\5\u014a\u00a6\2\u0702\u0704\5\u0154\u00ab\2\u0703\u0701\3\2\2\2\u0703"+
19423 "\u0702\3\2\2\2\u0704\u0147\3\2\2\2\u0705\u0708\5\u014c\u00a7\2\u0706\u0708"+
19424 "\5\u0156\u00ac\2\u0707\u0705\3\2\2\2\u0707\u0706\3\2\2\2\u0708\u0149\3"+
19425 "\2\2\2\u0709\u070a\7!\2\2\u070a\u070c\7F\2\2\u070b\u070d\5\u014e\u00a8"+
19426 "\2\u070c\u070b\3\2\2\2\u070c\u070d\3\2\2\2\u070d\u070e\3\2\2\2\u070e\u0710"+
19427 "\7L\2\2\u070f\u0711\5\u01b8\u00dd\2\u0710\u070f\3\2\2\2\u0710\u0711\3"+
19428 "\2\2\2\u0711\u0712\3\2\2\2\u0712\u0714\7L\2\2\u0713\u0715\5\u0150\u00a9"+
19429 "\2\u0714\u0713\3\2\2\2\u0714\u0715\3\2\2\2\u0715\u0716\3\2\2\2\u0716\u0717"+
19430 "\7G\2\2\u0717\u0718\5\u011c\u008f\2\u0718\u014b\3\2\2\2\u0719\u071a\7"+
19431 "!\2\2\u071a\u071c\7F\2\2\u071b\u071d\5\u014e\u00a8\2\u071c\u071b\3\2\2"+
19432 "\2\u071c\u071d\3\2\2\2\u071d\u071e\3\2\2\2\u071e\u0720\7L\2\2\u071f\u0721"+
19433 "\5\u01b8\u00dd\2\u0720\u071f\3\2\2\2\u0720\u0721\3\2\2\2\u0721\u0722\3"+
19434 "\2\2\2\u0722\u0724\7L\2\2\u0723\u0725\5\u0150\u00a9\2\u0724\u0723\3\2"+
19435 "\2\2\u0724\u0725\3\2\2\2\u0725\u0726\3\2\2\2\u0726\u0727\7G\2\2\u0727"+
19436 "\u0728\5\u011e\u0090\2\u0728\u014d\3\2\2\2\u0729\u072c\5\u0152\u00aa\2"+
19437 "\u072a\u072c\5\u011a\u008e\2\u072b\u0729\3\2\2\2\u072b\u072a\3\2\2\2\u072c"+
19438 "\u014f\3\2\2\2\u072d\u072e\5\u0152\u00aa\2\u072e\u0151\3\2\2\2\u072f\u0734"+
19439 "\5\u012a\u0096\2\u0730\u0731\7M\2\2\u0731\u0733\5\u012a\u0096\2\u0732"+
19440 "\u0730\3\2\2\2\u0733\u0736\3\2\2\2\u0734\u0732\3\2\2\2\u0734\u0735\3\2"+
19441 "\2\2\u0735\u0153\3\2\2\2\u0736\u0734\3\2\2\2\u0737\u0738\7!\2\2\u0738"+
19442 "\u073c\7F\2\2\u0739\u073b\5\u00b2Z\2\u073a\u0739\3\2\2\2\u073b\u073e\3"+
19443 "\2\2\2\u073c\u073a\3\2\2\2\u073c\u073d\3\2\2\2\u073d\u073f\3\2\2\2\u073e"+
19444 "\u073c\3\2\2\2\u073f\u0740\5\u008aF\2\u0740\u0741\5\u0086D\2\u0741\u0742"+
19445 "\7X\2\2\u0742\u0743\5\u01b8\u00dd\2\u0743\u0744\7G\2\2\u0744\u0745\5\u011c"+
19446 "\u008f\2\u0745\u0155\3\2\2\2\u0746\u0747\7!\2\2\u0747\u074b\7F\2\2\u0748"+
19447 "\u074a\5\u00b2Z\2\u0749\u0748\3\2\2\2\u074a\u074d\3\2\2\2\u074b\u0749"+
19448 "\3\2\2\2\u074b\u074c\3\2\2\2\u074c\u074e\3\2\2\2\u074d\u074b\3\2\2\2\u074e"+
19449 "\u074f\5\u008aF\2\u074f\u0750\5\u0086D\2\u0750\u0751\7X\2\2\u0751\u0752"+
19450 "\5\u01b8\u00dd\2\u0752\u0753\7G\2\2\u0753\u0754\5\u011e\u0090\2\u0754"+
19451 "\u0157\3\2\2\2\u0755\u0757\7\20\2\2\u0756\u0758\5\u01f4\u00fb\2\u0757"+
19452 "\u0756\3\2\2\2\u0757\u0758\3\2\2\2\u0758\u0759\3\2\2\2\u0759\u075a\7L"+
19453 "\2\2\u075a\u0159\3\2\2\2\u075b\u075d\7\27\2\2\u075c\u075e\5\u01f4\u00fb"+
19454 "\2\u075d\u075c\3\2\2\2\u075d\u075e\3\2\2\2\u075e\u075f\3\2\2\2\u075f\u0760"+
19455 "\7L\2\2\u0760\u015b\3\2\2\2\u0761\u0763\7\60\2\2\u0762\u0764\5\u01b8\u00dd"+
19456 "\2\u0763\u0762\3\2\2\2\u0763\u0764\3\2\2\2\u0764\u0765\3\2\2\2\u0765\u0766"+
19457 "\7L\2\2\u0766\u015d\3\2\2\2\u0767\u0768\78\2\2\u0768\u0769\5\u01b8\u00dd"+
19458 "\2\u0769\u076a\7L\2\2\u076a\u015f\3\2\2\2\u076b\u076c\7\66\2\2\u076c\u076d"+
19459 "\7F\2\2\u076d\u076e\5\u01b8\u00dd\2\u076e\u076f\7G\2\2\u076f\u0770\5\u0112"+
19460 "\u008a\2\u0770\u0161\3\2\2\2\u0771\u0772\7;\2\2\u0772\u0773\5\u0112\u008a"+
19461 "\2\u0773\u0774\5\u0164\u00b3\2\u0774\u077e\3\2\2\2\u0775\u0776\7;\2\2"+
19462 "\u0776\u0778\5\u0112\u008a\2\u0777\u0779\5\u0164\u00b3\2\u0778\u0777\3"+
19463 "\2\2\2\u0778\u0779\3\2\2\2\u0779\u077a\3\2\2\2\u077a\u077b\5\u016c\u00b7"+
19464 "\2\u077b\u077e\3\2\2\2\u077c\u077e\5\u016e\u00b8\2\u077d\u0771\3\2\2\2"+
19465 "\u077d\u0775\3\2\2\2\u077d\u077c\3\2\2\2\u077e\u0163\3\2\2\2\u077f\u0781"+
19466 "\5\u0166\u00b4\2\u0780\u077f\3\2\2\2\u0781\u0782\3\2\2\2\u0782\u0780\3"+
19467 "\2\2\2\u0782\u0783\3\2\2\2\u0783\u0165\3\2\2\2\u0784\u0785\7\23\2\2\u0785"+
19468 "\u0786\7F\2\2\u0786\u0787\5\u0168\u00b5\2\u0787\u0788\7G\2\2\u0788\u0789"+
19469 "\5\u0112\u008a\2\u0789\u0167\3\2\2\2\u078a\u078c\5\u00b2Z\2\u078b\u078a"+
19470 "\3\2\2\2\u078c\u078f\3\2\2\2\u078d\u078b\3\2\2\2\u078d\u078e\3\2\2\2\u078e"+
19471 "\u0790\3\2\2\2\u078f\u078d\3\2\2\2\u0790\u0791\5\u016a\u00b6\2\u0791\u0792"+
19472 "\5\u0086D\2\u0792\u0169\3\2\2\2\u0793\u0798\5\u0092J\2\u0794\u0795\7g"+
19473 "\2\2\u0795\u0797\5\20\t\2\u0796\u0794\3\2\2\2\u0797\u079a\3\2\2\2\u0798"+
19474 "\u0796\3\2\2\2\u0798\u0799\3\2\2\2\u0799\u016b\3\2\2\2\u079a\u0798\3\2"+
19475 "\2\2\u079b\u079c\7\37\2\2\u079c\u079d\5\u0112\u008a\2\u079d\u016d\3\2"+
19476 "\2\2\u079e\u079f\7;\2\2\u079f\u07a0\5\u0170\u00b9\2\u07a0\u07a2\5\u0112"+
19477 "\u008a\2\u07a1\u07a3\5\u0164\u00b3\2\u07a2\u07a1\3\2\2\2\u07a2\u07a3\3"+
19478 "\2\2\2\u07a3\u07a5\3\2\2\2\u07a4\u07a6\5\u016c\u00b7\2\u07a5\u07a4\3\2"+
19479 "\2\2\u07a5\u07a6\3\2\2\2\u07a6\u016f\3\2\2\2\u07a7\u07a8\7F\2\2\u07a8"+
19480 "\u07aa\5\u0172\u00ba\2\u07a9\u07ab\7L\2\2\u07aa\u07a9\3\2\2\2\u07aa\u07ab"+
19481 "\3\2\2\2\u07ab\u07ac\3\2\2\2\u07ac\u07ad\7G\2\2\u07ad\u0171\3\2\2\2\u07ae"+
19482 "\u07b3\5\u0174\u00bb\2\u07af\u07b0\7L\2\2\u07b0\u07b2\5\u0174\u00bb\2"+
19483 "\u07b1\u07af\3\2\2\2\u07b2\u07b5\3\2\2\2\u07b3\u07b1\3\2\2\2\u07b3\u07b4"+
19484 "\3\2\2\2\u07b4\u0173\3\2\2\2\u07b5\u07b3\3\2\2\2\u07b6\u07b8\5\u00b2Z"+
19485 "\2\u07b7\u07b6\3\2\2\2\u07b8\u07bb\3\2\2\2\u07b9\u07b7\3\2\2\2\u07b9\u07ba"+
19486 "\3\2\2\2\u07ba\u07bc\3\2\2\2\u07bb\u07b9\3\2\2\2\u07bc\u07bd\5\u008aF"+
19487 "\2\u07bd\u07be\5\u0086D\2\u07be\u07bf\7R\2\2\u07bf\u07c0\5\u01b8\u00dd"+
19488 "\2\u07c0\u07c3\3\2\2\2\u07c1\u07c3\5\u0176\u00bc\2\u07c2\u07b9\3\2\2\2"+
19489 "\u07c2\u07c1\3\2\2\2\u07c3\u0175\3\2\2\2\u07c4\u07c7\5<\37\2\u07c5\u07c7"+
19490 "\5\u0196\u00cc\2\u07c6\u07c4\3\2\2\2\u07c6\u07c5\3\2\2\2\u07c7\u0177\3"+
19491 "\2\2\2\u07c8\u07cb\5\u0186\u00c4\2\u07c9\u07cb\5\u01b0\u00d9\2\u07ca\u07c8"+
19492 "\3\2\2\2\u07ca\u07c9\3\2\2\2\u07cb\u07cf\3\2\2\2\u07cc\u07ce\5\u0180\u00c1"+
19493 "\2\u07cd\u07cc\3\2\2\2\u07ce\u07d1\3\2\2\2\u07cf\u07cd\3\2\2\2\u07cf\u07d0"+
19494 "\3\2\2\2\u07d0\u0179\3\2\2\2\u07d1\u07cf\3\2\2\2\u07d2\u07e3\5\2\2\2\u07d3"+
19495 "\u07e3\5\u018c\u00c7\2\u07d4\u07e3\7\67\2\2\u07d5\u07d6\58\35\2\u07d6"+
19496 "\u07d7\7N\2\2\u07d7\u07d8\7\67\2\2\u07d8\u07e3\3\2\2\2\u07d9\u07da\7F"+
19497 "\2\2\u07da\u07db\5\u01b8\u00dd\2\u07db\u07dc\7G\2\2\u07dc\u07e3\3\2\2"+
19498 "\2\u07dd\u07e3\5\u018e\u00c8\2\u07de\u07e3\5\u0196\u00cc\2\u07df\u07e3"+
19499 "\5\u019c\u00cf\2\u07e0\u07e3\5\u01a2\u00d2\2\u07e1\u07e3\5\u01aa\u00d6"+
19500 "\2\u07e2\u07d2\3\2\2\2\u07e2\u07d3\3\2\2\2\u07e2\u07d4\3\2\2\2\u07e2\u07d5"+
19501 "\3\2\2\2\u07e2\u07d9\3\2\2\2\u07e2\u07dd\3\2\2\2\u07e2\u07de\3\2\2\2\u07e2"+
19502 "\u07df\3\2\2\2\u07e2\u07e0\3\2\2\2\u07e2\u07e1\3\2\2\2\u07e3\u017b\3\2"+
19503 "\2\2\u07e4\u07e5\3\2\2\2\u07e5\u017d\3\2\2\2\u07e6\u0803\5\2\2\2\u07e7"+
19504 "\u07ec\58\35\2\u07e8\u07e9\7J\2\2\u07e9\u07eb\7K\2\2\u07ea\u07e8\3\2\2"+
19505 "\2\u07eb\u07ee\3\2\2\2\u07ec\u07ea\3\2\2\2\u07ec\u07ed\3\2\2\2\u07ed\u07ef"+
19506 "\3\2\2\2\u07ee\u07ec\3\2\2\2\u07ef\u07f0\7N\2\2\u07f0\u07f1\7\25\2\2\u07f1"+
19507 "\u0803\3\2\2\2\u07f2\u07f3\7<\2\2\u07f3\u07f4\7N\2\2\u07f4\u0803\7\25"+
19508 "\2\2\u07f5\u0803\7\67\2\2\u07f6\u07f7\58\35\2\u07f7\u07f8\7N\2\2\u07f8"+
19509 "\u07f9\7\67\2\2\u07f9\u0803\3\2\2\2\u07fa\u07fb\7F\2\2\u07fb\u07fc\5\u01b8"+
19510 "\u00dd\2\u07fc\u07fd\7G\2\2\u07fd\u0803\3\2\2\2\u07fe\u0803\5\u018e\u00c8"+
19511 "\2\u07ff\u0803\5\u0196\u00cc\2\u0800\u0803\5\u01a2\u00d2\2\u0801\u0803"+
19512 "\5\u01aa\u00d6\2\u0802\u07e6\3\2\2\2\u0802\u07e7\3\2\2\2\u0802\u07f2\3"+
19513 "\2\2\2\u0802\u07f5\3\2\2\2\u0802\u07f6\3\2\2\2\u0802\u07fa\3\2\2\2\u0802"+
19514 "\u07fe\3\2\2\2\u0802\u07ff\3\2\2\2\u0802\u0800\3\2\2\2\u0802\u0801\3\2"+
19515 "\2\2\u0803\u017f\3\2\2\2\u0804\u080a\5\u0190\u00c9\2\u0805\u080a\5\u0198"+
19516 "\u00cd\2\u0806\u080a\5\u019e\u00d0\2\u0807\u080a\5\u01a4\u00d3\2\u0808"+
19517 "\u080a\5\u01ac\u00d7\2\u0809\u0804\3\2\2\2\u0809\u0805\3\2\2\2\u0809\u0806"+
19518 "\3\2\2\2\u0809\u0807\3\2\2\2\u0809\u0808\3\2\2\2\u080a\u0181\3\2\2\2\u080b"+
19519 "\u080c\3\2\2\2\u080c\u0183\3\2\2\2\u080d\u0812\5\u0190\u00c9\2\u080e\u0812"+
19520 "\5\u0198\u00cd\2\u080f\u0812\5\u01a4\u00d3\2\u0810\u0812\5\u01ac\u00d7"+
19521 "\2\u0811\u080d\3\2\2\2\u0811\u080e\3\2\2\2\u0811\u080f\3\2\2\2\u0811\u0810"+
19522 "\3\2\2\2\u0812\u0185\3\2\2\2\u0813\u083c\5\2\2\2\u0814\u0819\58\35\2\u0815"+
19523 "\u0816\7J\2\2\u0816\u0818\7K\2\2\u0817\u0815\3\2\2\2\u0818\u081b\3\2\2"+
19524 "\2\u0819\u0817\3\2\2\2\u0819\u081a\3\2\2\2\u081a\u081c\3\2\2\2\u081b\u0819"+
19525 "\3\2\2\2\u081c\u081d\7N\2\2\u081d\u081e\7\25\2\2\u081e\u083c\3\2\2\2\u081f"+
19526 "\u0824\5\u008cG\2\u0820\u0821\7J\2\2\u0821\u0823\7K\2\2\u0822\u0820\3"+
19527 "\2\2\2\u0823\u0826\3\2\2\2\u0824\u0822\3\2\2\2\u0824\u0825\3\2\2\2\u0825"+
19528 "\u0827\3\2\2\2\u0826\u0824\3\2\2\2\u0827\u0828\7N\2\2\u0828\u0829\7\25"+
19529 "\2\2\u0829\u083c\3\2\2\2\u082a\u082b\7<\2\2\u082b\u082c\7N\2\2\u082c\u083c"+
19530 "\7\25\2\2\u082d\u083c\7\67\2\2\u082e\u082f\58\35\2\u082f\u0830\7N\2\2"+
19531 "\u0830\u0831\7\67\2\2\u0831\u083c\3\2\2\2\u0832\u0833\7F\2\2\u0833\u0834"+
19532 "\5\u01b8\u00dd\2\u0834\u0835\7G\2\2\u0835\u083c\3\2\2\2\u0836\u083c\5"+
19533 "\u0192\u00ca\2\u0837\u083c\5\u019a\u00ce\2\u0838\u083c\5\u01a0\u00d1\2"+
19534 "\u0839\u083c\5\u01a6\u00d4\2\u083a\u083c\5\u01ae\u00d8\2\u083b\u0813\3"+
19535 "\2\2\2\u083b\u0814\3\2\2\2\u083b\u081f\3\2\2\2\u083b\u082a\3\2\2\2\u083b"+
19536 "\u082d\3\2\2\2\u083b\u082e\3\2\2\2\u083b\u0832\3\2\2\2\u083b\u0836\3\2"+
19537 "\2\2\u083b\u0837\3\2\2\2\u083b\u0838\3\2\2\2\u083b\u0839\3\2\2\2\u083b"+
19538 "\u083a\3\2\2\2\u083c\u0187\3\2\2\2\u083d\u083e\3\2\2\2\u083e\u0189\3\2"+
19539 "\2\2\u083f\u0867\5\2\2\2\u0840\u0845\58\35\2\u0841\u0842\7J\2\2\u0842"+
19540 "\u0844\7K\2\2\u0843\u0841\3\2\2\2\u0844\u0847\3\2\2\2\u0845\u0843\3\2"+
19541 "\2\2\u0845\u0846\3\2\2\2\u0846\u0848\3\2\2\2\u0847\u0845\3\2\2\2\u0848"+
19542 "\u0849\7N\2\2\u0849\u084a\7\25\2\2\u084a\u0867\3\2\2\2\u084b\u0850\5\u008c"+
19543 "G\2\u084c\u084d\7J\2\2\u084d\u084f\7K\2\2\u084e\u084c\3\2\2\2\u084f\u0852"+
19544 "\3\2\2\2\u0850\u084e\3\2\2\2\u0850\u0851\3\2\2\2\u0851\u0853\3\2\2\2\u0852"+
19545 "\u0850\3\2\2\2\u0853\u0854\7N\2\2\u0854\u0855\7\25\2\2\u0855\u0867\3\2"+
19546 "\2\2\u0856\u0857\7<\2\2\u0857\u0858\7N\2\2\u0858\u0867\7\25\2\2\u0859"+
19547 "\u0867\7\67\2\2\u085a\u085b\58\35\2\u085b\u085c\7N\2\2\u085c\u085d\7\67"+
19548 "\2\2\u085d\u0867\3\2\2\2\u085e\u085f\7F\2\2\u085f\u0860\5\u01b8\u00dd"+
19549 "\2\u0860\u0861\7G\2\2\u0861\u0867\3\2\2\2\u0862\u0867\5\u0192\u00ca\2"+
19550 "\u0863\u0867\5\u019a\u00ce\2\u0864\u0867\5\u01a6\u00d4\2\u0865\u0867\5"+
19551 "\u01ae\u00d8\2\u0866\u083f\3\2\2\2\u0866\u0840\3\2\2\2\u0866\u084b\3\2"+
19552 "\2\2\u0866\u0856\3\2\2\2\u0866\u0859\3\2\2\2\u0866\u085a\3\2\2\2\u0866"+
19553 "\u085e\3\2\2\2\u0866\u0862\3\2\2\2\u0866\u0863\3\2\2\2\u0866\u0864\3\2"+
19554 "\2\2\u0866\u0865\3\2\2\2\u0867\u018b\3\2\2\2\u0868\u086c\58\35\2\u0869"+
19555 "\u086c\5\6\4\2\u086a\u086c\7\17\2\2\u086b\u0868\3\2\2\2\u086b\u0869\3"+
19556 "\2\2\2\u086b\u086a\3\2\2\2\u086c\u0871\3\2\2\2\u086d\u086e\7J\2\2\u086e"+
19557 "\u0870\7K\2\2\u086f\u086d\3\2\2\2\u0870\u0873\3\2\2\2\u0871\u086f\3\2"+
19558 "\2\2\u0871\u0872\3\2\2\2\u0872\u0874\3\2\2\2\u0873\u0871\3\2\2\2\u0874"+
19559 "\u0875\7N\2\2\u0875\u087a\7\25\2\2\u0876\u0877\7<\2\2\u0877\u0878\7N\2"+
19560 "\2\u0878\u087a\7\25\2\2\u0879\u086b\3\2\2\2\u0879\u0876\3\2\2\2\u087a"+
19561 "\u018d\3\2\2\2\u087b\u087d\7+\2\2\u087c\u087e\5*\26\2\u087d\u087c\3\2"+
19562 "\2\2\u087d\u087e\3\2\2\2\u087e\u0882\3\2\2\2\u087f\u0881\5\u00fc\177\2"+
19563 "\u0880\u087f\3\2\2\2\u0881\u0884\3\2\2\2\u0882\u0880\3\2\2\2\u0882\u0883"+
19564 "\3\2\2\2\u0883\u0885\3\2\2\2\u0884\u0882\3\2\2\2\u0885\u0890\5\u01f4\u00fb"+
19565 "\2\u0886\u088a\7N\2\2\u0887\u0889\5\u00fc\177\2\u0888\u0887\3\2\2\2\u0889"+
19566 "\u088c\3\2\2\2\u088a\u0888\3\2\2\2\u088a\u088b\3\2\2\2\u088b\u088d\3\2"+
19567 "\2\2\u088c\u088a\3\2\2\2\u088d\u088f\5\u01f4\u00fb\2\u088e\u0886\3\2\2"+
19568 "\2\u088f\u0892\3\2\2\2\u0890\u088e\3\2\2\2\u0890\u0891\3\2\2\2\u0891\u0894"+
19569 "\3\2\2\2\u0892\u0890\3\2\2\2\u0893\u0895\5\u0194\u00cb\2\u0894\u0893\3"+
19570 "\2\2\2\u0894\u0895\3\2\2\2\u0895\u0896\3\2\2\2\u0896\u0898\7F\2\2\u0897"+
19571 "\u0899\5\u01a8\u00d5\2\u0898\u0897\3\2\2\2\u0898\u0899\3\2\2\2\u0899\u089a"+
19572 "\3\2\2\2\u089a\u089c\7G\2\2\u089b\u089d\5x=\2\u089c\u089b\3\2\2\2\u089c"+
19573 "\u089d\3\2\2\2\u089d\u08cf\3\2\2\2\u089e\u089f\5<\37\2\u089f\u08a0\7N"+
19574 "\2\2\u08a0\u08a2\7+\2\2\u08a1\u08a3\5*\26\2\u08a2\u08a1\3\2\2\2\u08a2"+
19575 "\u08a3\3\2\2\2\u08a3\u08a7\3\2\2\2\u08a4\u08a6\5\u00fc\177\2\u08a5\u08a4"+
19576 "\3\2\2\2\u08a6\u08a9\3\2\2\2\u08a7\u08a5\3\2\2\2\u08a7\u08a8\3\2\2\2\u08a8"+
19577 "\u08aa\3\2\2\2\u08a9\u08a7\3\2\2\2\u08aa\u08ac\5\u01f4\u00fb\2\u08ab\u08ad"+
19578 "\5\u0194\u00cb\2\u08ac\u08ab\3\2\2\2\u08ac\u08ad\3\2\2\2\u08ad\u08ae\3"+
19579 "\2\2\2\u08ae\u08b0\7F\2\2\u08af\u08b1\5\u01a8\u00d5\2\u08b0\u08af\3\2"+
19580 "\2\2\u08b0\u08b1\3\2\2\2\u08b1\u08b2\3\2\2\2\u08b2\u08b4\7G\2\2\u08b3"+
19581 "\u08b5\5x=\2\u08b4\u08b3\3\2\2\2\u08b4\u08b5\3\2\2\2\u08b5\u08cf\3\2\2"+
19582 "\2\u08b6\u08b7\5\u0178\u00bd\2\u08b7\u08b8\7N\2\2\u08b8\u08ba\7+\2\2\u08b9"+
19583 "\u08bb\5*\26\2\u08ba\u08b9\3\2\2\2\u08ba\u08bb\3\2\2\2\u08bb\u08bf\3\2"+
19584 "\2\2\u08bc\u08be\5\u00fc\177\2\u08bd\u08bc\3\2\2\2\u08be\u08c1\3\2\2\2"+
19585 "\u08bf\u08bd\3\2\2\2\u08bf\u08c0\3\2\2\2\u08c0\u08c2\3\2\2\2\u08c1\u08bf"+
19586 "\3\2\2\2\u08c2\u08c4\5\u01f4\u00fb\2\u08c3\u08c5\5\u0194\u00cb\2\u08c4"+
19587 "\u08c3\3\2\2\2\u08c4\u08c5\3\2\2\2\u08c5\u08c6\3\2\2\2\u08c6\u08c8\7F"+
19588 "\2\2\u08c7\u08c9\5\u01a8\u00d5\2\u08c8\u08c7\3\2\2\2\u08c8\u08c9\3\2\2"+
19589 "\2\u08c9\u08ca\3\2\2\2\u08ca\u08cc\7G\2\2\u08cb\u08cd\5x=\2\u08cc\u08cb"+
19590 "\3\2\2\2\u08cc\u08cd\3\2\2\2\u08cd\u08cf\3\2\2\2\u08ce\u087b\3\2\2\2\u08ce"+
19591 "\u089e\3\2\2\2\u08ce\u08b6\3\2\2\2\u08cf\u018f\3\2\2\2\u08d0\u08d1\7N"+
19592 "\2\2\u08d1\u08d3\7+\2\2\u08d2\u08d4\5*\26\2\u08d3\u08d2\3\2\2\2\u08d3"+
19593 "\u08d4\3\2\2\2\u08d4\u08d8\3\2\2\2\u08d5\u08d7\5\u00fc\177\2\u08d6\u08d5"+
19594 "\3\2\2\2\u08d7\u08da\3\2\2\2\u08d8\u08d6\3\2\2\2\u08d8\u08d9\3\2\2\2\u08d9"+
19595 "\u08db\3\2\2\2\u08da\u08d8\3\2\2\2\u08db\u08dd\5\u01f4\u00fb\2\u08dc\u08de"+
19596 "\5\u0194\u00cb\2\u08dd\u08dc\3\2\2\2\u08dd\u08de\3\2\2\2\u08de\u08df\3"+
19597 "\2\2\2\u08df\u08e1\7F\2\2\u08e0\u08e2\5\u01a8\u00d5\2\u08e1\u08e0\3\2"+
19598 "\2\2\u08e1\u08e2\3\2\2\2\u08e2\u08e3\3\2\2\2\u08e3\u08e5\7G\2\2\u08e4"+
19599 "\u08e6\5x=\2\u08e5\u08e4\3\2\2\2\u08e5\u08e6\3\2\2\2\u08e6\u0191\3\2\2"+
19600 "\2\u08e7\u08e9\7+\2\2\u08e8\u08ea\5*\26\2\u08e9\u08e8\3\2\2\2\u08e9\u08ea"+
19601 "\3\2\2\2\u08ea\u08ee\3\2\2\2\u08eb\u08ed\5\u00fc\177\2\u08ec\u08eb\3\2"+
19602 "\2\2\u08ed\u08f0\3\2\2\2\u08ee\u08ec\3\2\2\2\u08ee\u08ef\3\2\2\2\u08ef"+
19603 "\u08f1\3\2\2\2\u08f0\u08ee\3\2\2\2\u08f1\u08fc\5\u01f4\u00fb\2\u08f2\u08f6"+
19604 "\7N\2\2\u08f3\u08f5\5\u00fc\177\2\u08f4\u08f3\3\2\2\2\u08f5\u08f8\3\2"+
19605 "\2\2\u08f6\u08f4\3\2\2\2\u08f6\u08f7\3\2\2\2\u08f7\u08f9\3\2\2\2\u08f8"+
19606 "\u08f6\3\2\2\2\u08f9\u08fb\5\u01f4\u00fb\2\u08fa\u08f2\3\2\2\2\u08fb\u08fe"+
19607 "\3\2\2\2\u08fc\u08fa\3\2\2\2\u08fc\u08fd\3\2\2\2\u08fd\u0900\3\2\2\2\u08fe"+
19608 "\u08fc\3\2\2\2\u08ff\u0901\5\u0194\u00cb\2\u0900\u08ff\3\2\2\2\u0900\u0901"+
19609 "\3\2\2\2\u0901\u0902\3\2\2\2\u0902\u0904\7F\2\2\u0903\u0905\5\u01a8\u00d5"+
19610 "\2\u0904\u0903\3\2\2\2\u0904\u0905\3\2\2\2\u0905\u0906\3\2\2\2\u0906\u0908"+
19611 "\7G\2\2\u0907\u0909\5x=\2\u0908\u0907\3\2\2\2\u0908\u0909\3\2\2\2\u0909"+
19612 "\u0923\3\2\2\2\u090a\u090b\5<\37\2\u090b\u090c\7N\2\2\u090c\u090e\7+\2"+
19613 "\2\u090d\u090f\5*\26\2\u090e\u090d\3\2\2\2\u090e\u090f\3\2\2\2\u090f\u0913"+
19614 "\3\2\2\2\u0910\u0912\5\u00fc\177\2\u0911\u0910\3\2\2\2\u0912\u0915\3\2"+
19615 "\2\2\u0913\u0911\3\2\2\2\u0913\u0914\3\2\2\2\u0914\u0916\3\2\2\2\u0915"+
19616 "\u0913\3\2\2\2\u0916\u0918\5\u01f4\u00fb\2\u0917\u0919\5\u0194\u00cb\2"+
19617 "\u0918\u0917\3\2\2\2\u0918\u0919\3\2\2\2\u0919\u091a\3\2\2\2\u091a\u091c"+
19618 "\7F\2\2\u091b\u091d\5\u01a8\u00d5\2\u091c\u091b\3\2\2\2\u091c\u091d\3"+
19619 "\2\2\2\u091d\u091e\3\2\2\2\u091e\u0920\7G\2\2\u091f\u0921\5x=\2\u0920"+
19620 "\u091f\3\2\2\2\u0920\u0921\3\2\2\2\u0921\u0923\3\2\2\2\u0922\u08e7\3\2"+
19621 "\2\2\u0922\u090a\3\2\2\2\u0923\u0193\3\2\2\2\u0924\u0928\5*\26\2\u0925"+
19622 "\u0926\7T\2\2\u0926\u0928\7S\2\2\u0927\u0924\3\2\2\2\u0927\u0925\3\2\2"+
19623 "\2\u0928\u0195\3\2\2\2\u0929\u092a\5\u0178\u00bd\2\u092a\u092b\7N\2\2"+
19624 "\u092b\u092c\5\u01f4\u00fb\2\u092c\u0937\3\2\2\2\u092d\u092e\7\64\2\2"+
19625 "\u092e\u092f\7N\2\2\u092f\u0937\5\u01f4\u00fb\2\u0930\u0931\58\35\2\u0931"+
19626 "\u0932\7N\2\2\u0932\u0933\7\64\2\2\u0933\u0934\7N\2\2\u0934\u0935\5\u01f4"+
19627 "\u00fb\2\u0935\u0937\3\2\2\2\u0936\u0929\3\2\2\2\u0936\u092d\3\2\2\2\u0936"+
19628 "\u0930\3\2\2\2\u0937\u0197\3\2\2\2\u0938\u0939\7N\2\2\u0939\u093a\5\u01f4"+
19629 "\u00fb\2\u093a\u0199\3\2\2\2\u093b\u093c\7\64\2\2\u093c\u093d\7N\2\2\u093d"+
19630 "\u0945\5\u01f4\u00fb\2\u093e\u093f\58\35\2\u093f\u0940\7N\2\2\u0940\u0941"+
19631 "\7\64\2\2\u0941\u0942\7N\2\2\u0942\u0943\5\u01f4\u00fb\2\u0943\u0945\3"+
19632 "\2\2\2\u0944\u093b\3\2\2\2\u0944\u093e\3\2\2\2\u0945\u019b\3\2\2\2\u0946"+
19633 "\u0947\5<\37\2\u0947\u0948\7J\2\2\u0948\u0949\5\u01b8\u00dd\2\u0949\u094a"+
19634 "\7K\2\2\u094a\u0951";
19635 private static final String _serializedATNSegment1 =
19636 "\3\2\2\2\u094b\u094c\5\u017e\u00c0\2\u094c\u094d\7J\2\2\u094d\u094e\5"+
19637 "\u01b8\u00dd\2\u094e\u094f\7K\2\2\u094f\u0951\3\2\2\2\u0950\u0946\3\2"+
19638 "\2\2\u0950\u094b\3\2\2\2\u0951\u0959\3\2\2\2\u0952\u0953\5\u017c\u00bf"+
19639 "\2\u0953\u0954\7J\2\2\u0954\u0955\5\u01b8\u00dd\2\u0955\u0956\7K\2\2\u0956"+
19640 "\u0958\3\2\2\2\u0957\u0952\3\2\2\2\u0958\u095b\3\2\2\2\u0959\u0957\3\2"+
19641 "\2\2\u0959\u095a\3\2\2\2\u095a\u019d\3\2\2\2\u095b\u0959\3\2\2\2\u095c"+
19642 "\u095d\5\u0184\u00c3\2\u095d\u095e\7J\2\2\u095e\u095f\5\u01b8\u00dd\2"+
19643 "\u095f\u0960\7K\2\2\u0960\u0968\3\2\2\2\u0961\u0962\5\u0182\u00c2\2\u0962"+
19644 "\u0963\7J\2\2\u0963\u0964\5\u01b8\u00dd\2\u0964\u0965\7K\2\2\u0965\u0967"+
19645 "\3\2\2\2\u0966\u0961\3\2\2\2\u0967\u096a\3\2\2\2\u0968\u0966\3\2\2\2\u0968"+
19646 "\u0969\3\2\2\2\u0969\u019f\3\2\2\2\u096a\u0968\3\2\2\2\u096b\u096c\5<"+
19647 "\37\2\u096c\u096d\7J\2\2\u096d\u096e\5\u01b8\u00dd\2\u096e\u096f\7K\2"+
19648 "\2\u096f\u0976\3\2\2\2\u0970\u0971\5\u018a\u00c6\2\u0971\u0972\7J\2\2"+
19649 "\u0972\u0973\5\u01b8\u00dd\2\u0973\u0974\7K\2\2\u0974\u0976\3\2\2\2\u0975"+
19650 "\u096b\3\2\2\2\u0975\u0970\3\2\2\2\u0976\u097e\3\2\2\2\u0977\u0978\5\u0188"+
19651 "\u00c5\2\u0978\u0979\7J\2\2\u0979\u097a\5\u01b8\u00dd\2\u097a\u097b\7"+
19652 "K\2\2\u097b\u097d\3\2\2\2\u097c\u0977\3\2\2\2\u097d\u0980\3\2\2\2\u097e"+
19653 "\u097c\3\2\2\2\u097e\u097f\3\2\2\2\u097f\u01a1\3\2\2\2\u0980\u097e\3\2"+
19654 "\2\2\u0981\u0982\5> \2\u0982\u0984\7F\2\2\u0983\u0985\5\u01a8\u00d5\2"+
19655 "\u0984\u0983\3\2\2\2\u0984\u0985\3\2\2\2\u0985\u0986\3\2\2\2\u0986\u0987"+
19656 "\7G\2\2\u0987\u09c7\3\2\2\2\u0988\u0989\58\35\2\u0989\u098b\7N\2\2\u098a"+
19657 "\u098c\5*\26\2\u098b\u098a\3\2\2\2\u098b\u098c\3\2\2\2\u098c\u098d\3\2"+
19658 "\2\2\u098d\u098e\5\u01f4\u00fb\2\u098e\u0990\7F\2\2\u098f\u0991\5\u01a8"+
19659 "\u00d5\2\u0990\u098f\3\2\2\2\u0990\u0991\3\2\2\2\u0991\u0992\3\2\2\2\u0992"+
19660 "\u0993\7G\2\2\u0993\u09c7\3\2\2\2\u0994\u0995\5<\37\2\u0995\u0997\7N\2"+
19661 "\2\u0996\u0998\5*\26\2\u0997\u0996\3\2\2\2\u0997\u0998\3\2\2\2\u0998\u0999"+
19662 "\3\2\2\2\u0999\u099a\5\u01f4\u00fb\2\u099a\u099c\7F\2\2\u099b\u099d\5"+
19663 "\u01a8\u00d5\2\u099c\u099b\3\2\2\2\u099c\u099d\3\2\2\2\u099d\u099e\3\2"+
19664 "\2\2\u099e\u099f\7G\2\2\u099f\u09c7\3\2\2\2\u09a0\u09a1\5\u0178\u00bd"+
19665 "\2\u09a1\u09a3\7N\2\2\u09a2\u09a4\5*\26\2\u09a3\u09a2\3\2\2\2\u09a3\u09a4"+
19666 "\3\2\2\2\u09a4\u09a5\3\2\2\2\u09a5\u09a6\5\u01f4\u00fb\2\u09a6\u09a8\7"+
19667 "F\2\2\u09a7\u09a9\5\u01a8\u00d5\2\u09a8\u09a7\3\2\2\2\u09a8\u09a9\3\2"+
19668 "\2\2\u09a9\u09aa\3\2\2\2\u09aa\u09ab\7G\2\2\u09ab\u09c7\3\2\2\2\u09ac"+
19669 "\u09ad\7\64\2\2\u09ad\u09af\7N\2\2\u09ae\u09b0\5*\26\2\u09af\u09ae\3\2"+
19670 "\2\2\u09af\u09b0\3\2\2\2\u09b0\u09b1\3\2\2\2\u09b1\u09b2\5\u01f4\u00fb"+
19671 "\2\u09b2\u09b4\7F\2\2\u09b3\u09b5\5\u01a8\u00d5\2\u09b4\u09b3\3\2\2\2"+
19672 "\u09b4\u09b5\3\2\2\2\u09b5\u09b6\3\2\2\2\u09b6\u09b7\7G\2\2\u09b7\u09c7"+
19673 "\3\2\2\2\u09b8\u09b9\58\35\2\u09b9\u09ba\7N\2\2\u09ba\u09bb\7\64\2\2\u09bb"+
19674 "\u09bd\7N\2\2\u09bc\u09be\5*\26\2\u09bd\u09bc\3\2\2\2\u09bd\u09be\3\2"+
19675 "\2\2\u09be\u09bf\3\2\2\2\u09bf\u09c0\5\u01f4\u00fb\2\u09c0\u09c2\7F\2"+
19676 "\2\u09c1\u09c3\5\u01a8\u00d5\2\u09c2\u09c1\3\2\2\2\u09c2\u09c3\3\2\2\2"+
19677 "\u09c3\u09c4\3\2\2\2\u09c4\u09c5\7G\2\2\u09c5\u09c7\3\2\2\2\u09c6\u0981"+
19678 "\3\2\2\2\u09c6\u0988\3\2\2\2\u09c6\u0994\3\2\2\2\u09c6\u09a0\3\2\2\2\u09c6"+
19679 "\u09ac\3\2\2\2\u09c6\u09b8\3\2\2\2\u09c7\u01a3\3\2\2\2\u09c8\u09ca\7N"+
19680 "\2\2\u09c9\u09cb\5*\26\2\u09ca\u09c9\3\2\2\2\u09ca\u09cb\3\2\2\2\u09cb"+
19681 "\u09cc\3\2\2\2\u09cc\u09cd\5\u01f4\u00fb\2\u09cd\u09cf\7F\2\2\u09ce\u09d0"+
19682 "\5\u01a8\u00d5\2\u09cf\u09ce\3\2\2\2\u09cf\u09d0\3\2\2\2\u09d0\u09d1\3"+
19683 "\2\2\2\u09d1\u09d2\7G\2\2\u09d2\u01a5\3\2\2\2\u09d3\u09d4\5> \2\u09d4"+
19684 "\u09d6\7F\2\2\u09d5\u09d7\5\u01a8\u00d5\2\u09d6\u09d5\3\2\2\2\u09d6\u09d7"+
19685 "\3\2\2\2\u09d7\u09d8\3\2\2\2\u09d8\u09d9\7G\2\2\u09d9\u0a0d\3\2\2\2\u09da"+
19686 "\u09db\58\35\2\u09db\u09dd\7N\2\2\u09dc\u09de\5*\26\2\u09dd\u09dc\3\2"+
19687 "\2\2\u09dd\u09de\3\2\2\2\u09de\u09df\3\2\2\2\u09df\u09e0\5\u01f4\u00fb"+
19688 "\2\u09e0\u09e2\7F\2\2\u09e1\u09e3\5\u01a8\u00d5\2\u09e2\u09e1\3\2\2\2"+
19689 "\u09e2\u09e3\3\2\2\2\u09e3\u09e4\3\2\2\2\u09e4\u09e5\7G\2\2\u09e5\u0a0d"+
19690 "\3\2\2\2\u09e6\u09e7\5<\37\2\u09e7\u09e9\7N\2\2\u09e8\u09ea\5*\26\2\u09e9"+
19691 "\u09e8\3\2\2\2\u09e9\u09ea\3\2\2\2\u09ea\u09eb\3\2\2\2\u09eb\u09ec\5\u01f4"+
19692 "\u00fb\2\u09ec\u09ee\7F\2\2\u09ed\u09ef\5\u01a8\u00d5\2\u09ee\u09ed\3"+
19693 "\2\2\2\u09ee\u09ef\3\2\2\2\u09ef\u09f0\3\2\2\2\u09f0\u09f1\7G\2\2\u09f1"+
19694 "\u0a0d\3\2\2\2\u09f2\u09f3\7\64\2\2\u09f3\u09f5\7N\2\2\u09f4\u09f6\5*"+
19695 "\26\2\u09f5\u09f4\3\2\2\2\u09f5\u09f6\3\2\2\2\u09f6\u09f7\3\2\2\2\u09f7"+
19696 "\u09f8\5\u01f4\u00fb\2\u09f8\u09fa\7F\2\2\u09f9\u09fb\5\u01a8\u00d5\2"+
19697 "\u09fa\u09f9\3\2\2\2\u09fa\u09fb\3\2\2\2\u09fb\u09fc\3\2\2\2\u09fc\u09fd"+
19698 "\7G\2\2\u09fd\u0a0d\3\2\2\2\u09fe\u09ff\58\35\2\u09ff\u0a00\7N\2\2\u0a00"+
19699 "\u0a01\7\64\2\2\u0a01\u0a03\7N\2\2\u0a02\u0a04\5*\26\2\u0a03\u0a02\3\2"+
19700 "\2\2\u0a03\u0a04\3\2\2\2\u0a04\u0a05\3\2\2\2\u0a05\u0a06\5\u01f4\u00fb"+
19701 "\2\u0a06\u0a08\7F\2\2\u0a07\u0a09\5\u01a8\u00d5\2\u0a08\u0a07\3\2\2\2"+
19702 "\u0a08\u0a09\3\2\2\2\u0a09\u0a0a\3\2\2\2\u0a0a\u0a0b\7G\2\2\u0a0b\u0a0d"+
19703 "\3\2\2\2\u0a0c\u09d3\3\2\2\2\u0a0c\u09da\3\2\2\2\u0a0c\u09e6\3\2\2\2\u0a0c"+
19704 "\u09f2\3\2\2\2\u0a0c\u09fe\3\2\2\2\u0a0d\u01a7\3\2\2\2\u0a0e\u0a13\5\u01b8"+
19705 "\u00dd\2\u0a0f\u0a10\7M\2\2\u0a10\u0a12\5\u01b8\u00dd\2\u0a11\u0a0f\3"+
19706 "\2\2\2\u0a12\u0a15\3\2\2\2\u0a13\u0a11\3\2\2\2\u0a13\u0a14\3\2\2\2\u0a14"+
19707 "\u01a9\3\2\2\2\u0a15\u0a13\3\2\2\2\u0a16\u0a17\5<\37\2\u0a17\u0a19\7Q"+
19708 "\2\2\u0a18\u0a1a\5*\26\2\u0a19\u0a18\3\2\2\2\u0a19\u0a1a\3\2\2\2\u0a1a"+
19709 "\u0a1b\3\2\2\2\u0a1b\u0a1c\5\u01f4\u00fb\2\u0a1c\u0a46\3\2\2\2\u0a1d\u0a1e"+
19710 "\5\f\7\2\u0a1e\u0a20\7Q\2\2\u0a1f\u0a21\5*\26\2\u0a20\u0a1f\3\2\2\2\u0a20"+
19711 "\u0a21\3\2\2\2\u0a21\u0a22\3\2\2\2\u0a22\u0a23\5\u01f4\u00fb\2\u0a23\u0a46"+
19712 "\3\2\2\2\u0a24\u0a25\5\u0178\u00bd\2\u0a25\u0a27\7Q\2\2\u0a26\u0a28\5"+
19713 "*\26\2\u0a27\u0a26\3\2\2\2\u0a27\u0a28\3\2\2\2\u0a28\u0a29\3\2\2\2\u0a29"+
19714 "\u0a2a\5\u01f4\u00fb\2\u0a2a\u0a46\3\2\2\2\u0a2b\u0a2c\7\64\2\2\u0a2c"+
19715 "\u0a2e\7Q\2\2\u0a2d\u0a2f\5*\26\2\u0a2e\u0a2d\3\2\2\2\u0a2e\u0a2f\3\2"+
19716 "\2\2\u0a2f\u0a30\3\2\2\2\u0a30\u0a46\5\u01f4\u00fb\2\u0a31\u0a32\58\35"+
19717 "\2\u0a32\u0a33\7N\2\2\u0a33\u0a34\7\64\2\2\u0a34\u0a36\7Q\2\2\u0a35\u0a37"+
19718 "\5*\26\2\u0a36\u0a35\3\2\2\2\u0a36\u0a37\3\2\2\2\u0a37\u0a38\3\2\2\2\u0a38"+
19719 "\u0a39\5\u01f4\u00fb\2\u0a39\u0a46\3\2\2\2\u0a3a\u0a3b\5\20\t\2\u0a3b"+
19720 "\u0a3d\7Q\2\2\u0a3c\u0a3e\5*\26\2\u0a3d\u0a3c\3\2\2\2\u0a3d\u0a3e\3\2"+
19721 "\2\2\u0a3e\u0a3f\3\2\2\2\u0a3f\u0a40\7+\2\2\u0a40\u0a46\3\2\2\2\u0a41"+
19722 "\u0a42\5\36\20\2\u0a42\u0a43\7Q\2\2\u0a43\u0a44\7+\2\2\u0a44\u0a46\3\2"+
19723 "\2\2\u0a45\u0a16\3\2\2\2\u0a45\u0a1d\3\2\2\2\u0a45\u0a24\3\2\2\2\u0a45"+
19724 "\u0a2b\3\2\2\2\u0a45\u0a31\3\2\2\2\u0a45\u0a3a\3\2\2\2\u0a45\u0a41\3\2"+
19725 "\2\2\u0a46\u01ab\3\2\2\2\u0a47\u0a49\7Q\2\2\u0a48\u0a4a\5*\26\2\u0a49"+
19726 "\u0a48\3\2\2\2\u0a49\u0a4a\3\2\2\2\u0a4a\u0a4b\3\2\2\2\u0a4b\u0a4c\5\u01f4"+
19727 "\u00fb\2\u0a4c\u01ad\3\2\2\2\u0a4d\u0a4e\5<\37\2\u0a4e\u0a50\7Q\2\2\u0a4f"+
19728 "\u0a51\5*\26\2\u0a50\u0a4f\3\2\2\2\u0a50\u0a51\3\2\2\2\u0a51\u0a52\3\2"+
19729 "\2\2\u0a52\u0a53\5\u01f4\u00fb\2\u0a53\u0a76\3\2\2\2\u0a54\u0a55\5\f\7"+
19730 "\2\u0a55\u0a57\7Q\2\2\u0a56\u0a58\5*\26\2\u0a57\u0a56\3\2\2\2\u0a57\u0a58"+
19731 "\3\2\2\2\u0a58\u0a59\3\2\2\2\u0a59\u0a5a\5\u01f4\u00fb\2\u0a5a\u0a76\3"+
19732 "\2\2\2\u0a5b\u0a5c\7\64\2\2\u0a5c\u0a5e\7Q\2\2\u0a5d\u0a5f\5*\26\2\u0a5e"+
19733 "\u0a5d\3\2\2\2\u0a5e\u0a5f\3\2\2\2\u0a5f\u0a60\3\2\2\2\u0a60\u0a76\5\u01f4"+
19734 "\u00fb\2\u0a61\u0a62\58\35\2\u0a62\u0a63\7N\2\2\u0a63\u0a64\7\64\2\2\u0a64"+
19735 "\u0a66\7Q\2\2\u0a65\u0a67\5*\26\2\u0a66\u0a65\3\2\2\2\u0a66\u0a67\3\2"+
19736 "\2\2\u0a67\u0a68\3\2\2\2\u0a68\u0a69\5\u01f4\u00fb\2\u0a69\u0a76\3\2\2"+
19737 "\2\u0a6a\u0a6b\5\20\t\2\u0a6b\u0a6d\7Q\2\2\u0a6c\u0a6e\5*\26\2\u0a6d\u0a6c"+
19738 "\3\2\2\2\u0a6d\u0a6e\3\2\2\2\u0a6e\u0a6f\3\2\2\2\u0a6f\u0a70\7+\2\2\u0a70"+
19739 "\u0a76\3\2\2\2\u0a71\u0a72\5\36\20\2\u0a72\u0a73\7Q\2\2\u0a73\u0a74\7"+
19740 "+\2\2\u0a74\u0a76\3\2\2\2\u0a75\u0a4d\3\2\2\2\u0a75\u0a54\3\2\2\2\u0a75"+
19741 "\u0a5b\3\2\2\2\u0a75\u0a61\3\2\2\2\u0a75\u0a6a\3\2\2\2\u0a75\u0a71\3\2"+
19742 "\2\2\u0a76\u01af\3\2\2\2\u0a77\u0a78\7+\2\2\u0a78\u0a79\5\4\3\2\u0a79"+
19743 "\u0a7b\5\u01b2\u00da\2\u0a7a\u0a7c\5 \21\2\u0a7b\u0a7a\3\2\2\2\u0a7b\u0a7c"+
19744 "\3\2\2\2\u0a7c\u0a8e\3\2\2\2\u0a7d\u0a7e\7+\2\2\u0a7e\u0a7f\5\16\b\2\u0a7f"+
19745 "\u0a81\5\u01b2\u00da\2\u0a80\u0a82\5 \21\2\u0a81\u0a80\3\2\2\2\u0a81\u0a82"+
19746 "\3\2\2\2\u0a82\u0a8e\3\2\2\2\u0a83\u0a84\7+\2\2\u0a84\u0a85\5\4\3\2\u0a85"+
19747 "\u0a86\5 \21\2\u0a86\u0a87\5\u010e\u0088\2\u0a87\u0a8e\3\2\2\2\u0a88\u0a89"+
19748 "\7+\2\2\u0a89\u0a8a\5\16\b\2\u0a8a\u0a8b\5 \21\2\u0a8b\u0a8c\5\u010e\u0088"+
19749 "\2\u0a8c\u0a8e\3\2\2\2\u0a8d\u0a77\3\2\2\2\u0a8d\u0a7d\3\2\2\2\u0a8d\u0a83"+
19750 "\3\2\2\2\u0a8d\u0a88\3\2\2\2\u0a8e\u01b1\3\2\2\2\u0a8f\u0a91\5\u01b4\u00db"+
19751 "\2\u0a90\u0a8f\3\2\2\2\u0a91\u0a92\3\2\2\2\u0a92\u0a90\3\2\2\2\u0a92\u0a93"+
19752 "\3\2\2\2\u0a93\u01b3\3\2\2\2\u0a94\u0a96\5\u00fc\177\2\u0a95\u0a94\3\2"+
19753 "\2\2\u0a96\u0a99\3\2\2\2\u0a97\u0a95\3\2\2\2\u0a97\u0a98\3\2\2\2\u0a98"+
19754 "\u0a9a\3\2\2\2\u0a99\u0a97\3\2\2\2\u0a9a\u0a9b\7J\2\2\u0a9b\u0a9c\5\u01b8"+
19755 "\u00dd\2\u0a9c\u0a9d\7K\2\2\u0a9d\u01b5\3\2\2\2\u0a9e\u0a9f\5\u01b8\u00dd"+
19756 "\2\u0a9f\u01b7\3\2\2\2\u0aa0\u0aa3\5\u01ba\u00de\2\u0aa1\u0aa3\5\u01c2"+
19757 "\u00e2\2\u0aa2\u0aa0\3\2\2\2\u0aa2\u0aa1\3\2\2\2\u0aa3\u01b9\3\2\2\2\u0aa4"+
19758 "\u0aa5\5\u01bc\u00df\2\u0aa5\u0aa6\7Y\2\2\u0aa6\u0aa7\5\u01c0\u00e1\2"+
19759 "\u0aa7\u01bb\3\2\2\2\u0aa8\u0ab3\5\u01f4\u00fb\2\u0aa9\u0aab\7F\2\2\u0aaa"+
19760 "\u0aac\5\u00acW\2\u0aab\u0aaa\3\2\2\2\u0aab\u0aac\3\2\2\2\u0aac\u0aad"+
19761 "\3\2\2\2\u0aad\u0ab3\7G\2\2\u0aae\u0aaf\7F\2\2\u0aaf\u0ab0\5\u01be\u00e0"+
19762 "\2\u0ab0\u0ab1\7G\2\2\u0ab1\u0ab3\3\2\2\2\u0ab2\u0aa8\3\2\2\2\u0ab2\u0aa9"+
19763 "\3\2\2\2\u0ab2\u0aae\3\2\2\2\u0ab3\u01bd\3\2\2\2\u0ab4\u0ab9\5\u01f4\u00fb"+
19764 "\2\u0ab5\u0ab6\7M\2\2\u0ab6\u0ab8\5\u01f4\u00fb\2\u0ab7\u0ab5\3\2\2\2"+
19765 "\u0ab8\u0abb\3\2\2\2\u0ab9\u0ab7\3\2\2\2\u0ab9\u0aba\3\2\2\2\u0aba\u01bf"+
19766 "\3\2\2\2\u0abb\u0ab9\3\2\2\2\u0abc\u0abf\5\u01b8\u00dd\2\u0abd\u0abf\5"+
19767 "\u0112\u008a\2\u0abe\u0abc\3\2\2\2\u0abe\u0abd\3\2\2\2\u0abf\u01c1\3\2"+
19768 "\2\2\u0ac0\u0ac3\5\u01ca\u00e6\2\u0ac1\u0ac3\5\u01c4\u00e3\2\u0ac2\u0ac0"+
19769 "\3\2\2\2\u0ac2\u0ac1\3\2\2\2\u0ac3\u01c3\3\2\2\2\u0ac4\u0ac5\5\u01c6\u00e4"+
19770 "\2\u0ac5\u0ac6\5\u01c8\u00e5\2\u0ac6\u0ac7\5\u01b8\u00dd\2\u0ac7\u01c5"+
19771 "\3\2\2\2\u0ac8\u0acc\5<\37\2\u0ac9\u0acc\5\u0196\u00cc\2\u0aca\u0acc\5"+
19772 "\u019c\u00cf\2\u0acb\u0ac8\3\2\2\2\u0acb\u0ac9\3\2\2\2\u0acb\u0aca\3\2"+
19773 "\2\2\u0acc\u01c7\3\2\2\2\u0acd\u0ace\t\6\2\2\u0ace\u01c9\3\2\2\2\u0acf"+
19774 "\u0ad9\5\u01cc\u00e7\2\u0ad0\u0ad1\5\u01cc\u00e7\2\u0ad1\u0ad2\7W\2\2"+
19775 "\u0ad2\u0ad3\5\u01b8\u00dd\2\u0ad3\u0ad6\7X\2\2\u0ad4\u0ad7\5\u01ca\u00e6"+
19776 "\2\u0ad5\u0ad7\5\u01ba\u00de\2\u0ad6\u0ad4\3\2\2\2\u0ad6\u0ad5\3\2\2\2"+
19777 "\u0ad7\u0ad9\3\2\2\2\u0ad8\u0acf\3\2\2\2\u0ad8\u0ad0\3\2\2\2\u0ad9\u01cb"+
19778 "\3\2\2\2\u0ada\u0adb\b\u00e7\1\2\u0adb\u0adc\5\u01ce\u00e8\2\u0adc\u0ae2"+
19779 "\3\2\2\2\u0add\u0ade\f\3\2\2\u0ade\u0adf\7_\2\2\u0adf\u0ae1\5\u01ce\u00e8"+
19780 "\2\u0ae0\u0add\3\2\2\2\u0ae1\u0ae4\3\2\2\2\u0ae2\u0ae0\3\2\2\2\u0ae2\u0ae3"+
19781 "\3\2\2\2\u0ae3\u01cd\3\2\2\2\u0ae4\u0ae2\3\2\2\2\u0ae5\u0ae6\b\u00e8\1"+
19782 "\2\u0ae6\u0ae7\5\u01d0\u00e9\2\u0ae7\u0aed\3\2\2\2\u0ae8\u0ae9\f\3\2\2"+
19783 "\u0ae9\u0aea\7^\2\2\u0aea\u0aec\5\u01d0\u00e9\2\u0aeb\u0ae8\3\2\2\2\u0aec"+
19784 "\u0aef\3\2\2\2\u0aed\u0aeb\3\2\2\2\u0aed\u0aee\3\2\2\2\u0aee\u01cf\3\2"+
19785 "\2\2\u0aef\u0aed\3\2\2\2\u0af0\u0af1\b\u00e9\1\2\u0af1\u0af2\5\u01d2\u00ea"+
19786 "\2\u0af2\u0af8\3\2\2\2\u0af3\u0af4\f\3\2\2\u0af4\u0af5\7g\2\2\u0af5\u0af7"+
19787 "\5\u01d2\u00ea\2\u0af6\u0af3\3\2\2\2\u0af7\u0afa\3\2\2\2\u0af8\u0af6\3"+
19788 "\2\2\2\u0af8\u0af9\3\2\2\2\u0af9\u01d1\3\2\2\2\u0afa\u0af8\3\2\2\2\u0afb"+
19789 "\u0afc\b\u00ea\1\2\u0afc\u0afd\5\u01d4\u00eb\2\u0afd\u0b03\3\2\2\2\u0afe"+
19790 "\u0aff\f\3\2\2\u0aff\u0b00\7h\2\2\u0b00\u0b02\5\u01d4\u00eb\2\u0b01\u0afe"+
19791 "\3\2\2\2\u0b02\u0b05\3\2\2\2\u0b03\u0b01\3\2\2\2\u0b03\u0b04\3\2\2\2\u0b04"+
19792 "\u01d3\3\2\2\2\u0b05\u0b03\3\2\2\2\u0b06\u0b07\b\u00eb\1\2\u0b07\u0b08"+
19793 "\5\u01d6\u00ec\2\u0b08\u0b0e\3\2\2\2\u0b09\u0b0a\f\3\2\2\u0b0a\u0b0b\7"+
19794 "f\2\2\u0b0b\u0b0d\5\u01d6\u00ec\2\u0b0c\u0b09\3\2\2\2\u0b0d\u0b10\3\2"+
19795 "\2\2\u0b0e\u0b0c\3\2\2\2\u0b0e\u0b0f\3\2\2\2\u0b0f\u01d5\3\2\2\2\u0b10"+
19796 "\u0b0e\3\2\2\2\u0b11\u0b12\b\u00ec\1\2\u0b12\u0b13\5\u01d8\u00ed\2\u0b13"+
19797 "\u0b1c\3\2\2\2\u0b14\u0b15\f\4\2\2\u0b15\u0b16\7Z\2\2\u0b16\u0b1b\5\u01d8"+
19798 "\u00ed\2\u0b17\u0b18\f\3\2\2\u0b18\u0b19\7]\2\2\u0b19\u0b1b\5\u01d8\u00ed"+
19799 "\2\u0b1a\u0b14\3\2\2\2\u0b1a\u0b17\3\2\2\2\u0b1b\u0b1e\3\2\2\2\u0b1c\u0b1a"+
19800 "\3\2\2\2\u0b1c\u0b1d\3\2\2\2\u0b1d\u01d7\3\2\2\2\u0b1e\u0b1c\3\2\2\2\u0b1f"+
19801 "\u0b20\b\u00ed\1\2\u0b20\u0b21\5\u01da\u00ee\2\u0b21\u0b33\3\2\2\2\u0b22"+
19802 "\u0b23\f\7\2\2\u0b23\u0b24\7T\2\2\u0b24\u0b32\5\u01da\u00ee\2\u0b25\u0b26"+
19803 "\f\6\2\2\u0b26\u0b27\7S\2\2\u0b27\u0b32\5\u01da\u00ee\2\u0b28\u0b29\f"+
19804 "\5\2\2\u0b29\u0b2a\7[\2\2\u0b2a\u0b32\5\u01da\u00ee\2\u0b2b\u0b2c\f\4"+
19805 "\2\2\u0b2c\u0b2d\7\\\2\2\u0b2d\u0b32\5\u01da\u00ee\2\u0b2e\u0b2f\f\3\2"+
19806 "\2\u0b2f\u0b30\7&\2\2\u0b30\u0b32\5\f\7\2\u0b31\u0b22\3\2\2\2\u0b31\u0b25"+
19807 "\3\2\2\2\u0b31\u0b28\3\2\2\2\u0b31\u0b2b\3\2\2\2\u0b31\u0b2e\3\2\2\2\u0b32"+
19808 "\u0b35\3\2\2\2\u0b33\u0b31\3\2\2\2\u0b33\u0b34\3\2\2\2\u0b34\u01d9\3\2"+
19809 "\2\2\u0b35\u0b33\3\2\2\2\u0b36\u0b37\b\u00ee\1\2\u0b37\u0b38\5\u01dc\u00ef"+
19810 "\2\u0b38\u0b48\3\2\2\2\u0b39\u0b3a\f\5\2\2\u0b3a\u0b3b\7T\2\2\u0b3b\u0b3c"+
19811 "\7T\2\2\u0b3c\u0b47\5\u01dc\u00ef\2\u0b3d\u0b3e\f\4\2\2\u0b3e\u0b3f\7"+
19812 "S\2\2\u0b3f\u0b40\7S\2\2\u0b40\u0b47\5\u01dc\u00ef\2\u0b41\u0b42\f\3\2"+
19813 "\2\u0b42\u0b43\7S\2\2\u0b43\u0b44\7S\2\2\u0b44\u0b45\7S\2\2\u0b45\u0b47"+
19814 "\5\u01dc\u00ef\2\u0b46\u0b39\3\2\2\2\u0b46\u0b3d\3\2\2\2\u0b46\u0b41\3"+
19815 "\2\2\2\u0b47\u0b4a\3\2\2\2\u0b48\u0b46\3\2\2\2\u0b48\u0b49\3\2\2\2\u0b49"+
19816 "\u01db\3\2\2\2\u0b4a\u0b48\3\2\2\2\u0b4b\u0b4c\b\u00ef\1\2\u0b4c\u0b4d"+
19817 "\5\u01de\u00f0\2\u0b4d\u0b56\3\2\2\2\u0b4e\u0b4f\f\4\2\2\u0b4f\u0b50\7"+
19818 "b\2\2\u0b50\u0b55\5\u01de\u00f0\2\u0b51\u0b52\f\3\2\2\u0b52\u0b53\7c\2"+
19819 "\2\u0b53\u0b55\5\u01de\u00f0\2\u0b54\u0b4e\3\2\2\2\u0b54\u0b51\3\2\2\2"+
19820 "\u0b55\u0b58\3\2\2\2\u0b56\u0b54\3\2\2\2\u0b56\u0b57\3\2\2\2\u0b57\u01dd"+
19821 "\3\2\2\2\u0b58\u0b56\3\2\2\2\u0b59\u0b5a\b\u00f0\1\2\u0b5a\u0b5b\5\u01e0"+
19822 "\u00f1\2\u0b5b\u0b67\3\2\2\2\u0b5c\u0b5d\f\5\2\2\u0b5d\u0b5e\7d\2\2\u0b5e"+
19823 "\u0b66\5\u01e0\u00f1\2\u0b5f\u0b60\f\4\2\2\u0b60\u0b61\7e\2\2\u0b61\u0b66"+
19824 "\5\u01e0\u00f1\2\u0b62\u0b63\f\3\2\2\u0b63\u0b64\7i\2\2\u0b64\u0b66\5"+
19825 "\u01e0\u00f1\2\u0b65\u0b5c\3\2\2\2\u0b65\u0b5f\3\2\2\2\u0b65\u0b62\3\2"+
19826 "\2\2\u0b66\u0b69\3\2\2\2\u0b67\u0b65\3\2\2\2\u0b67\u0b68\3\2\2\2\u0b68"+
19827 "\u01df\3\2\2\2\u0b69\u0b67\3\2\2\2\u0b6a\u0b72\5\u01e2\u00f2\2\u0b6b\u0b72"+
19828 "\5\u01e4\u00f3\2\u0b6c\u0b6d\7b\2\2\u0b6d\u0b72\5\u01e0\u00f1\2\u0b6e"+
19829 "\u0b6f\7c\2\2\u0b6f\u0b72\5\u01e0\u00f1\2\u0b70\u0b72\5\u01e6\u00f4\2"+
19830 "\u0b71\u0b6a\3\2\2\2\u0b71\u0b6b\3\2\2\2\u0b71\u0b6c\3\2\2\2\u0b71\u0b6e"+
19831 "\3\2\2\2\u0b71\u0b70\3\2\2\2\u0b72\u01e1\3\2\2\2\u0b73\u0b74\7`\2\2\u0b74"+
19832 "\u0b75\5\u01e0\u00f1\2\u0b75\u01e3\3\2\2\2\u0b76\u0b77\7a\2\2\u0b77\u0b78"+
19833 "\5\u01e0\u00f1\2\u0b78\u01e5\3\2\2\2\u0b79\u0b80\5\u01e8\u00f5\2\u0b7a"+
19834 "\u0b7b\7V\2\2\u0b7b\u0b80\5\u01e0\u00f1\2\u0b7c\u0b7d\7U\2\2\u0b7d\u0b80"+
19835 "\5\u01e0\u00f1\2\u0b7e\u0b80\5\u01f2\u00fa\2\u0b7f\u0b79\3\2\2\2\u0b7f"+
19836 "\u0b7a\3\2\2\2\u0b7f\u0b7c\3\2\2\2\u0b7f\u0b7e\3\2\2\2\u0b80\u01e7\3\2"+
19837 "\2\2\u0b81\u0b84\5\u0178\u00bd\2\u0b82\u0b84\5<\37\2\u0b83\u0b81\3\2\2"+
19838 "\2\u0b83\u0b82\3\2\2\2\u0b84\u0b89\3\2\2\2\u0b85\u0b88\5\u01ec\u00f7\2"+
19839 "\u0b86\u0b88\5\u01f0\u00f9\2\u0b87\u0b85\3\2\2\2\u0b87\u0b86\3\2\2\2\u0b88"+
19840 "\u0b8b\3\2\2\2\u0b89\u0b87\3\2\2\2\u0b89\u0b8a\3\2\2\2\u0b8a\u01e9\3\2"+
19841 "\2\2\u0b8b\u0b89\3\2\2\2\u0b8c\u0b8d\5\u01e8\u00f5\2\u0b8d\u0b8e\7`\2"+
19842 "\2\u0b8e\u01eb\3\2\2\2\u0b8f\u0b90\7`\2\2\u0b90\u01ed\3\2\2\2\u0b91\u0b92"+
19843 "\5\u01e8\u00f5\2\u0b92\u0b93\7a\2\2\u0b93\u01ef\3\2\2\2\u0b94\u0b95\7"+
19844 "a\2\2\u0b95\u01f1\3\2\2\2\u0b96\u0b97\7F\2\2\u0b97\u0b98\5\4\3\2\u0b98"+
19845 "\u0b99\7G\2\2\u0b99\u0b9a\5\u01e0\u00f1\2\u0b9a\u0bb2\3\2\2\2\u0b9b\u0b9c"+
19846 "\7F\2\2\u0b9c\u0ba0\5\f\7\2\u0b9d\u0b9f\5(\25\2\u0b9e\u0b9d\3\2\2\2\u0b9f"+
19847 "\u0ba2\3\2\2\2\u0ba0\u0b9e\3\2\2\2\u0ba0\u0ba1\3\2\2\2\u0ba1\u0ba3\3\2"+
19848 "\2\2\u0ba2\u0ba0\3\2\2\2\u0ba3\u0ba4\7G\2\2\u0ba4\u0ba5\5\u01e6\u00f4"+
19849 "\2\u0ba5\u0bb2\3\2\2\2\u0ba6\u0ba7\7F\2\2\u0ba7\u0bab\5\f\7\2\u0ba8\u0baa"+
19850 "\5(\25\2\u0ba9\u0ba8\3\2\2\2\u0baa\u0bad\3\2\2\2\u0bab\u0ba9\3\2\2\2\u0bab"+
19851 "\u0bac\3\2\2\2\u0bac\u0bae\3\2\2\2\u0bad\u0bab\3\2\2\2\u0bae\u0baf\7G"+
19852 "\2\2\u0baf\u0bb0\5\u01ba\u00de\2\u0bb0\u0bb2\3\2\2\2\u0bb1\u0b96\3\2\2"+
19853 "\2\u0bb1\u0b9b\3\2\2\2\u0bb1\u0ba6\3\2\2\2\u0bb2\u01f3\3\2\2\2\u0bb3\u0bb4"+
19854 "\t\7\2\2\u0bb4\u01f5\3\2\2\2\u0156\u01fb\u0202\u0206\u020a\u0213\u0217"+
19855 "\u021b\u021d\u0223\u0228\u022f\u0234\u0236\u023c\u0241\u0246\u024b\u0256"+
19856 "\u0264\u0269\u0271\u0278\u027e\u0283\u028e\u0291\u029f\u02a4\u02a9\u02ae"+
19857 "\u02b4\u02be\u02c9\u02d1\u02db\u02e3\u02ef\u02f4\u02f7\u02fc\u0302\u030a"+
19858 "\u0312\u031f\u033c\u0341\u0345\u034d\u0357\u035d\u036b\u036e\u037a\u037d"+
19859 "\u038d\u0396\u039b\u03a1\u03a4\u03a7\u03b3\u03be\u03cc\u03d3\u03dc\u03e3"+
19860 "\u03e8\u03f7\u03fe\u0404\u0408\u040c\u0410\u0414\u0419\u041d\u0421\u0423"+
19861 "\u0428\u042f\u0434\u0436\u043c\u0441\u0445\u0458\u045d\u046d\u0472\u0478"+
19862 "\u047e\u0480\u0484\u0489\u048d\u0495\u049c\u04a4\u04a7\u04ac\u04b4\u04b9"+
19863 "\u04c0\u04c7\u04cc\u04d3\u04df\u04e4\u04e8\u04f2\u04f7\u04ff\u0502\u0507"+
19864 "\u050f\u0512\u0517\u051c\u0521\u0526\u052d\u0532\u053a\u053f\u0544\u0549"+
19865 "\u054f\u0555\u0558\u055b\u0564\u056a\u0570\u0573\u0576\u057e\u0583\u0588"+
19866 "\u058e\u0591\u059c\u05a5\u05af\u05b4\u05bf\u05c4\u05d1\u05d6\u05e2\u05ec"+
19867 "\u05f1\u05f9\u05fc\u0603\u060b\u0611\u061a\u0624\u0628\u062b\u0634\u0642"+
19868 "\u0645\u064e\u0653\u065a\u065f\u0667\u0673\u067a\u0688\u069e\u06c0\u06cc"+
19869 "\u06d2\u06dd\u06e9\u0703\u0707\u070c\u0710\u0714\u071c\u0720\u0724\u072b"+
19870 "\u0734\u073c\u074b\u0757\u075d\u0763\u0778\u077d\u0782\u078d\u0798\u07a2"+
19871 "\u07a5\u07aa\u07b3\u07b9\u07c2\u07c6\u07ca\u07cf\u07e2\u07ec\u0802\u0809"+
19872 "\u0811\u0819\u0824\u083b\u0845\u0850\u0866\u086b\u0871\u0879\u087d\u0882"+
19873 "\u088a\u0890\u0894\u0898\u089c\u08a2\u08a7\u08ac\u08b0\u08b4\u08ba\u08bf"+
19874 "\u08c4\u08c8\u08cc\u08ce\u08d3\u08d8\u08dd\u08e1\u08e5\u08e9\u08ee\u08f6"+
19875 "\u08fc\u0900\u0904\u0908\u090e\u0913\u0918\u091c\u0920\u0922\u0927\u0936"+
19876 "\u0944\u0950\u0959\u0968\u0975\u097e\u0984\u098b\u0990\u0997\u099c\u09a3"+
19877 "\u09a8\u09af\u09b4\u09bd\u09c2\u09c6\u09ca\u09cf\u09d6\u09dd\u09e2\u09e9"+
19878 "\u09ee\u09f5\u09fa\u0a03\u0a08\u0a0c\u0a13\u0a19\u0a20\u0a27\u0a2e\u0a36"+
19879 "\u0a3d\u0a45\u0a49\u0a50\u0a57\u0a5e\u0a66\u0a6d\u0a75\u0a7b\u0a81\u0a8d"+
19880 "\u0a92\u0a97\u0aa2\u0aab\u0ab2\u0ab9\u0abe\u0ac2\u0acb\u0ad6\u0ad8\u0ae2"+
19881 "\u0aed\u0af8\u0b03\u0b0e\u0b1a\u0b1c\u0b31\u0b33\u0b46\u0b48\u0b54\u0b56"+
19882 "\u0b65\u0b67\u0b71\u0b7f\u0b83\u0b87\u0b89\u0ba0\u0bab\u0bb1";
19883 public static final String _serializedATN = Utils.join(
19884 new String[] {
19885 _serializedATNSegment0,
19886 _serializedATNSegment1
19887 },
19888 ""
19889 );
19890 public static final ATN _ATN =
19891 new ATNDeserializer().deserialize(_serializedATN.toCharArray());
19892 static {
19893 _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
19894 for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
19895 _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
19896 }
19897 }
19898 }