Java9Parser.java
// Generated from io/earcam/instrumental/module/jpms/parser/Java9.g4 by ANTLR 4.7.1
package io.earcam.instrumental.module.jpms.parser;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
class Java9Parser extends Parser {
static { RuntimeMetaData.checkVersion("4.7.1", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
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,
T__9=10, ABSTRACT=11, ASSERT=12, BOOLEAN=13, BREAK=14, BYTE=15, CASE=16,
CATCH=17, CHAR=18, CLASS=19, CONST=20, CONTINUE=21, DEFAULT=22, DO=23,
DOUBLE=24, ELSE=25, ENUM=26, EXTENDS=27, FINAL=28, FINALLY=29, FLOAT=30,
FOR=31, IF=32, GOTO=33, IMPLEMENTS=34, IMPORT=35, INSTANCEOF=36, INT=37,
INTERFACE=38, LONG=39, NATIVE=40, NEW=41, PACKAGE=42, PRIVATE=43, PROTECTED=44,
PUBLIC=45, RETURN=46, SHORT=47, STATIC=48, STRICTFP=49, SUPER=50, SWITCH=51,
SYNCHRONIZED=52, THIS=53, THROW=54, THROWS=55, TRANSIENT=56, TRY=57, VOID=58,
VOLATILE=59, WHILE=60, UNDER_SCORE=61, IntegerLiteral=62, FloatingPointLiteral=63,
BooleanLiteral=64, CharacterLiteral=65, StringLiteral=66, NullLiteral=67,
LPAREN=68, RPAREN=69, LBRACE=70, RBRACE=71, LBRACK=72, RBRACK=73, SEMI=74,
COMMA=75, DOT=76, ELLIPSIS=77, AT=78, COLONCOLON=79, ASSIGN=80, GT=81,
LT=82, BANG=83, TILDE=84, QUESTION=85, COLON=86, ARROW=87, EQUAL=88, LE=89,
GE=90, NOTEQUAL=91, AND=92, OR=93, INC=94, DEC=95, ADD=96, SUB=97, MUL=98,
DIV=99, BITAND=100, BITOR=101, CARET=102, MOD=103, ADD_ASSIGN=104, SUB_ASSIGN=105,
MUL_ASSIGN=106, DIV_ASSIGN=107, AND_ASSIGN=108, OR_ASSIGN=109, XOR_ASSIGN=110,
MOD_ASSIGN=111, LSHIFT_ASSIGN=112, RSHIFT_ASSIGN=113, URSHIFT_ASSIGN=114,
Identifier=115, WS=116, COMMENT=117, LINE_COMMENT=118;
public static final int
RULE_literal = 0, RULE_primitiveType = 1, RULE_numericType = 2, RULE_integralType = 3,
RULE_floatingPointType = 4, RULE_referenceType = 5, RULE_classOrInterfaceType = 6,
RULE_classType = 7, RULE_classType_lf_classOrInterfaceType = 8, RULE_classType_lfno_classOrInterfaceType = 9,
RULE_interfaceType = 10, RULE_interfaceType_lf_classOrInterfaceType = 11,
RULE_interfaceType_lfno_classOrInterfaceType = 12, RULE_typeVariable = 13,
RULE_arrayType = 14, RULE_dims = 15, RULE_typeParameter = 16, RULE_typeParameterModifier = 17,
RULE_typeBound = 18, RULE_additionalBound = 19, RULE_typeArguments = 20,
RULE_typeArgumentList = 21, RULE_typeArgument = 22, RULE_wildcard = 23,
RULE_wildcardBounds = 24, RULE_moduleName = 25, RULE_packageName = 26,
RULE_typeName = 27, RULE_packageOrTypeName = 28, RULE_expressionName = 29,
RULE_methodName = 30, RULE_ambiguousName = 31, RULE_compilationUnit = 32,
RULE_ordinaryCompilation = 33, RULE_modularCompilation = 34, RULE_packageDeclaration = 35,
RULE_packageModifier = 36, RULE_importDeclaration = 37, RULE_singleTypeImportDeclaration = 38,
RULE_typeImportOnDemandDeclaration = 39, RULE_singleStaticImportDeclaration = 40,
RULE_staticImportOnDemandDeclaration = 41, RULE_typeDeclaration = 42,
RULE_moduleDeclaration = 43, RULE_moduleDirective = 44, RULE_requiresDirective = 45,
RULE_exportsDirective = 46, RULE_opensDirective = 47, RULE_usesDirective = 48,
RULE_providesDirective = 49, RULE_requiresModifier = 50, RULE_classDeclaration = 51,
RULE_normalClassDeclaration = 52, RULE_classModifier = 53, RULE_typeParameters = 54,
RULE_typeParameterList = 55, RULE_superclass = 56, RULE_superinterfaces = 57,
RULE_interfaceTypeList = 58, RULE_classBody = 59, RULE_classBodyDeclaration = 60,
RULE_classMemberDeclaration = 61, RULE_fieldDeclaration = 62, RULE_fieldModifier = 63,
RULE_variableDeclaratorList = 64, RULE_variableDeclarator = 65, RULE_variableDeclaratorId = 66,
RULE_variableInitializer = 67, RULE_unannType = 68, RULE_unannPrimitiveType = 69,
RULE_unannReferenceType = 70, RULE_unannClassOrInterfaceType = 71, RULE_unannClassType = 72,
RULE_unannClassType_lf_unannClassOrInterfaceType = 73, RULE_unannClassType_lfno_unannClassOrInterfaceType = 74,
RULE_unannInterfaceType = 75, RULE_unannInterfaceType_lf_unannClassOrInterfaceType = 76,
RULE_unannInterfaceType_lfno_unannClassOrInterfaceType = 77, RULE_unannTypeVariable = 78,
RULE_unannArrayType = 79, RULE_methodDeclaration = 80, RULE_methodModifier = 81,
RULE_methodHeader = 82, RULE_result = 83, RULE_methodDeclarator = 84,
RULE_formalParameterList = 85, RULE_formalParameters = 86, RULE_formalParameter = 87,
RULE_variableModifier = 88, RULE_lastFormalParameter = 89, RULE_receiverParameter = 90,
RULE_throws_ = 91, RULE_exceptionTypeList = 92, RULE_exceptionType = 93,
RULE_methodBody = 94, RULE_instanceInitializer = 95, RULE_staticInitializer = 96,
RULE_constructorDeclaration = 97, RULE_constructorModifier = 98, RULE_constructorDeclarator = 99,
RULE_simpleTypeName = 100, RULE_constructorBody = 101, RULE_explicitConstructorInvocation = 102,
RULE_enumDeclaration = 103, RULE_enumBody = 104, RULE_enumConstantList = 105,
RULE_enumConstant = 106, RULE_enumConstantModifier = 107, RULE_enumBodyDeclarations = 108,
RULE_interfaceDeclaration = 109, RULE_normalInterfaceDeclaration = 110,
RULE_interfaceModifier = 111, RULE_extendsInterfaces = 112, RULE_interfaceBody = 113,
RULE_interfaceMemberDeclaration = 114, RULE_constantDeclaration = 115,
RULE_constantModifier = 116, RULE_interfaceMethodDeclaration = 117, RULE_interfaceMethodModifier = 118,
RULE_annotationTypeDeclaration = 119, RULE_annotationTypeBody = 120, RULE_annotationTypeMemberDeclaration = 121,
RULE_annotationTypeElementDeclaration = 122, RULE_annotationTypeElementModifier = 123,
RULE_defaultValue = 124, RULE_annotation = 125, RULE_normalAnnotation = 126,
RULE_elementValuePairList = 127, RULE_elementValuePair = 128, RULE_elementValue = 129,
RULE_elementValueArrayInitializer = 130, RULE_elementValueList = 131,
RULE_markerAnnotation = 132, RULE_singleElementAnnotation = 133, RULE_arrayInitializer = 134,
RULE_variableInitializerList = 135, RULE_block = 136, RULE_blockStatements = 137,
RULE_blockStatement = 138, RULE_localVariableDeclarationStatement = 139,
RULE_localVariableDeclaration = 140, RULE_statement = 141, RULE_statementNoShortIf = 142,
RULE_statementWithoutTrailingSubstatement = 143, RULE_emptyStatement = 144,
RULE_labeledStatement = 145, RULE_labeledStatementNoShortIf = 146, RULE_expressionStatement = 147,
RULE_statementExpression = 148, RULE_ifThenStatement = 149, RULE_ifThenElseStatement = 150,
RULE_ifThenElseStatementNoShortIf = 151, RULE_assertStatement = 152, RULE_switchStatement = 153,
RULE_switchBlock = 154, RULE_switchBlockStatementGroup = 155, RULE_switchLabels = 156,
RULE_switchLabel = 157, RULE_enumConstantName = 158, RULE_whileStatement = 159,
RULE_whileStatementNoShortIf = 160, RULE_doStatement = 161, RULE_forStatement = 162,
RULE_forStatementNoShortIf = 163, RULE_basicForStatement = 164, RULE_basicForStatementNoShortIf = 165,
RULE_forInit = 166, RULE_forUpdate = 167, RULE_statementExpressionList = 168,
RULE_enhancedForStatement = 169, RULE_enhancedForStatementNoShortIf = 170,
RULE_breakStatement = 171, RULE_continueStatement = 172, RULE_returnStatement = 173,
RULE_throwStatement = 174, RULE_synchronizedStatement = 175, RULE_tryStatement = 176,
RULE_catches = 177, RULE_catchClause = 178, RULE_catchFormalParameter = 179,
RULE_catchType = 180, RULE_finally_ = 181, RULE_tryWithResourcesStatement = 182,
RULE_resourceSpecification = 183, RULE_resourceList = 184, RULE_resource = 185,
RULE_variableAccess = 186, RULE_primary = 187, RULE_primaryNoNewArray = 188,
RULE_primaryNoNewArray_lf_arrayAccess = 189, RULE_primaryNoNewArray_lfno_arrayAccess = 190,
RULE_primaryNoNewArray_lf_primary = 191, RULE_primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary = 192,
RULE_primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary = 193, RULE_primaryNoNewArray_lfno_primary = 194,
RULE_primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary = 195,
RULE_primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary = 196,
RULE_classLiteral = 197, RULE_classInstanceCreationExpression = 198, RULE_classInstanceCreationExpression_lf_primary = 199,
RULE_classInstanceCreationExpression_lfno_primary = 200, RULE_typeArgumentsOrDiamond = 201,
RULE_fieldAccess = 202, RULE_fieldAccess_lf_primary = 203, RULE_fieldAccess_lfno_primary = 204,
RULE_arrayAccess = 205, RULE_arrayAccess_lf_primary = 206, RULE_arrayAccess_lfno_primary = 207,
RULE_methodInvocation = 208, RULE_methodInvocation_lf_primary = 209, RULE_methodInvocation_lfno_primary = 210,
RULE_argumentList = 211, RULE_methodReference = 212, RULE_methodReference_lf_primary = 213,
RULE_methodReference_lfno_primary = 214, RULE_arrayCreationExpression = 215,
RULE_dimExprs = 216, RULE_dimExpr = 217, RULE_constantExpression = 218,
RULE_expression = 219, RULE_lambdaExpression = 220, RULE_lambdaParameters = 221,
RULE_inferredFormalParameterList = 222, RULE_lambdaBody = 223, RULE_assignmentExpression = 224,
RULE_assignment = 225, RULE_leftHandSide = 226, RULE_assignmentOperator = 227,
RULE_conditionalExpression = 228, RULE_conditionalOrExpression = 229,
RULE_conditionalAndExpression = 230, RULE_inclusiveOrExpression = 231,
RULE_exclusiveOrExpression = 232, RULE_andExpression = 233, RULE_equalityExpression = 234,
RULE_relationalExpression = 235, RULE_shiftExpression = 236, RULE_additiveExpression = 237,
RULE_multiplicativeExpression = 238, RULE_unaryExpression = 239, RULE_preIncrementExpression = 240,
RULE_preDecrementExpression = 241, RULE_unaryExpressionNotPlusMinus = 242,
RULE_postfixExpression = 243, RULE_postIncrementExpression = 244, RULE_postIncrementExpression_lf_postfixExpression = 245,
RULE_postDecrementExpression = 246, RULE_postDecrementExpression_lf_postfixExpression = 247,
RULE_castExpression = 248, RULE_identifier = 249;
public static final String[] ruleNames = {
"literal", "primitiveType", "numericType", "integralType", "floatingPointType",
"referenceType", "classOrInterfaceType", "classType", "classType_lf_classOrInterfaceType",
"classType_lfno_classOrInterfaceType", "interfaceType", "interfaceType_lf_classOrInterfaceType",
"interfaceType_lfno_classOrInterfaceType", "typeVariable", "arrayType",
"dims", "typeParameter", "typeParameterModifier", "typeBound", "additionalBound",
"typeArguments", "typeArgumentList", "typeArgument", "wildcard", "wildcardBounds",
"moduleName", "packageName", "typeName", "packageOrTypeName", "expressionName",
"methodName", "ambiguousName", "compilationUnit", "ordinaryCompilation",
"modularCompilation", "packageDeclaration", "packageModifier", "importDeclaration",
"singleTypeImportDeclaration", "typeImportOnDemandDeclaration", "singleStaticImportDeclaration",
"staticImportOnDemandDeclaration", "typeDeclaration", "moduleDeclaration",
"moduleDirective", "requiresDirective", "exportsDirective", "opensDirective",
"usesDirective", "providesDirective", "requiresModifier", "classDeclaration",
"normalClassDeclaration", "classModifier", "typeParameters", "typeParameterList",
"superclass", "superinterfaces", "interfaceTypeList", "classBody", "classBodyDeclaration",
"classMemberDeclaration", "fieldDeclaration", "fieldModifier", "variableDeclaratorList",
"variableDeclarator", "variableDeclaratorId", "variableInitializer", "unannType",
"unannPrimitiveType", "unannReferenceType", "unannClassOrInterfaceType",
"unannClassType", "unannClassType_lf_unannClassOrInterfaceType", "unannClassType_lfno_unannClassOrInterfaceType",
"unannInterfaceType", "unannInterfaceType_lf_unannClassOrInterfaceType",
"unannInterfaceType_lfno_unannClassOrInterfaceType", "unannTypeVariable",
"unannArrayType", "methodDeclaration", "methodModifier", "methodHeader",
"result", "methodDeclarator", "formalParameterList", "formalParameters",
"formalParameter", "variableModifier", "lastFormalParameter", "receiverParameter",
"throws_", "exceptionTypeList", "exceptionType", "methodBody", "instanceInitializer",
"staticInitializer", "constructorDeclaration", "constructorModifier",
"constructorDeclarator", "simpleTypeName", "constructorBody", "explicitConstructorInvocation",
"enumDeclaration", "enumBody", "enumConstantList", "enumConstant", "enumConstantModifier",
"enumBodyDeclarations", "interfaceDeclaration", "normalInterfaceDeclaration",
"interfaceModifier", "extendsInterfaces", "interfaceBody", "interfaceMemberDeclaration",
"constantDeclaration", "constantModifier", "interfaceMethodDeclaration",
"interfaceMethodModifier", "annotationTypeDeclaration", "annotationTypeBody",
"annotationTypeMemberDeclaration", "annotationTypeElementDeclaration",
"annotationTypeElementModifier", "defaultValue", "annotation", "normalAnnotation",
"elementValuePairList", "elementValuePair", "elementValue", "elementValueArrayInitializer",
"elementValueList", "markerAnnotation", "singleElementAnnotation", "arrayInitializer",
"variableInitializerList", "block", "blockStatements", "blockStatement",
"localVariableDeclarationStatement", "localVariableDeclaration", "statement",
"statementNoShortIf", "statementWithoutTrailingSubstatement", "emptyStatement",
"labeledStatement", "labeledStatementNoShortIf", "expressionStatement",
"statementExpression", "ifThenStatement", "ifThenElseStatement", "ifThenElseStatementNoShortIf",
"assertStatement", "switchStatement", "switchBlock", "switchBlockStatementGroup",
"switchLabels", "switchLabel", "enumConstantName", "whileStatement", "whileStatementNoShortIf",
"doStatement", "forStatement", "forStatementNoShortIf", "basicForStatement",
"basicForStatementNoShortIf", "forInit", "forUpdate", "statementExpressionList",
"enhancedForStatement", "enhancedForStatementNoShortIf", "breakStatement",
"continueStatement", "returnStatement", "throwStatement", "synchronizedStatement",
"tryStatement", "catches", "catchClause", "catchFormalParameter", "catchType",
"finally_", "tryWithResourcesStatement", "resourceSpecification", "resourceList",
"resource", "variableAccess", "primary", "primaryNoNewArray", "primaryNoNewArray_lf_arrayAccess",
"primaryNoNewArray_lfno_arrayAccess", "primaryNoNewArray_lf_primary",
"primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary", "primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary",
"primaryNoNewArray_lfno_primary", "primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary",
"primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary", "classLiteral",
"classInstanceCreationExpression", "classInstanceCreationExpression_lf_primary",
"classInstanceCreationExpression_lfno_primary", "typeArgumentsOrDiamond",
"fieldAccess", "fieldAccess_lf_primary", "fieldAccess_lfno_primary", "arrayAccess",
"arrayAccess_lf_primary", "arrayAccess_lfno_primary", "methodInvocation",
"methodInvocation_lf_primary", "methodInvocation_lfno_primary", "argumentList",
"methodReference", "methodReference_lf_primary", "methodReference_lfno_primary",
"arrayCreationExpression", "dimExprs", "dimExpr", "constantExpression",
"expression", "lambdaExpression", "lambdaParameters", "inferredFormalParameterList",
"lambdaBody", "assignmentExpression", "assignment", "leftHandSide", "assignmentOperator",
"conditionalExpression", "conditionalOrExpression", "conditionalAndExpression",
"inclusiveOrExpression", "exclusiveOrExpression", "andExpression", "equalityExpression",
"relationalExpression", "shiftExpression", "additiveExpression", "multiplicativeExpression",
"unaryExpression", "preIncrementExpression", "preDecrementExpression",
"unaryExpressionNotPlusMinus", "postfixExpression", "postIncrementExpression",
"postIncrementExpression_lf_postfixExpression", "postDecrementExpression",
"postDecrementExpression_lf_postfixExpression", "castExpression", "identifier"
};
private static final String[] _LITERAL_NAMES = {
null, "'open'", "'module'", "'requires'", "'exports'", "'to'", "'opens'",
"'uses'", "'provides'", "'with'", "'transitive'", "'abstract'", "'assert'",
"'boolean'", "'break'", "'byte'", "'case'", "'catch'", "'char'", "'class'",
"'const'", "'continue'", "'default'", "'do'", "'double'", "'else'", "'enum'",
"'extends'", "'final'", "'finally'", "'float'", "'for'", "'if'", "'goto'",
"'implements'", "'import'", "'instanceof'", "'int'", "'interface'", "'long'",
"'native'", "'new'", "'package'", "'private'", "'protected'", "'public'",
"'return'", "'short'", "'static'", "'strictfp'", "'super'", "'switch'",
"'synchronized'", "'this'", "'throw'", "'throws'", "'transient'", "'try'",
"'void'", "'volatile'", "'while'", "'_'", null, null, null, null, null,
"'null'", "'('", "')'", "'{'", "'}'", "'['", "']'", "';'", "','", "'.'",
"'...'", "'@'", "'::'", "'='", "'>'", "'<'", "'!'", "'~'", "'?'", "':'",
"'->'", "'=='", "'<='", "'>='", "'!='", "'&&'", "'||'", "'++'", "'--'",
"'+'", "'-'", "'*'", "'/'", "'&'", "'|'", "'^'", "'%'", "'+='", "'-='",
"'*='", "'/='", "'&='", "'|='", "'^='", "'%='", "'<<='", "'>>='", "'>>>='"
};
private static final String[] _SYMBOLIC_NAMES = {
null, null, null, null, null, null, null, null, null, null, null, "ABSTRACT",
"ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", "CHAR", "CLASS",
"CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", "ENUM", "EXTENDS",
"FINAL", "FINALLY", "FLOAT", "FOR", "IF", "GOTO", "IMPLEMENTS", "IMPORT",
"INSTANCEOF", "INT", "INTERFACE", "LONG", "NATIVE", "NEW", "PACKAGE",
"PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", "STATIC", "STRICTFP",
"SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", "THROWS", "TRANSIENT",
"TRY", "VOID", "VOLATILE", "WHILE", "UNDER_SCORE", "IntegerLiteral", "FloatingPointLiteral",
"BooleanLiteral", "CharacterLiteral", "StringLiteral", "NullLiteral",
"LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", "SEMI", "COMMA",
"DOT", "ELLIPSIS", "AT", "COLONCOLON", "ASSIGN", "GT", "LT", "BANG", "TILDE",
"QUESTION", "COLON", "ARROW", "EQUAL", "LE", "GE", "NOTEQUAL", "AND",
"OR", "INC", "DEC", "ADD", "SUB", "MUL", "DIV", "BITAND", "BITOR", "CARET",
"MOD", "ADD_ASSIGN", "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN",
"OR_ASSIGN", "XOR_ASSIGN", "MOD_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN",
"URSHIFT_ASSIGN", "Identifier", "WS", "COMMENT", "LINE_COMMENT"
};
public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
/**
* @deprecated Use {@link #VOCABULARY} instead.
*/
@Deprecated
public static final String[] tokenNames;
static {
tokenNames = new String[_SYMBOLIC_NAMES.length];
for (int i = 0; i < tokenNames.length; i++) {
tokenNames[i] = VOCABULARY.getLiteralName(i);
if (tokenNames[i] == null) {
tokenNames[i] = VOCABULARY.getSymbolicName(i);
}
if (tokenNames[i] == null) {
tokenNames[i] = "<INVALID>";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
@Override
public String getGrammarFileName() { return "Java9.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public Java9Parser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class LiteralContext extends ParserRuleContext {
public TerminalNode IntegerLiteral() { return getToken(Java9Parser.IntegerLiteral, 0); }
public TerminalNode FloatingPointLiteral() { return getToken(Java9Parser.FloatingPointLiteral, 0); }
public TerminalNode BooleanLiteral() { return getToken(Java9Parser.BooleanLiteral, 0); }
public TerminalNode CharacterLiteral() { return getToken(Java9Parser.CharacterLiteral, 0); }
public TerminalNode StringLiteral() { return getToken(Java9Parser.StringLiteral, 0); }
public TerminalNode NullLiteral() { return getToken(Java9Parser.NullLiteral, 0); }
public LiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_literal; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitLiteral(this);
}
}
public final LiteralContext literal() throws RecognitionException {
LiteralContext _localctx = new LiteralContext(_ctx, getState());
enterRule(_localctx, 0, RULE_literal);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(500);
_la = _input.LA(1);
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)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PrimitiveTypeContext extends ParserRuleContext {
public NumericTypeContext numericType() {
return getRuleContext(NumericTypeContext.class,0);
}
public List<AnnotationContext> annotation() {
return getRuleContexts(AnnotationContext.class);
}
public AnnotationContext annotation(int i) {
return getRuleContext(AnnotationContext.class,i);
}
public PrimitiveTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primitiveType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPrimitiveType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPrimitiveType(this);
}
}
public final PrimitiveTypeContext primitiveType() throws RecognitionException {
PrimitiveTypeContext _localctx = new PrimitiveTypeContext(_ctx, getState());
enterRule(_localctx, 2, RULE_primitiveType);
int _la;
try {
setState(516);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(505);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(502);
annotation();
}
}
setState(507);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(508);
numericType();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(512);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(509);
annotation();
}
}
setState(514);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(515);
match(BOOLEAN);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NumericTypeContext extends ParserRuleContext {
public IntegralTypeContext integralType() {
return getRuleContext(IntegralTypeContext.class,0);
}
public FloatingPointTypeContext floatingPointType() {
return getRuleContext(FloatingPointTypeContext.class,0);
}
public NumericTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_numericType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterNumericType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitNumericType(this);
}
}
public final NumericTypeContext numericType() throws RecognitionException {
NumericTypeContext _localctx = new NumericTypeContext(_ctx, getState());
enterRule(_localctx, 4, RULE_numericType);
try {
setState(520);
_errHandler.sync(this);
switch (_input.LA(1)) {
case BYTE:
case CHAR:
case INT:
case LONG:
case SHORT:
enterOuterAlt(_localctx, 1);
{
setState(518);
integralType();
}
break;
case DOUBLE:
case FLOAT:
enterOuterAlt(_localctx, 2);
{
setState(519);
floatingPointType();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IntegralTypeContext extends ParserRuleContext {
public IntegralTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_integralType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterIntegralType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitIntegralType(this);
}
}
public final IntegralTypeContext integralType() throws RecognitionException {
IntegralTypeContext _localctx = new IntegralTypeContext(_ctx, getState());
enterRule(_localctx, 6, RULE_integralType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(522);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BYTE) | (1L << CHAR) | (1L << INT) | (1L << LONG) | (1L << SHORT))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FloatingPointTypeContext extends ParserRuleContext {
public FloatingPointTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_floatingPointType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterFloatingPointType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitFloatingPointType(this);
}
}
public final FloatingPointTypeContext floatingPointType() throws RecognitionException {
FloatingPointTypeContext _localctx = new FloatingPointTypeContext(_ctx, getState());
enterRule(_localctx, 8, RULE_floatingPointType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(524);
_la = _input.LA(1);
if ( !(_la==DOUBLE || _la==FLOAT) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ReferenceTypeContext extends ParserRuleContext {
public ClassOrInterfaceTypeContext classOrInterfaceType() {
return getRuleContext(ClassOrInterfaceTypeContext.class,0);
}
public TypeVariableContext typeVariable() {
return getRuleContext(TypeVariableContext.class,0);
}
public ArrayTypeContext arrayType() {
return getRuleContext(ArrayTypeContext.class,0);
}
public ReferenceTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_referenceType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterReferenceType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitReferenceType(this);
}
}
public final ReferenceTypeContext referenceType() throws RecognitionException {
ReferenceTypeContext _localctx = new ReferenceTypeContext(_ctx, getState());
enterRule(_localctx, 10, RULE_referenceType);
try {
setState(529);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(526);
classOrInterfaceType();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(527);
typeVariable();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(528);
arrayType();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassOrInterfaceTypeContext extends ParserRuleContext {
public ClassType_lfno_classOrInterfaceTypeContext classType_lfno_classOrInterfaceType() {
return getRuleContext(ClassType_lfno_classOrInterfaceTypeContext.class,0);
}
public InterfaceType_lfno_classOrInterfaceTypeContext interfaceType_lfno_classOrInterfaceType() {
return getRuleContext(InterfaceType_lfno_classOrInterfaceTypeContext.class,0);
}
public List<ClassType_lf_classOrInterfaceTypeContext> classType_lf_classOrInterfaceType() {
return getRuleContexts(ClassType_lf_classOrInterfaceTypeContext.class);
}
public ClassType_lf_classOrInterfaceTypeContext classType_lf_classOrInterfaceType(int i) {
return getRuleContext(ClassType_lf_classOrInterfaceTypeContext.class,i);
}
public List<InterfaceType_lf_classOrInterfaceTypeContext> interfaceType_lf_classOrInterfaceType() {
return getRuleContexts(InterfaceType_lf_classOrInterfaceTypeContext.class);
}
public InterfaceType_lf_classOrInterfaceTypeContext interfaceType_lf_classOrInterfaceType(int i) {
return getRuleContext(InterfaceType_lf_classOrInterfaceTypeContext.class,i);
}
public ClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classOrInterfaceType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterClassOrInterfaceType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitClassOrInterfaceType(this);
}
}
public final ClassOrInterfaceTypeContext classOrInterfaceType() throws RecognitionException {
ClassOrInterfaceTypeContext _localctx = new ClassOrInterfaceTypeContext(_ctx, getState());
enterRule(_localctx, 12, RULE_classOrInterfaceType);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(533);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
case 1:
{
setState(531);
classType_lfno_classOrInterfaceType();
}
break;
case 2:
{
setState(532);
interfaceType_lfno_classOrInterfaceType();
}
break;
}
setState(539);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,7,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
setState(537);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
case 1:
{
setState(535);
classType_lf_classOrInterfaceType();
}
break;
case 2:
{
setState(536);
interfaceType_lf_classOrInterfaceType();
}
break;
}
}
}
setState(541);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,7,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassTypeContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public List<AnnotationContext> annotation() {
return getRuleContexts(AnnotationContext.class);
}
public AnnotationContext annotation(int i) {
return getRuleContext(AnnotationContext.class,i);
}
public TypeArgumentsContext typeArguments() {
return getRuleContext(TypeArgumentsContext.class,0);
}
public ClassOrInterfaceTypeContext classOrInterfaceType() {
return getRuleContext(ClassOrInterfaceTypeContext.class,0);
}
public ClassTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterClassType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitClassType(this);
}
}
public final ClassTypeContext classType() throws RecognitionException {
ClassTypeContext _localctx = new ClassTypeContext(_ctx, getState());
enterRule(_localctx, 14, RULE_classType);
int _la;
try {
setState(564);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(545);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(542);
annotation();
}
}
setState(547);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(548);
identifier();
setState(550);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(549);
typeArguments();
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(552);
classOrInterfaceType();
setState(553);
match(DOT);
setState(557);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(554);
annotation();
}
}
setState(559);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(560);
identifier();
setState(562);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(561);
typeArguments();
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassType_lf_classOrInterfaceTypeContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public List<AnnotationContext> annotation() {
return getRuleContexts(AnnotationContext.class);
}
public AnnotationContext annotation(int i) {
return getRuleContext(AnnotationContext.class,i);
}
public TypeArgumentsContext typeArguments() {
return getRuleContext(TypeArgumentsContext.class,0);
}
public ClassType_lf_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classType_lf_classOrInterfaceType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterClassType_lf_classOrInterfaceType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitClassType_lf_classOrInterfaceType(this);
}
}
public final ClassType_lf_classOrInterfaceTypeContext classType_lf_classOrInterfaceType() throws RecognitionException {
ClassType_lf_classOrInterfaceTypeContext _localctx = new ClassType_lf_classOrInterfaceTypeContext(_ctx, getState());
enterRule(_localctx, 16, RULE_classType_lf_classOrInterfaceType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(566);
match(DOT);
setState(570);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(567);
annotation();
}
}
setState(572);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(573);
identifier();
setState(575);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
case 1:
{
setState(574);
typeArguments();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassType_lfno_classOrInterfaceTypeContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public List<AnnotationContext> annotation() {
return getRuleContexts(AnnotationContext.class);
}
public AnnotationContext annotation(int i) {
return getRuleContext(AnnotationContext.class,i);
}
public TypeArgumentsContext typeArguments() {
return getRuleContext(TypeArgumentsContext.class,0);
}
public ClassType_lfno_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classType_lfno_classOrInterfaceType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterClassType_lfno_classOrInterfaceType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitClassType_lfno_classOrInterfaceType(this);
}
}
public final ClassType_lfno_classOrInterfaceTypeContext classType_lfno_classOrInterfaceType() throws RecognitionException {
ClassType_lfno_classOrInterfaceTypeContext _localctx = new ClassType_lfno_classOrInterfaceTypeContext(_ctx, getState());
enterRule(_localctx, 18, RULE_classType_lfno_classOrInterfaceType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(580);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(577);
annotation();
}
}
setState(582);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(583);
identifier();
setState(585);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) {
case 1:
{
setState(584);
typeArguments();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InterfaceTypeContext extends ParserRuleContext {
public ClassTypeContext classType() {
return getRuleContext(ClassTypeContext.class,0);
}
public InterfaceTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_interfaceType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInterfaceType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInterfaceType(this);
}
}
public final InterfaceTypeContext interfaceType() throws RecognitionException {
InterfaceTypeContext _localctx = new InterfaceTypeContext(_ctx, getState());
enterRule(_localctx, 20, RULE_interfaceType);
try {
enterOuterAlt(_localctx, 1);
{
setState(587);
classType();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InterfaceType_lf_classOrInterfaceTypeContext extends ParserRuleContext {
public ClassType_lf_classOrInterfaceTypeContext classType_lf_classOrInterfaceType() {
return getRuleContext(ClassType_lf_classOrInterfaceTypeContext.class,0);
}
public InterfaceType_lf_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_interfaceType_lf_classOrInterfaceType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInterfaceType_lf_classOrInterfaceType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInterfaceType_lf_classOrInterfaceType(this);
}
}
public final InterfaceType_lf_classOrInterfaceTypeContext interfaceType_lf_classOrInterfaceType() throws RecognitionException {
InterfaceType_lf_classOrInterfaceTypeContext _localctx = new InterfaceType_lf_classOrInterfaceTypeContext(_ctx, getState());
enterRule(_localctx, 22, RULE_interfaceType_lf_classOrInterfaceType);
try {
enterOuterAlt(_localctx, 1);
{
setState(589);
classType_lf_classOrInterfaceType();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InterfaceType_lfno_classOrInterfaceTypeContext extends ParserRuleContext {
public ClassType_lfno_classOrInterfaceTypeContext classType_lfno_classOrInterfaceType() {
return getRuleContext(ClassType_lfno_classOrInterfaceTypeContext.class,0);
}
public InterfaceType_lfno_classOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_interfaceType_lfno_classOrInterfaceType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInterfaceType_lfno_classOrInterfaceType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInterfaceType_lfno_classOrInterfaceType(this);
}
}
public final InterfaceType_lfno_classOrInterfaceTypeContext interfaceType_lfno_classOrInterfaceType() throws RecognitionException {
InterfaceType_lfno_classOrInterfaceTypeContext _localctx = new InterfaceType_lfno_classOrInterfaceTypeContext(_ctx, getState());
enterRule(_localctx, 24, RULE_interfaceType_lfno_classOrInterfaceType);
try {
enterOuterAlt(_localctx, 1);
{
setState(591);
classType_lfno_classOrInterfaceType();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeVariableContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public List<AnnotationContext> annotation() {
return getRuleContexts(AnnotationContext.class);
}
public AnnotationContext annotation(int i) {
return getRuleContext(AnnotationContext.class,i);
}
public TypeVariableContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeVariable; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeVariable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeVariable(this);
}
}
public final TypeVariableContext typeVariable() throws RecognitionException {
TypeVariableContext _localctx = new TypeVariableContext(_ctx, getState());
enterRule(_localctx, 26, RULE_typeVariable);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(596);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(593);
annotation();
}
}
setState(598);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(599);
identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArrayTypeContext extends ParserRuleContext {
public PrimitiveTypeContext primitiveType() {
return getRuleContext(PrimitiveTypeContext.class,0);
}
public DimsContext dims() {
return getRuleContext(DimsContext.class,0);
}
public ClassOrInterfaceTypeContext classOrInterfaceType() {
return getRuleContext(ClassOrInterfaceTypeContext.class,0);
}
public TypeVariableContext typeVariable() {
return getRuleContext(TypeVariableContext.class,0);
}
public ArrayTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arrayType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterArrayType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitArrayType(this);
}
}
public final ArrayTypeContext arrayType() throws RecognitionException {
ArrayTypeContext _localctx = new ArrayTypeContext(_ctx, getState());
enterRule(_localctx, 28, RULE_arrayType);
try {
setState(610);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(601);
primitiveType();
setState(602);
dims();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(604);
classOrInterfaceType();
setState(605);
dims();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(607);
typeVariable();
setState(608);
dims();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DimsContext extends ParserRuleContext {
public List<AnnotationContext> annotation() {
return getRuleContexts(AnnotationContext.class);
}
public AnnotationContext annotation(int i) {
return getRuleContext(AnnotationContext.class,i);
}
public DimsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dims; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterDims(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitDims(this);
}
}
public final DimsContext dims() throws RecognitionException {
DimsContext _localctx = new DimsContext(_ctx, getState());
enterRule(_localctx, 30, RULE_dims);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(615);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(612);
annotation();
}
}
setState(617);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(618);
match(LBRACK);
setState(619);
match(RBRACK);
setState(630);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,21,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(623);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(620);
annotation();
}
}
setState(625);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(626);
match(LBRACK);
setState(627);
match(RBRACK);
}
}
}
setState(632);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,21,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeParameterContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public List<TypeParameterModifierContext> typeParameterModifier() {
return getRuleContexts(TypeParameterModifierContext.class);
}
public TypeParameterModifierContext typeParameterModifier(int i) {
return getRuleContext(TypeParameterModifierContext.class,i);
}
public TypeBoundContext typeBound() {
return getRuleContext(TypeBoundContext.class,0);
}
public TypeParameterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeParameter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeParameter(this);
}
}
public final TypeParameterContext typeParameter() throws RecognitionException {
TypeParameterContext _localctx = new TypeParameterContext(_ctx, getState());
enterRule(_localctx, 32, RULE_typeParameter);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(636);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(633);
typeParameterModifier();
}
}
setState(638);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(639);
identifier();
setState(641);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXTENDS) {
{
setState(640);
typeBound();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeParameterModifierContext extends ParserRuleContext {
public AnnotationContext annotation() {
return getRuleContext(AnnotationContext.class,0);
}
public TypeParameterModifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeParameterModifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeParameterModifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeParameterModifier(this);
}
}
public final TypeParameterModifierContext typeParameterModifier() throws RecognitionException {
TypeParameterModifierContext _localctx = new TypeParameterModifierContext(_ctx, getState());
enterRule(_localctx, 34, RULE_typeParameterModifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(643);
annotation();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeBoundContext extends ParserRuleContext {
public TypeVariableContext typeVariable() {
return getRuleContext(TypeVariableContext.class,0);
}
public ClassOrInterfaceTypeContext classOrInterfaceType() {
return getRuleContext(ClassOrInterfaceTypeContext.class,0);
}
public List<AdditionalBoundContext> additionalBound() {
return getRuleContexts(AdditionalBoundContext.class);
}
public AdditionalBoundContext additionalBound(int i) {
return getRuleContext(AdditionalBoundContext.class,i);
}
public TypeBoundContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeBound; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeBound(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeBound(this);
}
}
public final TypeBoundContext typeBound() throws RecognitionException {
TypeBoundContext _localctx = new TypeBoundContext(_ctx, getState());
enterRule(_localctx, 36, RULE_typeBound);
int _la;
try {
setState(655);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(645);
match(EXTENDS);
setState(646);
typeVariable();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(647);
match(EXTENDS);
setState(648);
classOrInterfaceType();
setState(652);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==BITAND) {
{
{
setState(649);
additionalBound();
}
}
setState(654);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AdditionalBoundContext extends ParserRuleContext {
public InterfaceTypeContext interfaceType() {
return getRuleContext(InterfaceTypeContext.class,0);
}
public AdditionalBoundContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_additionalBound; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterAdditionalBound(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitAdditionalBound(this);
}
}
public final AdditionalBoundContext additionalBound() throws RecognitionException {
AdditionalBoundContext _localctx = new AdditionalBoundContext(_ctx, getState());
enterRule(_localctx, 38, RULE_additionalBound);
try {
enterOuterAlt(_localctx, 1);
{
setState(657);
match(BITAND);
setState(658);
interfaceType();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeArgumentsContext extends ParserRuleContext {
public TypeArgumentListContext typeArgumentList() {
return getRuleContext(TypeArgumentListContext.class,0);
}
public TypeArgumentsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeArguments; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeArguments(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeArguments(this);
}
}
public final TypeArgumentsContext typeArguments() throws RecognitionException {
TypeArgumentsContext _localctx = new TypeArgumentsContext(_ctx, getState());
enterRule(_localctx, 40, RULE_typeArguments);
try {
enterOuterAlt(_localctx, 1);
{
setState(660);
match(LT);
setState(661);
typeArgumentList();
setState(662);
match(GT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeArgumentListContext extends ParserRuleContext {
public List<TypeArgumentContext> typeArgument() {
return getRuleContexts(TypeArgumentContext.class);
}
public TypeArgumentContext typeArgument(int i) {
return getRuleContext(TypeArgumentContext.class,i);
}
public TypeArgumentListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeArgumentList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeArgumentList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeArgumentList(this);
}
}
public final TypeArgumentListContext typeArgumentList() throws RecognitionException {
TypeArgumentListContext _localctx = new TypeArgumentListContext(_ctx, getState());
enterRule(_localctx, 42, RULE_typeArgumentList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(664);
typeArgument();
setState(669);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(665);
match(COMMA);
setState(666);
typeArgument();
}
}
setState(671);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeArgumentContext extends ParserRuleContext {
public ReferenceTypeContext referenceType() {
return getRuleContext(ReferenceTypeContext.class,0);
}
public WildcardContext wildcard() {
return getRuleContext(WildcardContext.class,0);
}
public TypeArgumentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeArgument; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeArgument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeArgument(this);
}
}
public final TypeArgumentContext typeArgument() throws RecognitionException {
TypeArgumentContext _localctx = new TypeArgumentContext(_ctx, getState());
enterRule(_localctx, 44, RULE_typeArgument);
try {
setState(674);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(672);
referenceType();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(673);
wildcard();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WildcardContext extends ParserRuleContext {
public List<AnnotationContext> annotation() {
return getRuleContexts(AnnotationContext.class);
}
public AnnotationContext annotation(int i) {
return getRuleContext(AnnotationContext.class,i);
}
public WildcardBoundsContext wildcardBounds() {
return getRuleContext(WildcardBoundsContext.class,0);
}
public WildcardContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_wildcard; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterWildcard(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitWildcard(this);
}
}
public final WildcardContext wildcard() throws RecognitionException {
WildcardContext _localctx = new WildcardContext(_ctx, getState());
enterRule(_localctx, 46, RULE_wildcard);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(679);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(676);
annotation();
}
}
setState(681);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(682);
match(QUESTION);
setState(684);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXTENDS || _la==SUPER) {
{
setState(683);
wildcardBounds();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WildcardBoundsContext extends ParserRuleContext {
public ReferenceTypeContext referenceType() {
return getRuleContext(ReferenceTypeContext.class,0);
}
public WildcardBoundsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_wildcardBounds; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterWildcardBounds(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitWildcardBounds(this);
}
}
public final WildcardBoundsContext wildcardBounds() throws RecognitionException {
WildcardBoundsContext _localctx = new WildcardBoundsContext(_ctx, getState());
enterRule(_localctx, 48, RULE_wildcardBounds);
try {
setState(690);
_errHandler.sync(this);
switch (_input.LA(1)) {
case EXTENDS:
enterOuterAlt(_localctx, 1);
{
setState(686);
match(EXTENDS);
setState(687);
referenceType();
}
break;
case SUPER:
enterOuterAlt(_localctx, 2);
{
setState(688);
match(SUPER);
setState(689);
referenceType();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ModuleNameContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ModuleNameContext moduleName() {
return getRuleContext(ModuleNameContext.class,0);
}
public ModuleNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_moduleName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterModuleName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitModuleName(this);
}
}
public final ModuleNameContext moduleName() throws RecognitionException {
return moduleName(0);
}
private ModuleNameContext moduleName(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ModuleNameContext _localctx = new ModuleNameContext(_ctx, _parentState);
ModuleNameContext _prevctx = _localctx;
int _startState = 50;
enterRecursionRule(_localctx, 50, RULE_moduleName, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(693);
identifier();
}
_ctx.stop = _input.LT(-1);
setState(700);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,31,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new ModuleNameContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_moduleName);
setState(695);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(696);
match(DOT);
setState(697);
identifier();
}
}
}
setState(702);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,31,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class PackageNameContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public PackageNameContext packageName() {
return getRuleContext(PackageNameContext.class,0);
}
public PackageNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_packageName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPackageName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPackageName(this);
}
}
public final PackageNameContext packageName() throws RecognitionException {
return packageName(0);
}
private PackageNameContext packageName(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
PackageNameContext _localctx = new PackageNameContext(_ctx, _parentState);
PackageNameContext _prevctx = _localctx;
int _startState = 52;
enterRecursionRule(_localctx, 52, RULE_packageName, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(704);
identifier();
}
_ctx.stop = _input.LT(-1);
setState(711);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,32,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new PackageNameContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_packageName);
setState(706);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(707);
match(DOT);
setState(708);
identifier();
}
}
}
setState(713);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,32,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class TypeNameContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public PackageOrTypeNameContext packageOrTypeName() {
return getRuleContext(PackageOrTypeNameContext.class,0);
}
public TypeNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeName(this);
}
}
public final TypeNameContext typeName() throws RecognitionException {
TypeNameContext _localctx = new TypeNameContext(_ctx, getState());
enterRule(_localctx, 54, RULE_typeName);
try {
setState(719);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(714);
identifier();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(715);
packageOrTypeName(0);
setState(716);
match(DOT);
setState(717);
identifier();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PackageOrTypeNameContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public PackageOrTypeNameContext packageOrTypeName() {
return getRuleContext(PackageOrTypeNameContext.class,0);
}
public PackageOrTypeNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_packageOrTypeName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPackageOrTypeName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPackageOrTypeName(this);
}
}
public final PackageOrTypeNameContext packageOrTypeName() throws RecognitionException {
return packageOrTypeName(0);
}
private PackageOrTypeNameContext packageOrTypeName(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
PackageOrTypeNameContext _localctx = new PackageOrTypeNameContext(_ctx, _parentState);
PackageOrTypeNameContext _prevctx = _localctx;
int _startState = 56;
enterRecursionRule(_localctx, 56, RULE_packageOrTypeName, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(722);
identifier();
}
_ctx.stop = _input.LT(-1);
setState(729);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,34,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new PackageOrTypeNameContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_packageOrTypeName);
setState(724);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(725);
match(DOT);
setState(726);
identifier();
}
}
}
setState(731);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,34,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class ExpressionNameContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public AmbiguousNameContext ambiguousName() {
return getRuleContext(AmbiguousNameContext.class,0);
}
public ExpressionNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterExpressionName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitExpressionName(this);
}
}
public final ExpressionNameContext expressionName() throws RecognitionException {
ExpressionNameContext _localctx = new ExpressionNameContext(_ctx, getState());
enterRule(_localctx, 58, RULE_expressionName);
try {
setState(737);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(732);
identifier();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(733);
ambiguousName(0);
setState(734);
match(DOT);
setState(735);
identifier();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MethodNameContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public MethodNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_methodName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterMethodName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitMethodName(this);
}
}
public final MethodNameContext methodName() throws RecognitionException {
MethodNameContext _localctx = new MethodNameContext(_ctx, getState());
enterRule(_localctx, 60, RULE_methodName);
try {
enterOuterAlt(_localctx, 1);
{
setState(739);
identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AmbiguousNameContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public AmbiguousNameContext ambiguousName() {
return getRuleContext(AmbiguousNameContext.class,0);
}
public AmbiguousNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ambiguousName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterAmbiguousName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitAmbiguousName(this);
}
}
public final AmbiguousNameContext ambiguousName() throws RecognitionException {
return ambiguousName(0);
}
private AmbiguousNameContext ambiguousName(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
AmbiguousNameContext _localctx = new AmbiguousNameContext(_ctx, _parentState);
AmbiguousNameContext _prevctx = _localctx;
int _startState = 62;
enterRecursionRule(_localctx, 62, RULE_ambiguousName, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(742);
identifier();
}
_ctx.stop = _input.LT(-1);
setState(749);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,36,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new AmbiguousNameContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_ambiguousName);
setState(744);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(745);
match(DOT);
setState(746);
identifier();
}
}
}
setState(751);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,36,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class CompilationUnitContext extends ParserRuleContext {
public OrdinaryCompilationContext ordinaryCompilation() {
return getRuleContext(OrdinaryCompilationContext.class,0);
}
public ModularCompilationContext modularCompilation() {
return getRuleContext(ModularCompilationContext.class,0);
}
public CompilationUnitContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_compilationUnit; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterCompilationUnit(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitCompilationUnit(this);
}
}
public final CompilationUnitContext compilationUnit() throws RecognitionException {
CompilationUnitContext _localctx = new CompilationUnitContext(_ctx, getState());
enterRule(_localctx, 64, RULE_compilationUnit);
try {
setState(754);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(752);
ordinaryCompilation();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(753);
modularCompilation();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OrdinaryCompilationContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(Java9Parser.EOF, 0); }
public PackageDeclarationContext packageDeclaration() {
return getRuleContext(PackageDeclarationContext.class,0);
}
public List<ImportDeclarationContext> importDeclaration() {
return getRuleContexts(ImportDeclarationContext.class);
}
public ImportDeclarationContext importDeclaration(int i) {
return getRuleContext(ImportDeclarationContext.class,i);
}
public List<TypeDeclarationContext> typeDeclaration() {
return getRuleContexts(TypeDeclarationContext.class);
}
public TypeDeclarationContext typeDeclaration(int i) {
return getRuleContext(TypeDeclarationContext.class,i);
}
public OrdinaryCompilationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ordinaryCompilation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterOrdinaryCompilation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitOrdinaryCompilation(this);
}
}
public final OrdinaryCompilationContext ordinaryCompilation() throws RecognitionException {
OrdinaryCompilationContext _localctx = new OrdinaryCompilationContext(_ctx, getState());
enterRule(_localctx, 66, RULE_ordinaryCompilation);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(757);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,38,_ctx) ) {
case 1:
{
setState(756);
packageDeclaration();
}
break;
}
setState(762);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==IMPORT) {
{
{
setState(759);
importDeclaration();
}
}
setState(764);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(768);
_errHandler.sync(this);
_la = _input.LA(1);
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) {
{
{
setState(765);
typeDeclaration();
}
}
setState(770);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(771);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ModularCompilationContext extends ParserRuleContext {
public ModuleDeclarationContext moduleDeclaration() {
return getRuleContext(ModuleDeclarationContext.class,0);
}
public List<ImportDeclarationContext> importDeclaration() {
return getRuleContexts(ImportDeclarationContext.class);
}
public ImportDeclarationContext importDeclaration(int i) {
return getRuleContext(ImportDeclarationContext.class,i);
}
public ModularCompilationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_modularCompilation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterModularCompilation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitModularCompilation(this);
}
}
public final ModularCompilationContext modularCompilation() throws RecognitionException {
ModularCompilationContext _localctx = new ModularCompilationContext(_ctx, getState());
enterRule(_localctx, 68, RULE_modularCompilation);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(776);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==IMPORT) {
{
{
setState(773);
importDeclaration();
}
}
setState(778);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(779);
moduleDeclaration();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PackageDeclarationContext extends ParserRuleContext {
public PackageNameContext packageName() {
return getRuleContext(PackageNameContext.class,0);
}
public List<PackageModifierContext> packageModifier() {
return getRuleContexts(PackageModifierContext.class);
}
public PackageModifierContext packageModifier(int i) {
return getRuleContext(PackageModifierContext.class,i);
}
public PackageDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_packageDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPackageDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPackageDeclaration(this);
}
}
public final PackageDeclarationContext packageDeclaration() throws RecognitionException {
PackageDeclarationContext _localctx = new PackageDeclarationContext(_ctx, getState());
enterRule(_localctx, 70, RULE_packageDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(784);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(781);
packageModifier();
}
}
setState(786);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(787);
match(PACKAGE);
setState(788);
packageName(0);
setState(789);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PackageModifierContext extends ParserRuleContext {
public AnnotationContext annotation() {
return getRuleContext(AnnotationContext.class,0);
}
public PackageModifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_packageModifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPackageModifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPackageModifier(this);
}
}
public final PackageModifierContext packageModifier() throws RecognitionException {
PackageModifierContext _localctx = new PackageModifierContext(_ctx, getState());
enterRule(_localctx, 72, RULE_packageModifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(791);
annotation();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ImportDeclarationContext extends ParserRuleContext {
public SingleTypeImportDeclarationContext singleTypeImportDeclaration() {
return getRuleContext(SingleTypeImportDeclarationContext.class,0);
}
public TypeImportOnDemandDeclarationContext typeImportOnDemandDeclaration() {
return getRuleContext(TypeImportOnDemandDeclarationContext.class,0);
}
public SingleStaticImportDeclarationContext singleStaticImportDeclaration() {
return getRuleContext(SingleStaticImportDeclarationContext.class,0);
}
public StaticImportOnDemandDeclarationContext staticImportOnDemandDeclaration() {
return getRuleContext(StaticImportOnDemandDeclarationContext.class,0);
}
public ImportDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_importDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterImportDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitImportDeclaration(this);
}
}
public final ImportDeclarationContext importDeclaration() throws RecognitionException {
ImportDeclarationContext _localctx = new ImportDeclarationContext(_ctx, getState());
enterRule(_localctx, 74, RULE_importDeclaration);
try {
setState(797);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,43,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(793);
singleTypeImportDeclaration();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(794);
typeImportOnDemandDeclaration();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(795);
singleStaticImportDeclaration();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(796);
staticImportOnDemandDeclaration();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SingleTypeImportDeclarationContext extends ParserRuleContext {
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public SingleTypeImportDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_singleTypeImportDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterSingleTypeImportDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitSingleTypeImportDeclaration(this);
}
}
public final SingleTypeImportDeclarationContext singleTypeImportDeclaration() throws RecognitionException {
SingleTypeImportDeclarationContext _localctx = new SingleTypeImportDeclarationContext(_ctx, getState());
enterRule(_localctx, 76, RULE_singleTypeImportDeclaration);
try {
enterOuterAlt(_localctx, 1);
{
setState(799);
match(IMPORT);
setState(800);
typeName();
setState(801);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeImportOnDemandDeclarationContext extends ParserRuleContext {
public PackageOrTypeNameContext packageOrTypeName() {
return getRuleContext(PackageOrTypeNameContext.class,0);
}
public TypeImportOnDemandDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeImportOnDemandDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeImportOnDemandDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeImportOnDemandDeclaration(this);
}
}
public final TypeImportOnDemandDeclarationContext typeImportOnDemandDeclaration() throws RecognitionException {
TypeImportOnDemandDeclarationContext _localctx = new TypeImportOnDemandDeclarationContext(_ctx, getState());
enterRule(_localctx, 78, RULE_typeImportOnDemandDeclaration);
try {
enterOuterAlt(_localctx, 1);
{
setState(803);
match(IMPORT);
setState(804);
packageOrTypeName(0);
setState(805);
match(DOT);
setState(806);
match(MUL);
setState(807);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SingleStaticImportDeclarationContext extends ParserRuleContext {
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public SingleStaticImportDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_singleStaticImportDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterSingleStaticImportDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitSingleStaticImportDeclaration(this);
}
}
public final SingleStaticImportDeclarationContext singleStaticImportDeclaration() throws RecognitionException {
SingleStaticImportDeclarationContext _localctx = new SingleStaticImportDeclarationContext(_ctx, getState());
enterRule(_localctx, 80, RULE_singleStaticImportDeclaration);
try {
enterOuterAlt(_localctx, 1);
{
setState(809);
match(IMPORT);
setState(810);
match(STATIC);
setState(811);
typeName();
setState(812);
match(DOT);
setState(813);
identifier();
setState(814);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StaticImportOnDemandDeclarationContext extends ParserRuleContext {
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public StaticImportOnDemandDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_staticImportOnDemandDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterStaticImportOnDemandDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitStaticImportOnDemandDeclaration(this);
}
}
public final StaticImportOnDemandDeclarationContext staticImportOnDemandDeclaration() throws RecognitionException {
StaticImportOnDemandDeclarationContext _localctx = new StaticImportOnDemandDeclarationContext(_ctx, getState());
enterRule(_localctx, 82, RULE_staticImportOnDemandDeclaration);
try {
enterOuterAlt(_localctx, 1);
{
setState(816);
match(IMPORT);
setState(817);
match(STATIC);
setState(818);
typeName();
setState(819);
match(DOT);
setState(820);
match(MUL);
setState(821);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeDeclarationContext extends ParserRuleContext {
public ClassDeclarationContext classDeclaration() {
return getRuleContext(ClassDeclarationContext.class,0);
}
public InterfaceDeclarationContext interfaceDeclaration() {
return getRuleContext(InterfaceDeclarationContext.class,0);
}
public TypeDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeDeclaration(this);
}
}
public final TypeDeclarationContext typeDeclaration() throws RecognitionException {
TypeDeclarationContext _localctx = new TypeDeclarationContext(_ctx, getState());
enterRule(_localctx, 84, RULE_typeDeclaration);
try {
setState(826);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(823);
classDeclaration();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(824);
interfaceDeclaration();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(825);
match(SEMI);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ModuleDeclarationContext extends ParserRuleContext {
public ModuleNameContext moduleName() {
return getRuleContext(ModuleNameContext.class,0);
}
public List<AnnotationContext> annotation() {
return getRuleContexts(AnnotationContext.class);
}
public AnnotationContext annotation(int i) {
return getRuleContext(AnnotationContext.class,i);
}
public List<ModuleDirectiveContext> moduleDirective() {
return getRuleContexts(ModuleDirectiveContext.class);
}
public ModuleDirectiveContext moduleDirective(int i) {
return getRuleContext(ModuleDirectiveContext.class,i);
}
public ModuleDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_moduleDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterModuleDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitModuleDeclaration(this);
}
}
public final ModuleDeclarationContext moduleDeclaration() throws RecognitionException {
ModuleDeclarationContext _localctx = new ModuleDeclarationContext(_ctx, getState());
enterRule(_localctx, 86, RULE_moduleDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(831);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(828);
annotation();
}
}
setState(833);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(835);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__0) {
{
setState(834);
match(T__0);
}
}
setState(837);
match(T__1);
setState(838);
moduleName(0);
setState(839);
match(LBRACE);
setState(843);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__2) | (1L << T__3) | (1L << T__5) | (1L << T__6) | (1L << T__7))) != 0)) {
{
{
setState(840);
moduleDirective();
}
}
setState(845);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(846);
match(RBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ModuleDirectiveContext extends ParserRuleContext {
public RequiresDirectiveContext requiresDirective() {
return getRuleContext(RequiresDirectiveContext.class,0);
}
public ExportsDirectiveContext exportsDirective() {
return getRuleContext(ExportsDirectiveContext.class,0);
}
public OpensDirectiveContext opensDirective() {
return getRuleContext(OpensDirectiveContext.class,0);
}
public UsesDirectiveContext usesDirective() {
return getRuleContext(UsesDirectiveContext.class,0);
}
public ProvidesDirectiveContext providesDirective() {
return getRuleContext(ProvidesDirectiveContext.class,0);
}
public ModuleDirectiveContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_moduleDirective; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterModuleDirective(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitModuleDirective(this);
}
}
public final ModuleDirectiveContext moduleDirective() throws RecognitionException {
ModuleDirectiveContext _localctx = new ModuleDirectiveContext(_ctx, getState());
enterRule(_localctx, 88, RULE_moduleDirective);
try {
setState(853);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__2:
enterOuterAlt(_localctx, 1);
{
setState(848);
requiresDirective();
}
break;
case T__3:
enterOuterAlt(_localctx, 2);
{
setState(849);
exportsDirective();
}
break;
case T__5:
enterOuterAlt(_localctx, 3);
{
setState(850);
opensDirective();
}
break;
case T__6:
enterOuterAlt(_localctx, 4);
{
setState(851);
usesDirective();
}
break;
case T__7:
enterOuterAlt(_localctx, 5);
{
setState(852);
providesDirective();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RequiresDirectiveContext extends ParserRuleContext {
public ModuleNameContext moduleName() {
return getRuleContext(ModuleNameContext.class,0);
}
public List<RequiresModifierContext> requiresModifier() {
return getRuleContexts(RequiresModifierContext.class);
}
public RequiresModifierContext requiresModifier(int i) {
return getRuleContext(RequiresModifierContext.class,i);
}
public RequiresDirectiveContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_requiresDirective; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterRequiresDirective(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitRequiresDirective(this);
}
}
public final RequiresDirectiveContext requiresDirective() throws RecognitionException {
RequiresDirectiveContext _localctx = new RequiresDirectiveContext(_ctx, getState());
enterRule(_localctx, 90, RULE_requiresDirective);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(855);
match(T__2);
setState(859);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__9 || _la==STATIC) {
{
{
setState(856);
requiresModifier();
}
}
setState(861);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(862);
moduleName(0);
setState(863);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExportsDirectiveContext extends ParserRuleContext {
public PackageNameContext packageName() {
return getRuleContext(PackageNameContext.class,0);
}
public List<ModuleNameContext> moduleName() {
return getRuleContexts(ModuleNameContext.class);
}
public ModuleNameContext moduleName(int i) {
return getRuleContext(ModuleNameContext.class,i);
}
public ExportsDirectiveContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_exportsDirective; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterExportsDirective(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitExportsDirective(this);
}
}
public final ExportsDirectiveContext exportsDirective() throws RecognitionException {
ExportsDirectiveContext _localctx = new ExportsDirectiveContext(_ctx, getState());
enterRule(_localctx, 92, RULE_exportsDirective);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(865);
match(T__3);
setState(866);
packageName(0);
setState(876);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__4) {
{
setState(867);
match(T__4);
setState(868);
moduleName(0);
setState(873);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(869);
match(COMMA);
setState(870);
moduleName(0);
}
}
setState(875);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(878);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OpensDirectiveContext extends ParserRuleContext {
public PackageNameContext packageName() {
return getRuleContext(PackageNameContext.class,0);
}
public List<ModuleNameContext> moduleName() {
return getRuleContexts(ModuleNameContext.class);
}
public ModuleNameContext moduleName(int i) {
return getRuleContext(ModuleNameContext.class,i);
}
public OpensDirectiveContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_opensDirective; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterOpensDirective(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitOpensDirective(this);
}
}
public final OpensDirectiveContext opensDirective() throws RecognitionException {
OpensDirectiveContext _localctx = new OpensDirectiveContext(_ctx, getState());
enterRule(_localctx, 94, RULE_opensDirective);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(880);
match(T__5);
setState(881);
packageName(0);
setState(891);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__4) {
{
setState(882);
match(T__4);
setState(883);
moduleName(0);
setState(888);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(884);
match(COMMA);
setState(885);
moduleName(0);
}
}
setState(890);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(893);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UsesDirectiveContext extends ParserRuleContext {
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public UsesDirectiveContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_usesDirective; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUsesDirective(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUsesDirective(this);
}
}
public final UsesDirectiveContext usesDirective() throws RecognitionException {
UsesDirectiveContext _localctx = new UsesDirectiveContext(_ctx, getState());
enterRule(_localctx, 96, RULE_usesDirective);
try {
enterOuterAlt(_localctx, 1);
{
setState(895);
match(T__6);
setState(896);
typeName();
setState(897);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ProvidesDirectiveContext extends ParserRuleContext {
public List<TypeNameContext> typeName() {
return getRuleContexts(TypeNameContext.class);
}
public TypeNameContext typeName(int i) {
return getRuleContext(TypeNameContext.class,i);
}
public ProvidesDirectiveContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_providesDirective; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterProvidesDirective(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitProvidesDirective(this);
}
}
public final ProvidesDirectiveContext providesDirective() throws RecognitionException {
ProvidesDirectiveContext _localctx = new ProvidesDirectiveContext(_ctx, getState());
enterRule(_localctx, 98, RULE_providesDirective);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(899);
match(T__7);
setState(900);
typeName();
setState(901);
match(T__8);
setState(902);
typeName();
setState(907);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(903);
match(COMMA);
setState(904);
typeName();
}
}
setState(909);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(910);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RequiresModifierContext extends ParserRuleContext {
public RequiresModifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_requiresModifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterRequiresModifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitRequiresModifier(this);
}
}
public final RequiresModifierContext requiresModifier() throws RecognitionException {
RequiresModifierContext _localctx = new RequiresModifierContext(_ctx, getState());
enterRule(_localctx, 100, RULE_requiresModifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(912);
_la = _input.LA(1);
if ( !(_la==T__9 || _la==STATIC) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassDeclarationContext extends ParserRuleContext {
public NormalClassDeclarationContext normalClassDeclaration() {
return getRuleContext(NormalClassDeclarationContext.class,0);
}
public EnumDeclarationContext enumDeclaration() {
return getRuleContext(EnumDeclarationContext.class,0);
}
public ClassDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterClassDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitClassDeclaration(this);
}
}
public final ClassDeclarationContext classDeclaration() throws RecognitionException {
ClassDeclarationContext _localctx = new ClassDeclarationContext(_ctx, getState());
enterRule(_localctx, 102, RULE_classDeclaration);
try {
setState(916);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(914);
normalClassDeclaration();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(915);
enumDeclaration();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NormalClassDeclarationContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ClassBodyContext classBody() {
return getRuleContext(ClassBodyContext.class,0);
}
public List<ClassModifierContext> classModifier() {
return getRuleContexts(ClassModifierContext.class);
}
public ClassModifierContext classModifier(int i) {
return getRuleContext(ClassModifierContext.class,i);
}
public TypeParametersContext typeParameters() {
return getRuleContext(TypeParametersContext.class,0);
}
public SuperclassContext superclass() {
return getRuleContext(SuperclassContext.class,0);
}
public SuperinterfacesContext superinterfaces() {
return getRuleContext(SuperinterfacesContext.class,0);
}
public NormalClassDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_normalClassDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterNormalClassDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitNormalClassDeclaration(this);
}
}
public final NormalClassDeclarationContext normalClassDeclaration() throws RecognitionException {
NormalClassDeclarationContext _localctx = new NormalClassDeclarationContext(_ctx, getState());
enterRule(_localctx, 104, RULE_normalClassDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(921);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) {
{
{
setState(918);
classModifier();
}
}
setState(923);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(924);
match(CLASS);
setState(925);
identifier();
setState(927);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(926);
typeParameters();
}
}
setState(930);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXTENDS) {
{
setState(929);
superclass();
}
}
setState(933);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IMPLEMENTS) {
{
setState(932);
superinterfaces();
}
}
setState(935);
classBody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassModifierContext extends ParserRuleContext {
public AnnotationContext annotation() {
return getRuleContext(AnnotationContext.class,0);
}
public ClassModifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classModifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterClassModifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitClassModifier(this);
}
}
public final ClassModifierContext classModifier() throws RecognitionException {
ClassModifierContext _localctx = new ClassModifierContext(_ctx, getState());
enterRule(_localctx, 106, RULE_classModifier);
try {
setState(945);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AT:
enterOuterAlt(_localctx, 1);
{
setState(937);
annotation();
}
break;
case PUBLIC:
enterOuterAlt(_localctx, 2);
{
setState(938);
match(PUBLIC);
}
break;
case PROTECTED:
enterOuterAlt(_localctx, 3);
{
setState(939);
match(PROTECTED);
}
break;
case PRIVATE:
enterOuterAlt(_localctx, 4);
{
setState(940);
match(PRIVATE);
}
break;
case ABSTRACT:
enterOuterAlt(_localctx, 5);
{
setState(941);
match(ABSTRACT);
}
break;
case STATIC:
enterOuterAlt(_localctx, 6);
{
setState(942);
match(STATIC);
}
break;
case FINAL:
enterOuterAlt(_localctx, 7);
{
setState(943);
match(FINAL);
}
break;
case STRICTFP:
enterOuterAlt(_localctx, 8);
{
setState(944);
match(STRICTFP);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeParametersContext extends ParserRuleContext {
public TypeParameterListContext typeParameterList() {
return getRuleContext(TypeParameterListContext.class,0);
}
public TypeParametersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeParameters; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeParameters(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeParameters(this);
}
}
public final TypeParametersContext typeParameters() throws RecognitionException {
TypeParametersContext _localctx = new TypeParametersContext(_ctx, getState());
enterRule(_localctx, 108, RULE_typeParameters);
try {
enterOuterAlt(_localctx, 1);
{
setState(947);
match(LT);
setState(948);
typeParameterList();
setState(949);
match(GT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeParameterListContext extends ParserRuleContext {
public List<TypeParameterContext> typeParameter() {
return getRuleContexts(TypeParameterContext.class);
}
public TypeParameterContext typeParameter(int i) {
return getRuleContext(TypeParameterContext.class,i);
}
public TypeParameterListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeParameterList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeParameterList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeParameterList(this);
}
}
public final TypeParameterListContext typeParameterList() throws RecognitionException {
TypeParameterListContext _localctx = new TypeParameterListContext(_ctx, getState());
enterRule(_localctx, 110, RULE_typeParameterList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(951);
typeParameter();
setState(956);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(952);
match(COMMA);
setState(953);
typeParameter();
}
}
setState(958);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SuperclassContext extends ParserRuleContext {
public ClassTypeContext classType() {
return getRuleContext(ClassTypeContext.class,0);
}
public SuperclassContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_superclass; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterSuperclass(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitSuperclass(this);
}
}
public final SuperclassContext superclass() throws RecognitionException {
SuperclassContext _localctx = new SuperclassContext(_ctx, getState());
enterRule(_localctx, 112, RULE_superclass);
try {
enterOuterAlt(_localctx, 1);
{
setState(959);
match(EXTENDS);
setState(960);
classType();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SuperinterfacesContext extends ParserRuleContext {
public InterfaceTypeListContext interfaceTypeList() {
return getRuleContext(InterfaceTypeListContext.class,0);
}
public SuperinterfacesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_superinterfaces; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterSuperinterfaces(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitSuperinterfaces(this);
}
}
public final SuperinterfacesContext superinterfaces() throws RecognitionException {
SuperinterfacesContext _localctx = new SuperinterfacesContext(_ctx, getState());
enterRule(_localctx, 114, RULE_superinterfaces);
try {
enterOuterAlt(_localctx, 1);
{
setState(962);
match(IMPLEMENTS);
setState(963);
interfaceTypeList();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InterfaceTypeListContext extends ParserRuleContext {
public List<InterfaceTypeContext> interfaceType() {
return getRuleContexts(InterfaceTypeContext.class);
}
public InterfaceTypeContext interfaceType(int i) {
return getRuleContext(InterfaceTypeContext.class,i);
}
public InterfaceTypeListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_interfaceTypeList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInterfaceTypeList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInterfaceTypeList(this);
}
}
public final InterfaceTypeListContext interfaceTypeList() throws RecognitionException {
InterfaceTypeListContext _localctx = new InterfaceTypeListContext(_ctx, getState());
enterRule(_localctx, 116, RULE_interfaceTypeList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(965);
interfaceType();
setState(970);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(966);
match(COMMA);
setState(967);
interfaceType();
}
}
setState(972);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassBodyContext extends ParserRuleContext {
public List<ClassBodyDeclarationContext> classBodyDeclaration() {
return getRuleContexts(ClassBodyDeclarationContext.class);
}
public ClassBodyDeclarationContext classBodyDeclaration(int i) {
return getRuleContext(ClassBodyDeclarationContext.class,i);
}
public ClassBodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classBody; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterClassBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitClassBody(this);
}
}
public final ClassBodyContext classBody() throws RecognitionException {
ClassBodyContext _localctx = new ClassBodyContext(_ctx, getState());
enterRule(_localctx, 118, RULE_classBody);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(973);
match(LBRACE);
setState(977);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
{
setState(974);
classBodyDeclaration();
}
}
setState(979);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(980);
match(RBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassBodyDeclarationContext extends ParserRuleContext {
public ClassMemberDeclarationContext classMemberDeclaration() {
return getRuleContext(ClassMemberDeclarationContext.class,0);
}
public InstanceInitializerContext instanceInitializer() {
return getRuleContext(InstanceInitializerContext.class,0);
}
public StaticInitializerContext staticInitializer() {
return getRuleContext(StaticInitializerContext.class,0);
}
public ConstructorDeclarationContext constructorDeclaration() {
return getRuleContext(ConstructorDeclarationContext.class,0);
}
public ClassBodyDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classBodyDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterClassBodyDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitClassBodyDeclaration(this);
}
}
public final ClassBodyDeclarationContext classBodyDeclaration() throws RecognitionException {
ClassBodyDeclarationContext _localctx = new ClassBodyDeclarationContext(_ctx, getState());
enterRule(_localctx, 120, RULE_classBodyDeclaration);
try {
setState(986);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,64,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(982);
classMemberDeclaration();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(983);
instanceInitializer();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(984);
staticInitializer();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(985);
constructorDeclaration();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassMemberDeclarationContext extends ParserRuleContext {
public FieldDeclarationContext fieldDeclaration() {
return getRuleContext(FieldDeclarationContext.class,0);
}
public MethodDeclarationContext methodDeclaration() {
return getRuleContext(MethodDeclarationContext.class,0);
}
public ClassDeclarationContext classDeclaration() {
return getRuleContext(ClassDeclarationContext.class,0);
}
public InterfaceDeclarationContext interfaceDeclaration() {
return getRuleContext(InterfaceDeclarationContext.class,0);
}
public ClassMemberDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classMemberDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterClassMemberDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitClassMemberDeclaration(this);
}
}
public final ClassMemberDeclarationContext classMemberDeclaration() throws RecognitionException {
ClassMemberDeclarationContext _localctx = new ClassMemberDeclarationContext(_ctx, getState());
enterRule(_localctx, 122, RULE_classMemberDeclaration);
try {
setState(993);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(988);
fieldDeclaration();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(989);
methodDeclaration();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(990);
classDeclaration();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(991);
interfaceDeclaration();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(992);
match(SEMI);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FieldDeclarationContext extends ParserRuleContext {
public UnannTypeContext unannType() {
return getRuleContext(UnannTypeContext.class,0);
}
public VariableDeclaratorListContext variableDeclaratorList() {
return getRuleContext(VariableDeclaratorListContext.class,0);
}
public List<FieldModifierContext> fieldModifier() {
return getRuleContexts(FieldModifierContext.class);
}
public FieldModifierContext fieldModifier(int i) {
return getRuleContext(FieldModifierContext.class,i);
}
public FieldDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fieldDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterFieldDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitFieldDeclaration(this);
}
}
public final FieldDeclarationContext fieldDeclaration() throws RecognitionException {
FieldDeclarationContext _localctx = new FieldDeclarationContext(_ctx, getState());
enterRule(_localctx, 124, RULE_fieldDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(998);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
{
setState(995);
fieldModifier();
}
}
setState(1000);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1001);
unannType();
setState(1002);
variableDeclaratorList();
setState(1003);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FieldModifierContext extends ParserRuleContext {
public AnnotationContext annotation() {
return getRuleContext(AnnotationContext.class,0);
}
public FieldModifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fieldModifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterFieldModifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitFieldModifier(this);
}
}
public final FieldModifierContext fieldModifier() throws RecognitionException {
FieldModifierContext _localctx = new FieldModifierContext(_ctx, getState());
enterRule(_localctx, 126, RULE_fieldModifier);
try {
setState(1013);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AT:
enterOuterAlt(_localctx, 1);
{
setState(1005);
annotation();
}
break;
case PUBLIC:
enterOuterAlt(_localctx, 2);
{
setState(1006);
match(PUBLIC);
}
break;
case PROTECTED:
enterOuterAlt(_localctx, 3);
{
setState(1007);
match(PROTECTED);
}
break;
case PRIVATE:
enterOuterAlt(_localctx, 4);
{
setState(1008);
match(PRIVATE);
}
break;
case STATIC:
enterOuterAlt(_localctx, 5);
{
setState(1009);
match(STATIC);
}
break;
case FINAL:
enterOuterAlt(_localctx, 6);
{
setState(1010);
match(FINAL);
}
break;
case TRANSIENT:
enterOuterAlt(_localctx, 7);
{
setState(1011);
match(TRANSIENT);
}
break;
case VOLATILE:
enterOuterAlt(_localctx, 8);
{
setState(1012);
match(VOLATILE);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VariableDeclaratorListContext extends ParserRuleContext {
public List<VariableDeclaratorContext> variableDeclarator() {
return getRuleContexts(VariableDeclaratorContext.class);
}
public VariableDeclaratorContext variableDeclarator(int i) {
return getRuleContext(VariableDeclaratorContext.class,i);
}
public VariableDeclaratorListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_variableDeclaratorList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterVariableDeclaratorList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitVariableDeclaratorList(this);
}
}
public final VariableDeclaratorListContext variableDeclaratorList() throws RecognitionException {
VariableDeclaratorListContext _localctx = new VariableDeclaratorListContext(_ctx, getState());
enterRule(_localctx, 128, RULE_variableDeclaratorList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1015);
variableDeclarator();
setState(1020);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1016);
match(COMMA);
setState(1017);
variableDeclarator();
}
}
setState(1022);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VariableDeclaratorContext extends ParserRuleContext {
public VariableDeclaratorIdContext variableDeclaratorId() {
return getRuleContext(VariableDeclaratorIdContext.class,0);
}
public VariableInitializerContext variableInitializer() {
return getRuleContext(VariableInitializerContext.class,0);
}
public VariableDeclaratorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_variableDeclarator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterVariableDeclarator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitVariableDeclarator(this);
}
}
public final VariableDeclaratorContext variableDeclarator() throws RecognitionException {
VariableDeclaratorContext _localctx = new VariableDeclaratorContext(_ctx, getState());
enterRule(_localctx, 130, RULE_variableDeclarator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1023);
variableDeclaratorId();
setState(1026);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ASSIGN) {
{
setState(1024);
match(ASSIGN);
setState(1025);
variableInitializer();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VariableDeclaratorIdContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public DimsContext dims() {
return getRuleContext(DimsContext.class,0);
}
public VariableDeclaratorIdContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_variableDeclaratorId; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterVariableDeclaratorId(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitVariableDeclaratorId(this);
}
}
public final VariableDeclaratorIdContext variableDeclaratorId() throws RecognitionException {
VariableDeclaratorIdContext _localctx = new VariableDeclaratorIdContext(_ctx, getState());
enterRule(_localctx, 132, RULE_variableDeclaratorId);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1028);
identifier();
setState(1030);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LBRACK || _la==AT) {
{
setState(1029);
dims();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VariableInitializerContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ArrayInitializerContext arrayInitializer() {
return getRuleContext(ArrayInitializerContext.class,0);
}
public VariableInitializerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_variableInitializer; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterVariableInitializer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitVariableInitializer(this);
}
}
public final VariableInitializerContext variableInitializer() throws RecognitionException {
VariableInitializerContext _localctx = new VariableInitializerContext(_ctx, getState());
enterRule(_localctx, 134, RULE_variableInitializer);
try {
setState(1034);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__0:
case T__1:
case T__2:
case T__3:
case T__4:
case T__5:
case T__6:
case T__7:
case T__8:
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case NEW:
case SHORT:
case SUPER:
case THIS:
case VOID:
case IntegerLiteral:
case FloatingPointLiteral:
case BooleanLiteral:
case CharacterLiteral:
case StringLiteral:
case NullLiteral:
case LPAREN:
case AT:
case BANG:
case TILDE:
case INC:
case DEC:
case ADD:
case SUB:
case Identifier:
enterOuterAlt(_localctx, 1);
{
setState(1032);
expression();
}
break;
case LBRACE:
enterOuterAlt(_localctx, 2);
{
setState(1033);
arrayInitializer();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UnannTypeContext extends ParserRuleContext {
public UnannPrimitiveTypeContext unannPrimitiveType() {
return getRuleContext(UnannPrimitiveTypeContext.class,0);
}
public UnannReferenceTypeContext unannReferenceType() {
return getRuleContext(UnannReferenceTypeContext.class,0);
}
public UnannTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unannType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannType(this);
}
}
public final UnannTypeContext unannType() throws RecognitionException {
UnannTypeContext _localctx = new UnannTypeContext(_ctx, getState());
enterRule(_localctx, 136, RULE_unannType);
try {
setState(1038);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,72,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1036);
unannPrimitiveType();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1037);
unannReferenceType();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UnannPrimitiveTypeContext extends ParserRuleContext {
public NumericTypeContext numericType() {
return getRuleContext(NumericTypeContext.class,0);
}
public UnannPrimitiveTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unannPrimitiveType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannPrimitiveType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannPrimitiveType(this);
}
}
public final UnannPrimitiveTypeContext unannPrimitiveType() throws RecognitionException {
UnannPrimitiveTypeContext _localctx = new UnannPrimitiveTypeContext(_ctx, getState());
enterRule(_localctx, 138, RULE_unannPrimitiveType);
try {
setState(1042);
_errHandler.sync(this);
switch (_input.LA(1)) {
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case SHORT:
enterOuterAlt(_localctx, 1);
{
setState(1040);
numericType();
}
break;
case BOOLEAN:
enterOuterAlt(_localctx, 2);
{
setState(1041);
match(BOOLEAN);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UnannReferenceTypeContext extends ParserRuleContext {
public UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() {
return getRuleContext(UnannClassOrInterfaceTypeContext.class,0);
}
public UnannTypeVariableContext unannTypeVariable() {
return getRuleContext(UnannTypeVariableContext.class,0);
}
public UnannArrayTypeContext unannArrayType() {
return getRuleContext(UnannArrayTypeContext.class,0);
}
public UnannReferenceTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unannReferenceType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannReferenceType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannReferenceType(this);
}
}
public final UnannReferenceTypeContext unannReferenceType() throws RecognitionException {
UnannReferenceTypeContext _localctx = new UnannReferenceTypeContext(_ctx, getState());
enterRule(_localctx, 140, RULE_unannReferenceType);
try {
setState(1047);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,74,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1044);
unannClassOrInterfaceType();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1045);
unannTypeVariable();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1046);
unannArrayType();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UnannClassOrInterfaceTypeContext extends ParserRuleContext {
public UnannClassType_lfno_unannClassOrInterfaceTypeContext unannClassType_lfno_unannClassOrInterfaceType() {
return getRuleContext(UnannClassType_lfno_unannClassOrInterfaceTypeContext.class,0);
}
public UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext unannInterfaceType_lfno_unannClassOrInterfaceType() {
return getRuleContext(UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext.class,0);
}
public List<UnannClassType_lf_unannClassOrInterfaceTypeContext> unannClassType_lf_unannClassOrInterfaceType() {
return getRuleContexts(UnannClassType_lf_unannClassOrInterfaceTypeContext.class);
}
public UnannClassType_lf_unannClassOrInterfaceTypeContext unannClassType_lf_unannClassOrInterfaceType(int i) {
return getRuleContext(UnannClassType_lf_unannClassOrInterfaceTypeContext.class,i);
}
public List<UnannInterfaceType_lf_unannClassOrInterfaceTypeContext> unannInterfaceType_lf_unannClassOrInterfaceType() {
return getRuleContexts(UnannInterfaceType_lf_unannClassOrInterfaceTypeContext.class);
}
public UnannInterfaceType_lf_unannClassOrInterfaceTypeContext unannInterfaceType_lf_unannClassOrInterfaceType(int i) {
return getRuleContext(UnannInterfaceType_lf_unannClassOrInterfaceTypeContext.class,i);
}
public UnannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unannClassOrInterfaceType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannClassOrInterfaceType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannClassOrInterfaceType(this);
}
}
public final UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() throws RecognitionException {
UnannClassOrInterfaceTypeContext _localctx = new UnannClassOrInterfaceTypeContext(_ctx, getState());
enterRule(_localctx, 142, RULE_unannClassOrInterfaceType);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1051);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
case 1:
{
setState(1049);
unannClassType_lfno_unannClassOrInterfaceType();
}
break;
case 2:
{
setState(1050);
unannInterfaceType_lfno_unannClassOrInterfaceType();
}
break;
}
setState(1057);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,77,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
setState(1055);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,76,_ctx) ) {
case 1:
{
setState(1053);
unannClassType_lf_unannClassOrInterfaceType();
}
break;
case 2:
{
setState(1054);
unannInterfaceType_lf_unannClassOrInterfaceType();
}
break;
}
}
}
setState(1059);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,77,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UnannClassTypeContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TypeArgumentsContext typeArguments() {
return getRuleContext(TypeArgumentsContext.class,0);
}
public UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() {
return getRuleContext(UnannClassOrInterfaceTypeContext.class,0);
}
public List<AnnotationContext> annotation() {
return getRuleContexts(AnnotationContext.class);
}
public AnnotationContext annotation(int i) {
return getRuleContext(AnnotationContext.class,i);
}
public UnannClassTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unannClassType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannClassType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannClassType(this);
}
}
public final UnannClassTypeContext unannClassType() throws RecognitionException {
UnannClassTypeContext _localctx = new UnannClassTypeContext(_ctx, getState());
enterRule(_localctx, 144, RULE_unannClassType);
int _la;
try {
setState(1076);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,81,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1060);
identifier();
setState(1062);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1061);
typeArguments();
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1064);
unannClassOrInterfaceType();
setState(1065);
match(DOT);
setState(1069);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(1066);
annotation();
}
}
setState(1071);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1072);
identifier();
setState(1074);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1073);
typeArguments();
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UnannClassType_lf_unannClassOrInterfaceTypeContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public List<AnnotationContext> annotation() {
return getRuleContexts(AnnotationContext.class);
}
public AnnotationContext annotation(int i) {
return getRuleContext(AnnotationContext.class,i);
}
public TypeArgumentsContext typeArguments() {
return getRuleContext(TypeArgumentsContext.class,0);
}
public UnannClassType_lf_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unannClassType_lf_unannClassOrInterfaceType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannClassType_lf_unannClassOrInterfaceType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannClassType_lf_unannClassOrInterfaceType(this);
}
}
public final UnannClassType_lf_unannClassOrInterfaceTypeContext unannClassType_lf_unannClassOrInterfaceType() throws RecognitionException {
UnannClassType_lf_unannClassOrInterfaceTypeContext _localctx = new UnannClassType_lf_unannClassOrInterfaceTypeContext(_ctx, getState());
enterRule(_localctx, 146, RULE_unannClassType_lf_unannClassOrInterfaceType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1078);
match(DOT);
setState(1082);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(1079);
annotation();
}
}
setState(1084);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1085);
identifier();
setState(1087);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1086);
typeArguments();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UnannClassType_lfno_unannClassOrInterfaceTypeContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TypeArgumentsContext typeArguments() {
return getRuleContext(TypeArgumentsContext.class,0);
}
public UnannClassType_lfno_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unannClassType_lfno_unannClassOrInterfaceType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannClassType_lfno_unannClassOrInterfaceType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannClassType_lfno_unannClassOrInterfaceType(this);
}
}
public final UnannClassType_lfno_unannClassOrInterfaceTypeContext unannClassType_lfno_unannClassOrInterfaceType() throws RecognitionException {
UnannClassType_lfno_unannClassOrInterfaceTypeContext _localctx = new UnannClassType_lfno_unannClassOrInterfaceTypeContext(_ctx, getState());
enterRule(_localctx, 148, RULE_unannClassType_lfno_unannClassOrInterfaceType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1089);
identifier();
setState(1091);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1090);
typeArguments();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UnannInterfaceTypeContext extends ParserRuleContext {
public UnannClassTypeContext unannClassType() {
return getRuleContext(UnannClassTypeContext.class,0);
}
public UnannInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unannInterfaceType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannInterfaceType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannInterfaceType(this);
}
}
public final UnannInterfaceTypeContext unannInterfaceType() throws RecognitionException {
UnannInterfaceTypeContext _localctx = new UnannInterfaceTypeContext(_ctx, getState());
enterRule(_localctx, 150, RULE_unannInterfaceType);
try {
enterOuterAlt(_localctx, 1);
{
setState(1093);
unannClassType();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UnannInterfaceType_lf_unannClassOrInterfaceTypeContext extends ParserRuleContext {
public UnannClassType_lf_unannClassOrInterfaceTypeContext unannClassType_lf_unannClassOrInterfaceType() {
return getRuleContext(UnannClassType_lf_unannClassOrInterfaceTypeContext.class,0);
}
public UnannInterfaceType_lf_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unannInterfaceType_lf_unannClassOrInterfaceType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannInterfaceType_lf_unannClassOrInterfaceType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannInterfaceType_lf_unannClassOrInterfaceType(this);
}
}
public final UnannInterfaceType_lf_unannClassOrInterfaceTypeContext unannInterfaceType_lf_unannClassOrInterfaceType() throws RecognitionException {
UnannInterfaceType_lf_unannClassOrInterfaceTypeContext _localctx = new UnannInterfaceType_lf_unannClassOrInterfaceTypeContext(_ctx, getState());
enterRule(_localctx, 152, RULE_unannInterfaceType_lf_unannClassOrInterfaceType);
try {
enterOuterAlt(_localctx, 1);
{
setState(1095);
unannClassType_lf_unannClassOrInterfaceType();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext extends ParserRuleContext {
public UnannClassType_lfno_unannClassOrInterfaceTypeContext unannClassType_lfno_unannClassOrInterfaceType() {
return getRuleContext(UnannClassType_lfno_unannClassOrInterfaceTypeContext.class,0);
}
public UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unannInterfaceType_lfno_unannClassOrInterfaceType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannInterfaceType_lfno_unannClassOrInterfaceType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannInterfaceType_lfno_unannClassOrInterfaceType(this);
}
}
public final UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext unannInterfaceType_lfno_unannClassOrInterfaceType() throws RecognitionException {
UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext _localctx = new UnannInterfaceType_lfno_unannClassOrInterfaceTypeContext(_ctx, getState());
enterRule(_localctx, 154, RULE_unannInterfaceType_lfno_unannClassOrInterfaceType);
try {
enterOuterAlt(_localctx, 1);
{
setState(1097);
unannClassType_lfno_unannClassOrInterfaceType();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UnannTypeVariableContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public UnannTypeVariableContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unannTypeVariable; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannTypeVariable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannTypeVariable(this);
}
}
public final UnannTypeVariableContext unannTypeVariable() throws RecognitionException {
UnannTypeVariableContext _localctx = new UnannTypeVariableContext(_ctx, getState());
enterRule(_localctx, 156, RULE_unannTypeVariable);
try {
enterOuterAlt(_localctx, 1);
{
setState(1099);
identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UnannArrayTypeContext extends ParserRuleContext {
public UnannPrimitiveTypeContext unannPrimitiveType() {
return getRuleContext(UnannPrimitiveTypeContext.class,0);
}
public DimsContext dims() {
return getRuleContext(DimsContext.class,0);
}
public UnannClassOrInterfaceTypeContext unannClassOrInterfaceType() {
return getRuleContext(UnannClassOrInterfaceTypeContext.class,0);
}
public UnannTypeVariableContext unannTypeVariable() {
return getRuleContext(UnannTypeVariableContext.class,0);
}
public UnannArrayTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unannArrayType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnannArrayType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnannArrayType(this);
}
}
public final UnannArrayTypeContext unannArrayType() throws RecognitionException {
UnannArrayTypeContext _localctx = new UnannArrayTypeContext(_ctx, getState());
enterRule(_localctx, 158, RULE_unannArrayType);
try {
setState(1110);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1101);
unannPrimitiveType();
setState(1102);
dims();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1104);
unannClassOrInterfaceType();
setState(1105);
dims();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1107);
unannTypeVariable();
setState(1108);
dims();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MethodDeclarationContext extends ParserRuleContext {
public MethodHeaderContext methodHeader() {
return getRuleContext(MethodHeaderContext.class,0);
}
public MethodBodyContext methodBody() {
return getRuleContext(MethodBodyContext.class,0);
}
public List<MethodModifierContext> methodModifier() {
return getRuleContexts(MethodModifierContext.class);
}
public MethodModifierContext methodModifier(int i) {
return getRuleContext(MethodModifierContext.class,i);
}
public MethodDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_methodDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterMethodDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitMethodDeclaration(this);
}
}
public final MethodDeclarationContext methodDeclaration() throws RecognitionException {
MethodDeclarationContext _localctx = new MethodDeclarationContext(_ctx, getState());
enterRule(_localctx, 160, RULE_methodDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1115);
_errHandler.sync(this);
_la = _input.LA(1);
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) {
{
{
setState(1112);
methodModifier();
}
}
setState(1117);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1118);
methodHeader();
setState(1119);
methodBody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MethodModifierContext extends ParserRuleContext {
public AnnotationContext annotation() {
return getRuleContext(AnnotationContext.class,0);
}
public MethodModifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_methodModifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterMethodModifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitMethodModifier(this);
}
}
public final MethodModifierContext methodModifier() throws RecognitionException {
MethodModifierContext _localctx = new MethodModifierContext(_ctx, getState());
enterRule(_localctx, 162, RULE_methodModifier);
try {
setState(1131);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AT:
enterOuterAlt(_localctx, 1);
{
setState(1121);
annotation();
}
break;
case PUBLIC:
enterOuterAlt(_localctx, 2);
{
setState(1122);
match(PUBLIC);
}
break;
case PROTECTED:
enterOuterAlt(_localctx, 3);
{
setState(1123);
match(PROTECTED);
}
break;
case PRIVATE:
enterOuterAlt(_localctx, 4);
{
setState(1124);
match(PRIVATE);
}
break;
case ABSTRACT:
enterOuterAlt(_localctx, 5);
{
setState(1125);
match(ABSTRACT);
}
break;
case STATIC:
enterOuterAlt(_localctx, 6);
{
setState(1126);
match(STATIC);
}
break;
case FINAL:
enterOuterAlt(_localctx, 7);
{
setState(1127);
match(FINAL);
}
break;
case SYNCHRONIZED:
enterOuterAlt(_localctx, 8);
{
setState(1128);
match(SYNCHRONIZED);
}
break;
case NATIVE:
enterOuterAlt(_localctx, 9);
{
setState(1129);
match(NATIVE);
}
break;
case STRICTFP:
enterOuterAlt(_localctx, 10);
{
setState(1130);
match(STRICTFP);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MethodHeaderContext extends ParserRuleContext {
public ResultContext result() {
return getRuleContext(ResultContext.class,0);
}
public MethodDeclaratorContext methodDeclarator() {
return getRuleContext(MethodDeclaratorContext.class,0);
}
public Throws_Context throws_() {
return getRuleContext(Throws_Context.class,0);
}
public TypeParametersContext typeParameters() {
return getRuleContext(TypeParametersContext.class,0);
}
public List<AnnotationContext> annotation() {
return getRuleContexts(AnnotationContext.class);
}
public AnnotationContext annotation(int i) {
return getRuleContext(AnnotationContext.class,i);
}
public MethodHeaderContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_methodHeader; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterMethodHeader(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitMethodHeader(this);
}
}
public final MethodHeaderContext methodHeader() throws RecognitionException {
MethodHeaderContext _localctx = new MethodHeaderContext(_ctx, getState());
enterRule(_localctx, 164, RULE_methodHeader);
int _la;
try {
setState(1150);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__0:
case T__1:
case T__2:
case T__3:
case T__4:
case T__5:
case T__6:
case T__7:
case T__8:
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case SHORT:
case VOID:
case Identifier:
enterOuterAlt(_localctx, 1);
{
setState(1133);
result();
setState(1134);
methodDeclarator();
setState(1136);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==THROWS) {
{
setState(1135);
throws_();
}
}
}
break;
case LT:
enterOuterAlt(_localctx, 2);
{
setState(1138);
typeParameters();
setState(1142);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(1139);
annotation();
}
}
setState(1144);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1145);
result();
setState(1146);
methodDeclarator();
setState(1148);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==THROWS) {
{
setState(1147);
throws_();
}
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ResultContext extends ParserRuleContext {
public UnannTypeContext unannType() {
return getRuleContext(UnannTypeContext.class,0);
}
public ResultContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_result; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterResult(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitResult(this);
}
}
public final ResultContext result() throws RecognitionException {
ResultContext _localctx = new ResultContext(_ctx, getState());
enterRule(_localctx, 166, RULE_result);
try {
setState(1154);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__0:
case T__1:
case T__2:
case T__3:
case T__4:
case T__5:
case T__6:
case T__7:
case T__8:
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case SHORT:
case Identifier:
enterOuterAlt(_localctx, 1);
{
setState(1152);
unannType();
}
break;
case VOID:
enterOuterAlt(_localctx, 2);
{
setState(1153);
match(VOID);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MethodDeclaratorContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public FormalParameterListContext formalParameterList() {
return getRuleContext(FormalParameterListContext.class,0);
}
public DimsContext dims() {
return getRuleContext(DimsContext.class,0);
}
public MethodDeclaratorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_methodDeclarator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterMethodDeclarator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitMethodDeclarator(this);
}
}
public final MethodDeclaratorContext methodDeclarator() throws RecognitionException {
MethodDeclaratorContext _localctx = new MethodDeclaratorContext(_ctx, getState());
enterRule(_localctx, 168, RULE_methodDeclarator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1156);
identifier();
setState(1157);
match(LPAREN);
setState(1159);
_errHandler.sync(this);
_la = _input.LA(1);
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) {
{
setState(1158);
formalParameterList();
}
}
setState(1161);
match(RPAREN);
setState(1163);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LBRACK || _la==AT) {
{
setState(1162);
dims();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FormalParameterListContext extends ParserRuleContext {
public FormalParametersContext formalParameters() {
return getRuleContext(FormalParametersContext.class,0);
}
public LastFormalParameterContext lastFormalParameter() {
return getRuleContext(LastFormalParameterContext.class,0);
}
public ReceiverParameterContext receiverParameter() {
return getRuleContext(ReceiverParameterContext.class,0);
}
public FormalParameterListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_formalParameterList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterFormalParameterList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitFormalParameterList(this);
}
}
public final FormalParameterListContext formalParameterList() throws RecognitionException {
FormalParameterListContext _localctx = new FormalParameterListContext(_ctx, getState());
enterRule(_localctx, 170, RULE_formalParameterList);
try {
setState(1171);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,95,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1165);
formalParameters();
setState(1166);
match(COMMA);
setState(1167);
lastFormalParameter();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1169);
lastFormalParameter();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1170);
receiverParameter();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FormalParametersContext extends ParserRuleContext {
public List<FormalParameterContext> formalParameter() {
return getRuleContexts(FormalParameterContext.class);
}
public FormalParameterContext formalParameter(int i) {
return getRuleContext(FormalParameterContext.class,i);
}
public ReceiverParameterContext receiverParameter() {
return getRuleContext(ReceiverParameterContext.class,0);
}
public FormalParametersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_formalParameters; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterFormalParameters(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitFormalParameters(this);
}
}
public final FormalParametersContext formalParameters() throws RecognitionException {
FormalParametersContext _localctx = new FormalParametersContext(_ctx, getState());
enterRule(_localctx, 172, RULE_formalParameters);
try {
int _alt;
setState(1189);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,98,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1173);
formalParameter();
setState(1178);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,96,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1174);
match(COMMA);
setState(1175);
formalParameter();
}
}
}
setState(1180);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,96,_ctx);
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1181);
receiverParameter();
setState(1186);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,97,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1182);
match(COMMA);
setState(1183);
formalParameter();
}
}
}
setState(1188);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,97,_ctx);
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FormalParameterContext extends ParserRuleContext {
public UnannTypeContext unannType() {
return getRuleContext(UnannTypeContext.class,0);
}
public VariableDeclaratorIdContext variableDeclaratorId() {
return getRuleContext(VariableDeclaratorIdContext.class,0);
}
public List<VariableModifierContext> variableModifier() {
return getRuleContexts(VariableModifierContext.class);
}
public VariableModifierContext variableModifier(int i) {
return getRuleContext(VariableModifierContext.class,i);
}
public FormalParameterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_formalParameter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterFormalParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitFormalParameter(this);
}
}
public final FormalParameterContext formalParameter() throws RecognitionException {
FormalParameterContext _localctx = new FormalParameterContext(_ctx, getState());
enterRule(_localctx, 174, RULE_formalParameter);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1194);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==FINAL || _la==AT) {
{
{
setState(1191);
variableModifier();
}
}
setState(1196);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1197);
unannType();
setState(1198);
variableDeclaratorId();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VariableModifierContext extends ParserRuleContext {
public AnnotationContext annotation() {
return getRuleContext(AnnotationContext.class,0);
}
public VariableModifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_variableModifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterVariableModifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitVariableModifier(this);
}
}
public final VariableModifierContext variableModifier() throws RecognitionException {
VariableModifierContext _localctx = new VariableModifierContext(_ctx, getState());
enterRule(_localctx, 176, RULE_variableModifier);
try {
setState(1202);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AT:
enterOuterAlt(_localctx, 1);
{
setState(1200);
annotation();
}
break;
case FINAL:
enterOuterAlt(_localctx, 2);
{
setState(1201);
match(FINAL);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LastFormalParameterContext extends ParserRuleContext {
public UnannTypeContext unannType() {
return getRuleContext(UnannTypeContext.class,0);
}
public VariableDeclaratorIdContext variableDeclaratorId() {
return getRuleContext(VariableDeclaratorIdContext.class,0);
}
public List<VariableModifierContext> variableModifier() {
return getRuleContexts(VariableModifierContext.class);
}
public VariableModifierContext variableModifier(int i) {
return getRuleContext(VariableModifierContext.class,i);
}
public List<AnnotationContext> annotation() {
return getRuleContexts(AnnotationContext.class);
}
public AnnotationContext annotation(int i) {
return getRuleContext(AnnotationContext.class,i);
}
public FormalParameterContext formalParameter() {
return getRuleContext(FormalParameterContext.class,0);
}
public LastFormalParameterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lastFormalParameter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterLastFormalParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitLastFormalParameter(this);
}
}
public final LastFormalParameterContext lastFormalParameter() throws RecognitionException {
LastFormalParameterContext _localctx = new LastFormalParameterContext(_ctx, getState());
enterRule(_localctx, 178, RULE_lastFormalParameter);
int _la;
try {
setState(1221);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,103,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1207);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==FINAL || _la==AT) {
{
{
setState(1204);
variableModifier();
}
}
setState(1209);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1210);
unannType();
setState(1214);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(1211);
annotation();
}
}
setState(1216);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1217);
match(ELLIPSIS);
setState(1218);
variableDeclaratorId();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1220);
formalParameter();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ReceiverParameterContext extends ParserRuleContext {
public UnannTypeContext unannType() {
return getRuleContext(UnannTypeContext.class,0);
}
public List<AnnotationContext> annotation() {
return getRuleContexts(AnnotationContext.class);
}
public AnnotationContext annotation(int i) {
return getRuleContext(AnnotationContext.class,i);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ReceiverParameterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_receiverParameter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterReceiverParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitReceiverParameter(this);
}
}
public final ReceiverParameterContext receiverParameter() throws RecognitionException {
ReceiverParameterContext _localctx = new ReceiverParameterContext(_ctx, getState());
enterRule(_localctx, 180, RULE_receiverParameter);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1226);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(1223);
annotation();
}
}
setState(1228);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1229);
unannType();
setState(1233);
_errHandler.sync(this);
_la = _input.LA(1);
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) {
{
setState(1230);
identifier();
setState(1231);
match(DOT);
}
}
setState(1235);
match(THIS);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Throws_Context extends ParserRuleContext {
public ExceptionTypeListContext exceptionTypeList() {
return getRuleContext(ExceptionTypeListContext.class,0);
}
public Throws_Context(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_throws_; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterThrows_(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitThrows_(this);
}
}
public final Throws_Context throws_() throws RecognitionException {
Throws_Context _localctx = new Throws_Context(_ctx, getState());
enterRule(_localctx, 182, RULE_throws_);
try {
enterOuterAlt(_localctx, 1);
{
setState(1237);
match(THROWS);
setState(1238);
exceptionTypeList();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExceptionTypeListContext extends ParserRuleContext {
public List<ExceptionTypeContext> exceptionType() {
return getRuleContexts(ExceptionTypeContext.class);
}
public ExceptionTypeContext exceptionType(int i) {
return getRuleContext(ExceptionTypeContext.class,i);
}
public ExceptionTypeListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_exceptionTypeList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterExceptionTypeList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitExceptionTypeList(this);
}
}
public final ExceptionTypeListContext exceptionTypeList() throws RecognitionException {
ExceptionTypeListContext _localctx = new ExceptionTypeListContext(_ctx, getState());
enterRule(_localctx, 184, RULE_exceptionTypeList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1240);
exceptionType();
setState(1245);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1241);
match(COMMA);
setState(1242);
exceptionType();
}
}
setState(1247);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExceptionTypeContext extends ParserRuleContext {
public ClassTypeContext classType() {
return getRuleContext(ClassTypeContext.class,0);
}
public TypeVariableContext typeVariable() {
return getRuleContext(TypeVariableContext.class,0);
}
public ExceptionTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_exceptionType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterExceptionType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitExceptionType(this);
}
}
public final ExceptionTypeContext exceptionType() throws RecognitionException {
ExceptionTypeContext _localctx = new ExceptionTypeContext(_ctx, getState());
enterRule(_localctx, 186, RULE_exceptionType);
try {
setState(1250);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,107,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1248);
classType();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1249);
typeVariable();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MethodBodyContext extends ParserRuleContext {
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public MethodBodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_methodBody; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterMethodBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitMethodBody(this);
}
}
public final MethodBodyContext methodBody() throws RecognitionException {
MethodBodyContext _localctx = new MethodBodyContext(_ctx, getState());
enterRule(_localctx, 188, RULE_methodBody);
try {
setState(1254);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LBRACE:
enterOuterAlt(_localctx, 1);
{
setState(1252);
block();
}
break;
case SEMI:
enterOuterAlt(_localctx, 2);
{
setState(1253);
match(SEMI);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InstanceInitializerContext extends ParserRuleContext {
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public InstanceInitializerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_instanceInitializer; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInstanceInitializer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInstanceInitializer(this);
}
}
public final InstanceInitializerContext instanceInitializer() throws RecognitionException {
InstanceInitializerContext _localctx = new InstanceInitializerContext(_ctx, getState());
enterRule(_localctx, 190, RULE_instanceInitializer);
try {
enterOuterAlt(_localctx, 1);
{
setState(1256);
block();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StaticInitializerContext extends ParserRuleContext {
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public StaticInitializerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_staticInitializer; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterStaticInitializer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitStaticInitializer(this);
}
}
public final StaticInitializerContext staticInitializer() throws RecognitionException {
StaticInitializerContext _localctx = new StaticInitializerContext(_ctx, getState());
enterRule(_localctx, 192, RULE_staticInitializer);
try {
enterOuterAlt(_localctx, 1);
{
setState(1258);
match(STATIC);
setState(1259);
block();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstructorDeclarationContext extends ParserRuleContext {
public ConstructorDeclaratorContext constructorDeclarator() {
return getRuleContext(ConstructorDeclaratorContext.class,0);
}
public ConstructorBodyContext constructorBody() {
return getRuleContext(ConstructorBodyContext.class,0);
}
public List<ConstructorModifierContext> constructorModifier() {
return getRuleContexts(ConstructorModifierContext.class);
}
public ConstructorModifierContext constructorModifier(int i) {
return getRuleContext(ConstructorModifierContext.class,i);
}
public Throws_Context throws_() {
return getRuleContext(Throws_Context.class,0);
}
public ConstructorDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constructorDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterConstructorDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitConstructorDeclaration(this);
}
}
public final ConstructorDeclarationContext constructorDeclaration() throws RecognitionException {
ConstructorDeclarationContext _localctx = new ConstructorDeclarationContext(_ctx, getState());
enterRule(_localctx, 194, RULE_constructorDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1264);
_errHandler.sync(this);
_la = _input.LA(1);
while (((((_la - 43)) & ~0x3f) == 0 && ((1L << (_la - 43)) & ((1L << (PRIVATE - 43)) | (1L << (PROTECTED - 43)) | (1L << (PUBLIC - 43)) | (1L << (AT - 43)))) != 0)) {
{
{
setState(1261);
constructorModifier();
}
}
setState(1266);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1267);
constructorDeclarator();
setState(1269);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==THROWS) {
{
setState(1268);
throws_();
}
}
setState(1271);
constructorBody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstructorModifierContext extends ParserRuleContext {
public AnnotationContext annotation() {
return getRuleContext(AnnotationContext.class,0);
}
public ConstructorModifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constructorModifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterConstructorModifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitConstructorModifier(this);
}
}
public final ConstructorModifierContext constructorModifier() throws RecognitionException {
ConstructorModifierContext _localctx = new ConstructorModifierContext(_ctx, getState());
enterRule(_localctx, 196, RULE_constructorModifier);
try {
setState(1277);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AT:
enterOuterAlt(_localctx, 1);
{
setState(1273);
annotation();
}
break;
case PUBLIC:
enterOuterAlt(_localctx, 2);
{
setState(1274);
match(PUBLIC);
}
break;
case PROTECTED:
enterOuterAlt(_localctx, 3);
{
setState(1275);
match(PROTECTED);
}
break;
case PRIVATE:
enterOuterAlt(_localctx, 4);
{
setState(1276);
match(PRIVATE);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstructorDeclaratorContext extends ParserRuleContext {
public SimpleTypeNameContext simpleTypeName() {
return getRuleContext(SimpleTypeNameContext.class,0);
}
public TypeParametersContext typeParameters() {
return getRuleContext(TypeParametersContext.class,0);
}
public FormalParameterListContext formalParameterList() {
return getRuleContext(FormalParameterListContext.class,0);
}
public ConstructorDeclaratorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constructorDeclarator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterConstructorDeclarator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitConstructorDeclarator(this);
}
}
public final ConstructorDeclaratorContext constructorDeclarator() throws RecognitionException {
ConstructorDeclaratorContext _localctx = new ConstructorDeclaratorContext(_ctx, getState());
enterRule(_localctx, 198, RULE_constructorDeclarator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1280);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1279);
typeParameters();
}
}
setState(1282);
simpleTypeName();
setState(1283);
match(LPAREN);
setState(1285);
_errHandler.sync(this);
_la = _input.LA(1);
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) {
{
setState(1284);
formalParameterList();
}
}
setState(1287);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SimpleTypeNameContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public SimpleTypeNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simpleTypeName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterSimpleTypeName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitSimpleTypeName(this);
}
}
public final SimpleTypeNameContext simpleTypeName() throws RecognitionException {
SimpleTypeNameContext _localctx = new SimpleTypeNameContext(_ctx, getState());
enterRule(_localctx, 200, RULE_simpleTypeName);
try {
enterOuterAlt(_localctx, 1);
{
setState(1289);
identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstructorBodyContext extends ParserRuleContext {
public ExplicitConstructorInvocationContext explicitConstructorInvocation() {
return getRuleContext(ExplicitConstructorInvocationContext.class,0);
}
public BlockStatementsContext blockStatements() {
return getRuleContext(BlockStatementsContext.class,0);
}
public ConstructorBodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constructorBody; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterConstructorBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitConstructorBody(this);
}
}
public final ConstructorBodyContext constructorBody() throws RecognitionException {
ConstructorBodyContext _localctx = new ConstructorBodyContext(_ctx, getState());
enterRule(_localctx, 202, RULE_constructorBody);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1291);
match(LBRACE);
setState(1293);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,114,_ctx) ) {
case 1:
{
setState(1292);
explicitConstructorInvocation();
}
break;
}
setState(1296);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
setState(1295);
blockStatements();
}
}
setState(1298);
match(RBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExplicitConstructorInvocationContext extends ParserRuleContext {
public TypeArgumentsContext typeArguments() {
return getRuleContext(TypeArgumentsContext.class,0);
}
public ArgumentListContext argumentList() {
return getRuleContext(ArgumentListContext.class,0);
}
public ExpressionNameContext expressionName() {
return getRuleContext(ExpressionNameContext.class,0);
}
public PrimaryContext primary() {
return getRuleContext(PrimaryContext.class,0);
}
public ExplicitConstructorInvocationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_explicitConstructorInvocation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterExplicitConstructorInvocation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitExplicitConstructorInvocation(this);
}
}
public final ExplicitConstructorInvocationContext explicitConstructorInvocation() throws RecognitionException {
ExplicitConstructorInvocationContext _localctx = new ExplicitConstructorInvocationContext(_ctx, getState());
enterRule(_localctx, 204, RULE_explicitConstructorInvocation);
int _la;
try {
setState(1346);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1301);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1300);
typeArguments();
}
}
setState(1303);
match(THIS);
setState(1304);
match(LPAREN);
setState(1306);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
setState(1305);
argumentList();
}
}
setState(1308);
match(RPAREN);
setState(1309);
match(SEMI);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1311);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1310);
typeArguments();
}
}
setState(1313);
match(SUPER);
setState(1314);
match(LPAREN);
setState(1316);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
setState(1315);
argumentList();
}
}
setState(1318);
match(RPAREN);
setState(1319);
match(SEMI);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1320);
expressionName();
setState(1321);
match(DOT);
setState(1323);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1322);
typeArguments();
}
}
setState(1325);
match(SUPER);
setState(1326);
match(LPAREN);
setState(1328);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
setState(1327);
argumentList();
}
}
setState(1330);
match(RPAREN);
setState(1331);
match(SEMI);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1333);
primary();
setState(1334);
match(DOT);
setState(1336);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1335);
typeArguments();
}
}
setState(1338);
match(SUPER);
setState(1339);
match(LPAREN);
setState(1341);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
setState(1340);
argumentList();
}
}
setState(1343);
match(RPAREN);
setState(1344);
match(SEMI);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumDeclarationContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public EnumBodyContext enumBody() {
return getRuleContext(EnumBodyContext.class,0);
}
public List<ClassModifierContext> classModifier() {
return getRuleContexts(ClassModifierContext.class);
}
public ClassModifierContext classModifier(int i) {
return getRuleContext(ClassModifierContext.class,i);
}
public SuperinterfacesContext superinterfaces() {
return getRuleContext(SuperinterfacesContext.class,0);
}
public EnumDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterEnumDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitEnumDeclaration(this);
}
}
public final EnumDeclarationContext enumDeclaration() throws RecognitionException {
EnumDeclarationContext _localctx = new EnumDeclarationContext(_ctx, getState());
enterRule(_localctx, 206, RULE_enumDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1351);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) {
{
{
setState(1348);
classModifier();
}
}
setState(1353);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1354);
match(ENUM);
setState(1355);
identifier();
setState(1357);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IMPLEMENTS) {
{
setState(1356);
superinterfaces();
}
}
setState(1359);
enumBody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumBodyContext extends ParserRuleContext {
public EnumConstantListContext enumConstantList() {
return getRuleContext(EnumConstantListContext.class,0);
}
public EnumBodyDeclarationsContext enumBodyDeclarations() {
return getRuleContext(EnumBodyDeclarationsContext.class,0);
}
public EnumBodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumBody; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterEnumBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitEnumBody(this);
}
}
public final EnumBodyContext enumBody() throws RecognitionException {
EnumBodyContext _localctx = new EnumBodyContext(_ctx, getState());
enterRule(_localctx, 208, RULE_enumBody);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1361);
match(LBRACE);
setState(1363);
_errHandler.sync(this);
_la = _input.LA(1);
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) {
{
setState(1362);
enumConstantList();
}
}
setState(1366);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1365);
match(COMMA);
}
}
setState(1369);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SEMI) {
{
setState(1368);
enumBodyDeclarations();
}
}
setState(1371);
match(RBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumConstantListContext extends ParserRuleContext {
public List<EnumConstantContext> enumConstant() {
return getRuleContexts(EnumConstantContext.class);
}
public EnumConstantContext enumConstant(int i) {
return getRuleContext(EnumConstantContext.class,i);
}
public EnumConstantListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumConstantList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterEnumConstantList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitEnumConstantList(this);
}
}
public final EnumConstantListContext enumConstantList() throws RecognitionException {
EnumConstantListContext _localctx = new EnumConstantListContext(_ctx, getState());
enterRule(_localctx, 210, RULE_enumConstantList);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1373);
enumConstant();
setState(1378);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,130,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1374);
match(COMMA);
setState(1375);
enumConstant();
}
}
}
setState(1380);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,130,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumConstantContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public List<EnumConstantModifierContext> enumConstantModifier() {
return getRuleContexts(EnumConstantModifierContext.class);
}
public EnumConstantModifierContext enumConstantModifier(int i) {
return getRuleContext(EnumConstantModifierContext.class,i);
}
public ClassBodyContext classBody() {
return getRuleContext(ClassBodyContext.class,0);
}
public ArgumentListContext argumentList() {
return getRuleContext(ArgumentListContext.class,0);
}
public EnumConstantContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumConstant; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterEnumConstant(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitEnumConstant(this);
}
}
public final EnumConstantContext enumConstant() throws RecognitionException {
EnumConstantContext _localctx = new EnumConstantContext(_ctx, getState());
enterRule(_localctx, 212, RULE_enumConstant);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1384);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(1381);
enumConstantModifier();
}
}
setState(1386);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1387);
identifier();
setState(1393);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(1388);
match(LPAREN);
setState(1390);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
setState(1389);
argumentList();
}
}
setState(1392);
match(RPAREN);
}
}
setState(1396);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LBRACE) {
{
setState(1395);
classBody();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumConstantModifierContext extends ParserRuleContext {
public AnnotationContext annotation() {
return getRuleContext(AnnotationContext.class,0);
}
public EnumConstantModifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumConstantModifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterEnumConstantModifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitEnumConstantModifier(this);
}
}
public final EnumConstantModifierContext enumConstantModifier() throws RecognitionException {
EnumConstantModifierContext _localctx = new EnumConstantModifierContext(_ctx, getState());
enterRule(_localctx, 214, RULE_enumConstantModifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(1398);
annotation();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumBodyDeclarationsContext extends ParserRuleContext {
public List<ClassBodyDeclarationContext> classBodyDeclaration() {
return getRuleContexts(ClassBodyDeclarationContext.class);
}
public ClassBodyDeclarationContext classBodyDeclaration(int i) {
return getRuleContext(ClassBodyDeclarationContext.class,i);
}
public EnumBodyDeclarationsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumBodyDeclarations; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterEnumBodyDeclarations(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitEnumBodyDeclarations(this);
}
}
public final EnumBodyDeclarationsContext enumBodyDeclarations() throws RecognitionException {
EnumBodyDeclarationsContext _localctx = new EnumBodyDeclarationsContext(_ctx, getState());
enterRule(_localctx, 216, RULE_enumBodyDeclarations);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1400);
match(SEMI);
setState(1404);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
{
setState(1401);
classBodyDeclaration();
}
}
setState(1406);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InterfaceDeclarationContext extends ParserRuleContext {
public NormalInterfaceDeclarationContext normalInterfaceDeclaration() {
return getRuleContext(NormalInterfaceDeclarationContext.class,0);
}
public AnnotationTypeDeclarationContext annotationTypeDeclaration() {
return getRuleContext(AnnotationTypeDeclarationContext.class,0);
}
public InterfaceDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_interfaceDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInterfaceDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInterfaceDeclaration(this);
}
}
public final InterfaceDeclarationContext interfaceDeclaration() throws RecognitionException {
InterfaceDeclarationContext _localctx = new InterfaceDeclarationContext(_ctx, getState());
enterRule(_localctx, 218, RULE_interfaceDeclaration);
try {
setState(1409);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,136,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1407);
normalInterfaceDeclaration();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1408);
annotationTypeDeclaration();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NormalInterfaceDeclarationContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public InterfaceBodyContext interfaceBody() {
return getRuleContext(InterfaceBodyContext.class,0);
}
public List<InterfaceModifierContext> interfaceModifier() {
return getRuleContexts(InterfaceModifierContext.class);
}
public InterfaceModifierContext interfaceModifier(int i) {
return getRuleContext(InterfaceModifierContext.class,i);
}
public TypeParametersContext typeParameters() {
return getRuleContext(TypeParametersContext.class,0);
}
public ExtendsInterfacesContext extendsInterfaces() {
return getRuleContext(ExtendsInterfacesContext.class,0);
}
public NormalInterfaceDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_normalInterfaceDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterNormalInterfaceDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitNormalInterfaceDeclaration(this);
}
}
public final NormalInterfaceDeclarationContext normalInterfaceDeclaration() throws RecognitionException {
NormalInterfaceDeclarationContext _localctx = new NormalInterfaceDeclarationContext(_ctx, getState());
enterRule(_localctx, 220, RULE_normalInterfaceDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1414);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) {
{
{
setState(1411);
interfaceModifier();
}
}
setState(1416);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1417);
match(INTERFACE);
setState(1418);
identifier();
setState(1420);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1419);
typeParameters();
}
}
setState(1423);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXTENDS) {
{
setState(1422);
extendsInterfaces();
}
}
setState(1425);
interfaceBody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InterfaceModifierContext extends ParserRuleContext {
public AnnotationContext annotation() {
return getRuleContext(AnnotationContext.class,0);
}
public InterfaceModifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_interfaceModifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInterfaceModifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInterfaceModifier(this);
}
}
public final InterfaceModifierContext interfaceModifier() throws RecognitionException {
InterfaceModifierContext _localctx = new InterfaceModifierContext(_ctx, getState());
enterRule(_localctx, 222, RULE_interfaceModifier);
try {
setState(1434);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AT:
enterOuterAlt(_localctx, 1);
{
setState(1427);
annotation();
}
break;
case PUBLIC:
enterOuterAlt(_localctx, 2);
{
setState(1428);
match(PUBLIC);
}
break;
case PROTECTED:
enterOuterAlt(_localctx, 3);
{
setState(1429);
match(PROTECTED);
}
break;
case PRIVATE:
enterOuterAlt(_localctx, 4);
{
setState(1430);
match(PRIVATE);
}
break;
case ABSTRACT:
enterOuterAlt(_localctx, 5);
{
setState(1431);
match(ABSTRACT);
}
break;
case STATIC:
enterOuterAlt(_localctx, 6);
{
setState(1432);
match(STATIC);
}
break;
case STRICTFP:
enterOuterAlt(_localctx, 7);
{
setState(1433);
match(STRICTFP);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExtendsInterfacesContext extends ParserRuleContext {
public InterfaceTypeListContext interfaceTypeList() {
return getRuleContext(InterfaceTypeListContext.class,0);
}
public ExtendsInterfacesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_extendsInterfaces; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterExtendsInterfaces(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitExtendsInterfaces(this);
}
}
public final ExtendsInterfacesContext extendsInterfaces() throws RecognitionException {
ExtendsInterfacesContext _localctx = new ExtendsInterfacesContext(_ctx, getState());
enterRule(_localctx, 224, RULE_extendsInterfaces);
try {
enterOuterAlt(_localctx, 1);
{
setState(1436);
match(EXTENDS);
setState(1437);
interfaceTypeList();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InterfaceBodyContext extends ParserRuleContext {
public List<InterfaceMemberDeclarationContext> interfaceMemberDeclaration() {
return getRuleContexts(InterfaceMemberDeclarationContext.class);
}
public InterfaceMemberDeclarationContext interfaceMemberDeclaration(int i) {
return getRuleContext(InterfaceMemberDeclarationContext.class,i);
}
public InterfaceBodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_interfaceBody; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInterfaceBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInterfaceBody(this);
}
}
public final InterfaceBodyContext interfaceBody() throws RecognitionException {
InterfaceBodyContext _localctx = new InterfaceBodyContext(_ctx, getState());
enterRule(_localctx, 226, RULE_interfaceBody);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1439);
match(LBRACE);
setState(1443);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
{
setState(1440);
interfaceMemberDeclaration();
}
}
setState(1445);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1446);
match(RBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InterfaceMemberDeclarationContext extends ParserRuleContext {
public ConstantDeclarationContext constantDeclaration() {
return getRuleContext(ConstantDeclarationContext.class,0);
}
public InterfaceMethodDeclarationContext interfaceMethodDeclaration() {
return getRuleContext(InterfaceMethodDeclarationContext.class,0);
}
public ClassDeclarationContext classDeclaration() {
return getRuleContext(ClassDeclarationContext.class,0);
}
public InterfaceDeclarationContext interfaceDeclaration() {
return getRuleContext(InterfaceDeclarationContext.class,0);
}
public InterfaceMemberDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_interfaceMemberDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInterfaceMemberDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInterfaceMemberDeclaration(this);
}
}
public final InterfaceMemberDeclarationContext interfaceMemberDeclaration() throws RecognitionException {
InterfaceMemberDeclarationContext _localctx = new InterfaceMemberDeclarationContext(_ctx, getState());
enterRule(_localctx, 228, RULE_interfaceMemberDeclaration);
try {
setState(1453);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,142,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1448);
constantDeclaration();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1449);
interfaceMethodDeclaration();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1450);
classDeclaration();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1451);
interfaceDeclaration();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1452);
match(SEMI);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstantDeclarationContext extends ParserRuleContext {
public UnannTypeContext unannType() {
return getRuleContext(UnannTypeContext.class,0);
}
public VariableDeclaratorListContext variableDeclaratorList() {
return getRuleContext(VariableDeclaratorListContext.class,0);
}
public List<ConstantModifierContext> constantModifier() {
return getRuleContexts(ConstantModifierContext.class);
}
public ConstantModifierContext constantModifier(int i) {
return getRuleContext(ConstantModifierContext.class,i);
}
public ConstantDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constantDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterConstantDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitConstantDeclaration(this);
}
}
public final ConstantDeclarationContext constantDeclaration() throws RecognitionException {
ConstantDeclarationContext _localctx = new ConstantDeclarationContext(_ctx, getState());
enterRule(_localctx, 230, RULE_constantDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1458);
_errHandler.sync(this);
_la = _input.LA(1);
while (((((_la - 28)) & ~0x3f) == 0 && ((1L << (_la - 28)) & ((1L << (FINAL - 28)) | (1L << (PUBLIC - 28)) | (1L << (STATIC - 28)) | (1L << (AT - 28)))) != 0)) {
{
{
setState(1455);
constantModifier();
}
}
setState(1460);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1461);
unannType();
setState(1462);
variableDeclaratorList();
setState(1463);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstantModifierContext extends ParserRuleContext {
public AnnotationContext annotation() {
return getRuleContext(AnnotationContext.class,0);
}
public ConstantModifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constantModifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterConstantModifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitConstantModifier(this);
}
}
public final ConstantModifierContext constantModifier() throws RecognitionException {
ConstantModifierContext _localctx = new ConstantModifierContext(_ctx, getState());
enterRule(_localctx, 232, RULE_constantModifier);
try {
setState(1469);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AT:
enterOuterAlt(_localctx, 1);
{
setState(1465);
annotation();
}
break;
case PUBLIC:
enterOuterAlt(_localctx, 2);
{
setState(1466);
match(PUBLIC);
}
break;
case STATIC:
enterOuterAlt(_localctx, 3);
{
setState(1467);
match(STATIC);
}
break;
case FINAL:
enterOuterAlt(_localctx, 4);
{
setState(1468);
match(FINAL);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InterfaceMethodDeclarationContext extends ParserRuleContext {
public MethodHeaderContext methodHeader() {
return getRuleContext(MethodHeaderContext.class,0);
}
public MethodBodyContext methodBody() {
return getRuleContext(MethodBodyContext.class,0);
}
public List<InterfaceMethodModifierContext> interfaceMethodModifier() {
return getRuleContexts(InterfaceMethodModifierContext.class);
}
public InterfaceMethodModifierContext interfaceMethodModifier(int i) {
return getRuleContext(InterfaceMethodModifierContext.class,i);
}
public InterfaceMethodDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_interfaceMethodDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInterfaceMethodDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInterfaceMethodDeclaration(this);
}
}
public final InterfaceMethodDeclarationContext interfaceMethodDeclaration() throws RecognitionException {
InterfaceMethodDeclarationContext _localctx = new InterfaceMethodDeclarationContext(_ctx, getState());
enterRule(_localctx, 234, RULE_interfaceMethodDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1474);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << DEFAULT) | (1L << PRIVATE) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT) {
{
{
setState(1471);
interfaceMethodModifier();
}
}
setState(1476);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1477);
methodHeader();
setState(1478);
methodBody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InterfaceMethodModifierContext extends ParserRuleContext {
public AnnotationContext annotation() {
return getRuleContext(AnnotationContext.class,0);
}
public InterfaceMethodModifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_interfaceMethodModifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInterfaceMethodModifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInterfaceMethodModifier(this);
}
}
public final InterfaceMethodModifierContext interfaceMethodModifier() throws RecognitionException {
InterfaceMethodModifierContext _localctx = new InterfaceMethodModifierContext(_ctx, getState());
enterRule(_localctx, 236, RULE_interfaceMethodModifier);
try {
setState(1487);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AT:
enterOuterAlt(_localctx, 1);
{
setState(1480);
annotation();
}
break;
case PUBLIC:
enterOuterAlt(_localctx, 2);
{
setState(1481);
match(PUBLIC);
}
break;
case PRIVATE:
enterOuterAlt(_localctx, 3);
{
setState(1482);
match(PRIVATE);
}
break;
case ABSTRACT:
enterOuterAlt(_localctx, 4);
{
setState(1483);
match(ABSTRACT);
}
break;
case DEFAULT:
enterOuterAlt(_localctx, 5);
{
setState(1484);
match(DEFAULT);
}
break;
case STATIC:
enterOuterAlt(_localctx, 6);
{
setState(1485);
match(STATIC);
}
break;
case STRICTFP:
enterOuterAlt(_localctx, 7);
{
setState(1486);
match(STRICTFP);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AnnotationTypeDeclarationContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public AnnotationTypeBodyContext annotationTypeBody() {
return getRuleContext(AnnotationTypeBodyContext.class,0);
}
public List<InterfaceModifierContext> interfaceModifier() {
return getRuleContexts(InterfaceModifierContext.class);
}
public InterfaceModifierContext interfaceModifier(int i) {
return getRuleContext(InterfaceModifierContext.class,i);
}
public AnnotationTypeDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotationTypeDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterAnnotationTypeDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitAnnotationTypeDeclaration(this);
}
}
public final AnnotationTypeDeclarationContext annotationTypeDeclaration() throws RecognitionException {
AnnotationTypeDeclarationContext _localctx = new AnnotationTypeDeclarationContext(_ctx, getState());
enterRule(_localctx, 238, RULE_annotationTypeDeclaration);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1492);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,147,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1489);
interfaceModifier();
}
}
}
setState(1494);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,147,_ctx);
}
setState(1495);
match(AT);
setState(1496);
match(INTERFACE);
setState(1497);
identifier();
setState(1498);
annotationTypeBody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AnnotationTypeBodyContext extends ParserRuleContext {
public List<AnnotationTypeMemberDeclarationContext> annotationTypeMemberDeclaration() {
return getRuleContexts(AnnotationTypeMemberDeclarationContext.class);
}
public AnnotationTypeMemberDeclarationContext annotationTypeMemberDeclaration(int i) {
return getRuleContext(AnnotationTypeMemberDeclarationContext.class,i);
}
public AnnotationTypeBodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotationTypeBody; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterAnnotationTypeBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitAnnotationTypeBody(this);
}
}
public final AnnotationTypeBodyContext annotationTypeBody() throws RecognitionException {
AnnotationTypeBodyContext _localctx = new AnnotationTypeBodyContext(_ctx, getState());
enterRule(_localctx, 240, RULE_annotationTypeBody);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1500);
match(LBRACE);
setState(1504);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
{
setState(1501);
annotationTypeMemberDeclaration();
}
}
setState(1506);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1507);
match(RBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AnnotationTypeMemberDeclarationContext extends ParserRuleContext {
public AnnotationTypeElementDeclarationContext annotationTypeElementDeclaration() {
return getRuleContext(AnnotationTypeElementDeclarationContext.class,0);
}
public ConstantDeclarationContext constantDeclaration() {
return getRuleContext(ConstantDeclarationContext.class,0);
}
public ClassDeclarationContext classDeclaration() {
return getRuleContext(ClassDeclarationContext.class,0);
}
public InterfaceDeclarationContext interfaceDeclaration() {
return getRuleContext(InterfaceDeclarationContext.class,0);
}
public AnnotationTypeMemberDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotationTypeMemberDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterAnnotationTypeMemberDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitAnnotationTypeMemberDeclaration(this);
}
}
public final AnnotationTypeMemberDeclarationContext annotationTypeMemberDeclaration() throws RecognitionException {
AnnotationTypeMemberDeclarationContext _localctx = new AnnotationTypeMemberDeclarationContext(_ctx, getState());
enterRule(_localctx, 242, RULE_annotationTypeMemberDeclaration);
try {
setState(1514);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,149,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1509);
annotationTypeElementDeclaration();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1510);
constantDeclaration();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1511);
classDeclaration();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1512);
interfaceDeclaration();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1513);
match(SEMI);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AnnotationTypeElementDeclarationContext extends ParserRuleContext {
public UnannTypeContext unannType() {
return getRuleContext(UnannTypeContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public List<AnnotationTypeElementModifierContext> annotationTypeElementModifier() {
return getRuleContexts(AnnotationTypeElementModifierContext.class);
}
public AnnotationTypeElementModifierContext annotationTypeElementModifier(int i) {
return getRuleContext(AnnotationTypeElementModifierContext.class,i);
}
public DimsContext dims() {
return getRuleContext(DimsContext.class,0);
}
public DefaultValueContext defaultValue() {
return getRuleContext(DefaultValueContext.class,0);
}
public AnnotationTypeElementDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotationTypeElementDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterAnnotationTypeElementDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitAnnotationTypeElementDeclaration(this);
}
}
public final AnnotationTypeElementDeclarationContext annotationTypeElementDeclaration() throws RecognitionException {
AnnotationTypeElementDeclarationContext _localctx = new AnnotationTypeElementDeclarationContext(_ctx, getState());
enterRule(_localctx, 244, RULE_annotationTypeElementDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1519);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==ABSTRACT || _la==PUBLIC || _la==AT) {
{
{
setState(1516);
annotationTypeElementModifier();
}
}
setState(1521);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1522);
unannType();
setState(1523);
identifier();
setState(1524);
match(LPAREN);
setState(1525);
match(RPAREN);
setState(1527);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LBRACK || _la==AT) {
{
setState(1526);
dims();
}
}
setState(1530);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DEFAULT) {
{
setState(1529);
defaultValue();
}
}
setState(1532);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AnnotationTypeElementModifierContext extends ParserRuleContext {
public AnnotationContext annotation() {
return getRuleContext(AnnotationContext.class,0);
}
public AnnotationTypeElementModifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotationTypeElementModifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterAnnotationTypeElementModifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitAnnotationTypeElementModifier(this);
}
}
public final AnnotationTypeElementModifierContext annotationTypeElementModifier() throws RecognitionException {
AnnotationTypeElementModifierContext _localctx = new AnnotationTypeElementModifierContext(_ctx, getState());
enterRule(_localctx, 246, RULE_annotationTypeElementModifier);
try {
setState(1537);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AT:
enterOuterAlt(_localctx, 1);
{
setState(1534);
annotation();
}
break;
case PUBLIC:
enterOuterAlt(_localctx, 2);
{
setState(1535);
match(PUBLIC);
}
break;
case ABSTRACT:
enterOuterAlt(_localctx, 3);
{
setState(1536);
match(ABSTRACT);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DefaultValueContext extends ParserRuleContext {
public ElementValueContext elementValue() {
return getRuleContext(ElementValueContext.class,0);
}
public DefaultValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_defaultValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterDefaultValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitDefaultValue(this);
}
}
public final DefaultValueContext defaultValue() throws RecognitionException {
DefaultValueContext _localctx = new DefaultValueContext(_ctx, getState());
enterRule(_localctx, 248, RULE_defaultValue);
try {
enterOuterAlt(_localctx, 1);
{
setState(1539);
match(DEFAULT);
setState(1540);
elementValue();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AnnotationContext extends ParserRuleContext {
public NormalAnnotationContext normalAnnotation() {
return getRuleContext(NormalAnnotationContext.class,0);
}
public MarkerAnnotationContext markerAnnotation() {
return getRuleContext(MarkerAnnotationContext.class,0);
}
public SingleElementAnnotationContext singleElementAnnotation() {
return getRuleContext(SingleElementAnnotationContext.class,0);
}
public AnnotationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterAnnotation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitAnnotation(this);
}
}
public final AnnotationContext annotation() throws RecognitionException {
AnnotationContext _localctx = new AnnotationContext(_ctx, getState());
enterRule(_localctx, 250, RULE_annotation);
try {
setState(1545);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,154,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1542);
normalAnnotation();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1543);
markerAnnotation();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1544);
singleElementAnnotation();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NormalAnnotationContext extends ParserRuleContext {
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public ElementValuePairListContext elementValuePairList() {
return getRuleContext(ElementValuePairListContext.class,0);
}
public NormalAnnotationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_normalAnnotation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterNormalAnnotation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitNormalAnnotation(this);
}
}
public final NormalAnnotationContext normalAnnotation() throws RecognitionException {
NormalAnnotationContext _localctx = new NormalAnnotationContext(_ctx, getState());
enterRule(_localctx, 252, RULE_normalAnnotation);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1547);
match(AT);
setState(1548);
typeName();
setState(1549);
match(LPAREN);
setState(1551);
_errHandler.sync(this);
_la = _input.LA(1);
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) {
{
setState(1550);
elementValuePairList();
}
}
setState(1553);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ElementValuePairListContext extends ParserRuleContext {
public List<ElementValuePairContext> elementValuePair() {
return getRuleContexts(ElementValuePairContext.class);
}
public ElementValuePairContext elementValuePair(int i) {
return getRuleContext(ElementValuePairContext.class,i);
}
public ElementValuePairListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_elementValuePairList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterElementValuePairList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitElementValuePairList(this);
}
}
public final ElementValuePairListContext elementValuePairList() throws RecognitionException {
ElementValuePairListContext _localctx = new ElementValuePairListContext(_ctx, getState());
enterRule(_localctx, 254, RULE_elementValuePairList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1555);
elementValuePair();
setState(1560);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1556);
match(COMMA);
setState(1557);
elementValuePair();
}
}
setState(1562);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ElementValuePairContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ElementValueContext elementValue() {
return getRuleContext(ElementValueContext.class,0);
}
public ElementValuePairContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_elementValuePair; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterElementValuePair(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitElementValuePair(this);
}
}
public final ElementValuePairContext elementValuePair() throws RecognitionException {
ElementValuePairContext _localctx = new ElementValuePairContext(_ctx, getState());
enterRule(_localctx, 256, RULE_elementValuePair);
try {
enterOuterAlt(_localctx, 1);
{
setState(1563);
identifier();
setState(1564);
match(ASSIGN);
setState(1565);
elementValue();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ElementValueContext extends ParserRuleContext {
public ConditionalExpressionContext conditionalExpression() {
return getRuleContext(ConditionalExpressionContext.class,0);
}
public ElementValueArrayInitializerContext elementValueArrayInitializer() {
return getRuleContext(ElementValueArrayInitializerContext.class,0);
}
public AnnotationContext annotation() {
return getRuleContext(AnnotationContext.class,0);
}
public ElementValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_elementValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterElementValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitElementValue(this);
}
}
public final ElementValueContext elementValue() throws RecognitionException {
ElementValueContext _localctx = new ElementValueContext(_ctx, getState());
enterRule(_localctx, 258, RULE_elementValue);
try {
setState(1570);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1567);
conditionalExpression();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1568);
elementValueArrayInitializer();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1569);
annotation();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ElementValueArrayInitializerContext extends ParserRuleContext {
public ElementValueListContext elementValueList() {
return getRuleContext(ElementValueListContext.class,0);
}
public ElementValueArrayInitializerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_elementValueArrayInitializer; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterElementValueArrayInitializer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitElementValueArrayInitializer(this);
}
}
public final ElementValueArrayInitializerContext elementValueArrayInitializer() throws RecognitionException {
ElementValueArrayInitializerContext _localctx = new ElementValueArrayInitializerContext(_ctx, getState());
enterRule(_localctx, 260, RULE_elementValueArrayInitializer);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1572);
match(LBRACE);
setState(1574);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
setState(1573);
elementValueList();
}
}
setState(1577);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1576);
match(COMMA);
}
}
setState(1579);
match(RBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ElementValueListContext extends ParserRuleContext {
public List<ElementValueContext> elementValue() {
return getRuleContexts(ElementValueContext.class);
}
public ElementValueContext elementValue(int i) {
return getRuleContext(ElementValueContext.class,i);
}
public ElementValueListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_elementValueList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterElementValueList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitElementValueList(this);
}
}
public final ElementValueListContext elementValueList() throws RecognitionException {
ElementValueListContext _localctx = new ElementValueListContext(_ctx, getState());
enterRule(_localctx, 262, RULE_elementValueList);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1581);
elementValue();
setState(1586);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,160,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1582);
match(COMMA);
setState(1583);
elementValue();
}
}
}
setState(1588);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,160,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MarkerAnnotationContext extends ParserRuleContext {
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public MarkerAnnotationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_markerAnnotation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterMarkerAnnotation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitMarkerAnnotation(this);
}
}
public final MarkerAnnotationContext markerAnnotation() throws RecognitionException {
MarkerAnnotationContext _localctx = new MarkerAnnotationContext(_ctx, getState());
enterRule(_localctx, 264, RULE_markerAnnotation);
try {
enterOuterAlt(_localctx, 1);
{
setState(1589);
match(AT);
setState(1590);
typeName();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SingleElementAnnotationContext extends ParserRuleContext {
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public ElementValueContext elementValue() {
return getRuleContext(ElementValueContext.class,0);
}
public SingleElementAnnotationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_singleElementAnnotation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterSingleElementAnnotation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitSingleElementAnnotation(this);
}
}
public final SingleElementAnnotationContext singleElementAnnotation() throws RecognitionException {
SingleElementAnnotationContext _localctx = new SingleElementAnnotationContext(_ctx, getState());
enterRule(_localctx, 266, RULE_singleElementAnnotation);
try {
enterOuterAlt(_localctx, 1);
{
setState(1592);
match(AT);
setState(1593);
typeName();
setState(1594);
match(LPAREN);
setState(1595);
elementValue();
setState(1596);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArrayInitializerContext extends ParserRuleContext {
public VariableInitializerListContext variableInitializerList() {
return getRuleContext(VariableInitializerListContext.class,0);
}
public ArrayInitializerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arrayInitializer; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterArrayInitializer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitArrayInitializer(this);
}
}
public final ArrayInitializerContext arrayInitializer() throws RecognitionException {
ArrayInitializerContext _localctx = new ArrayInitializerContext(_ctx, getState());
enterRule(_localctx, 268, RULE_arrayInitializer);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1598);
match(LBRACE);
setState(1600);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
setState(1599);
variableInitializerList();
}
}
setState(1603);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(1602);
match(COMMA);
}
}
setState(1605);
match(RBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VariableInitializerListContext extends ParserRuleContext {
public List<VariableInitializerContext> variableInitializer() {
return getRuleContexts(VariableInitializerContext.class);
}
public VariableInitializerContext variableInitializer(int i) {
return getRuleContext(VariableInitializerContext.class,i);
}
public VariableInitializerListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_variableInitializerList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterVariableInitializerList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitVariableInitializerList(this);
}
}
public final VariableInitializerListContext variableInitializerList() throws RecognitionException {
VariableInitializerListContext _localctx = new VariableInitializerListContext(_ctx, getState());
enterRule(_localctx, 270, RULE_variableInitializerList);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1607);
variableInitializer();
setState(1612);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,163,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1608);
match(COMMA);
setState(1609);
variableInitializer();
}
}
}
setState(1614);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,163,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BlockContext extends ParserRuleContext {
public BlockStatementsContext blockStatements() {
return getRuleContext(BlockStatementsContext.class,0);
}
public BlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_block; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitBlock(this);
}
}
public final BlockContext block() throws RecognitionException {
BlockContext _localctx = new BlockContext(_ctx, getState());
enterRule(_localctx, 272, RULE_block);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1615);
match(LBRACE);
setState(1617);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
setState(1616);
blockStatements();
}
}
setState(1619);
match(RBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BlockStatementsContext extends ParserRuleContext {
public List<BlockStatementContext> blockStatement() {
return getRuleContexts(BlockStatementContext.class);
}
public BlockStatementContext blockStatement(int i) {
return getRuleContext(BlockStatementContext.class,i);
}
public BlockStatementsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_blockStatements; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterBlockStatements(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitBlockStatements(this);
}
}
public final BlockStatementsContext blockStatements() throws RecognitionException {
BlockStatementsContext _localctx = new BlockStatementsContext(_ctx, getState());
enterRule(_localctx, 274, RULE_blockStatements);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1622);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(1621);
blockStatement();
}
}
setState(1624);
_errHandler.sync(this);
_la = _input.LA(1);
} 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) );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BlockStatementContext extends ParserRuleContext {
public LocalVariableDeclarationStatementContext localVariableDeclarationStatement() {
return getRuleContext(LocalVariableDeclarationStatementContext.class,0);
}
public ClassDeclarationContext classDeclaration() {
return getRuleContext(ClassDeclarationContext.class,0);
}
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public BlockStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_blockStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterBlockStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitBlockStatement(this);
}
}
public final BlockStatementContext blockStatement() throws RecognitionException {
BlockStatementContext _localctx = new BlockStatementContext(_ctx, getState());
enterRule(_localctx, 276, RULE_blockStatement);
try {
setState(1629);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,166,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1626);
localVariableDeclarationStatement();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1627);
classDeclaration();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1628);
statement();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LocalVariableDeclarationStatementContext extends ParserRuleContext {
public LocalVariableDeclarationContext localVariableDeclaration() {
return getRuleContext(LocalVariableDeclarationContext.class,0);
}
public LocalVariableDeclarationStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_localVariableDeclarationStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterLocalVariableDeclarationStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitLocalVariableDeclarationStatement(this);
}
}
public final LocalVariableDeclarationStatementContext localVariableDeclarationStatement() throws RecognitionException {
LocalVariableDeclarationStatementContext _localctx = new LocalVariableDeclarationStatementContext(_ctx, getState());
enterRule(_localctx, 278, RULE_localVariableDeclarationStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(1631);
localVariableDeclaration();
setState(1632);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LocalVariableDeclarationContext extends ParserRuleContext {
public UnannTypeContext unannType() {
return getRuleContext(UnannTypeContext.class,0);
}
public VariableDeclaratorListContext variableDeclaratorList() {
return getRuleContext(VariableDeclaratorListContext.class,0);
}
public List<VariableModifierContext> variableModifier() {
return getRuleContexts(VariableModifierContext.class);
}
public VariableModifierContext variableModifier(int i) {
return getRuleContext(VariableModifierContext.class,i);
}
public LocalVariableDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_localVariableDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterLocalVariableDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitLocalVariableDeclaration(this);
}
}
public final LocalVariableDeclarationContext localVariableDeclaration() throws RecognitionException {
LocalVariableDeclarationContext _localctx = new LocalVariableDeclarationContext(_ctx, getState());
enterRule(_localctx, 280, RULE_localVariableDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1637);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==FINAL || _la==AT) {
{
{
setState(1634);
variableModifier();
}
}
setState(1639);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1640);
unannType();
setState(1641);
variableDeclaratorList();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StatementContext extends ParserRuleContext {
public StatementWithoutTrailingSubstatementContext statementWithoutTrailingSubstatement() {
return getRuleContext(StatementWithoutTrailingSubstatementContext.class,0);
}
public LabeledStatementContext labeledStatement() {
return getRuleContext(LabeledStatementContext.class,0);
}
public IfThenStatementContext ifThenStatement() {
return getRuleContext(IfThenStatementContext.class,0);
}
public IfThenElseStatementContext ifThenElseStatement() {
return getRuleContext(IfThenElseStatementContext.class,0);
}
public WhileStatementContext whileStatement() {
return getRuleContext(WhileStatementContext.class,0);
}
public ForStatementContext forStatement() {
return getRuleContext(ForStatementContext.class,0);
}
public StatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_statement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitStatement(this);
}
}
public final StatementContext statement() throws RecognitionException {
StatementContext _localctx = new StatementContext(_ctx, getState());
enterRule(_localctx, 282, RULE_statement);
try {
setState(1649);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,168,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1643);
statementWithoutTrailingSubstatement();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1644);
labeledStatement();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1645);
ifThenStatement();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1646);
ifThenElseStatement();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1647);
whileStatement();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(1648);
forStatement();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StatementNoShortIfContext extends ParserRuleContext {
public StatementWithoutTrailingSubstatementContext statementWithoutTrailingSubstatement() {
return getRuleContext(StatementWithoutTrailingSubstatementContext.class,0);
}
public LabeledStatementNoShortIfContext labeledStatementNoShortIf() {
return getRuleContext(LabeledStatementNoShortIfContext.class,0);
}
public IfThenElseStatementNoShortIfContext ifThenElseStatementNoShortIf() {
return getRuleContext(IfThenElseStatementNoShortIfContext.class,0);
}
public WhileStatementNoShortIfContext whileStatementNoShortIf() {
return getRuleContext(WhileStatementNoShortIfContext.class,0);
}
public ForStatementNoShortIfContext forStatementNoShortIf() {
return getRuleContext(ForStatementNoShortIfContext.class,0);
}
public StatementNoShortIfContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_statementNoShortIf; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterStatementNoShortIf(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitStatementNoShortIf(this);
}
}
public final StatementNoShortIfContext statementNoShortIf() throws RecognitionException {
StatementNoShortIfContext _localctx = new StatementNoShortIfContext(_ctx, getState());
enterRule(_localctx, 284, RULE_statementNoShortIf);
try {
setState(1656);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,169,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1651);
statementWithoutTrailingSubstatement();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1652);
labeledStatementNoShortIf();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1653);
ifThenElseStatementNoShortIf();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1654);
whileStatementNoShortIf();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1655);
forStatementNoShortIf();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StatementWithoutTrailingSubstatementContext extends ParserRuleContext {
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public EmptyStatementContext emptyStatement() {
return getRuleContext(EmptyStatementContext.class,0);
}
public ExpressionStatementContext expressionStatement() {
return getRuleContext(ExpressionStatementContext.class,0);
}
public AssertStatementContext assertStatement() {
return getRuleContext(AssertStatementContext.class,0);
}
public SwitchStatementContext switchStatement() {
return getRuleContext(SwitchStatementContext.class,0);
}
public DoStatementContext doStatement() {
return getRuleContext(DoStatementContext.class,0);
}
public BreakStatementContext breakStatement() {
return getRuleContext(BreakStatementContext.class,0);
}
public ContinueStatementContext continueStatement() {
return getRuleContext(ContinueStatementContext.class,0);
}
public ReturnStatementContext returnStatement() {
return getRuleContext(ReturnStatementContext.class,0);
}
public SynchronizedStatementContext synchronizedStatement() {
return getRuleContext(SynchronizedStatementContext.class,0);
}
public ThrowStatementContext throwStatement() {
return getRuleContext(ThrowStatementContext.class,0);
}
public TryStatementContext tryStatement() {
return getRuleContext(TryStatementContext.class,0);
}
public StatementWithoutTrailingSubstatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_statementWithoutTrailingSubstatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterStatementWithoutTrailingSubstatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitStatementWithoutTrailingSubstatement(this);
}
}
public final StatementWithoutTrailingSubstatementContext statementWithoutTrailingSubstatement() throws RecognitionException {
StatementWithoutTrailingSubstatementContext _localctx = new StatementWithoutTrailingSubstatementContext(_ctx, getState());
enterRule(_localctx, 286, RULE_statementWithoutTrailingSubstatement);
try {
setState(1670);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LBRACE:
enterOuterAlt(_localctx, 1);
{
setState(1658);
block();
}
break;
case SEMI:
enterOuterAlt(_localctx, 2);
{
setState(1659);
emptyStatement();
}
break;
case T__0:
case T__1:
case T__2:
case T__3:
case T__4:
case T__5:
case T__6:
case T__7:
case T__8:
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case NEW:
case SHORT:
case SUPER:
case THIS:
case VOID:
case IntegerLiteral:
case FloatingPointLiteral:
case BooleanLiteral:
case CharacterLiteral:
case StringLiteral:
case NullLiteral:
case LPAREN:
case AT:
case INC:
case DEC:
case Identifier:
enterOuterAlt(_localctx, 3);
{
setState(1660);
expressionStatement();
}
break;
case ASSERT:
enterOuterAlt(_localctx, 4);
{
setState(1661);
assertStatement();
}
break;
case SWITCH:
enterOuterAlt(_localctx, 5);
{
setState(1662);
switchStatement();
}
break;
case DO:
enterOuterAlt(_localctx, 6);
{
setState(1663);
doStatement();
}
break;
case BREAK:
enterOuterAlt(_localctx, 7);
{
setState(1664);
breakStatement();
}
break;
case CONTINUE:
enterOuterAlt(_localctx, 8);
{
setState(1665);
continueStatement();
}
break;
case RETURN:
enterOuterAlt(_localctx, 9);
{
setState(1666);
returnStatement();
}
break;
case SYNCHRONIZED:
enterOuterAlt(_localctx, 10);
{
setState(1667);
synchronizedStatement();
}
break;
case THROW:
enterOuterAlt(_localctx, 11);
{
setState(1668);
throwStatement();
}
break;
case TRY:
enterOuterAlt(_localctx, 12);
{
setState(1669);
tryStatement();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EmptyStatementContext extends ParserRuleContext {
public EmptyStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_emptyStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterEmptyStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitEmptyStatement(this);
}
}
public final EmptyStatementContext emptyStatement() throws RecognitionException {
EmptyStatementContext _localctx = new EmptyStatementContext(_ctx, getState());
enterRule(_localctx, 288, RULE_emptyStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(1672);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LabeledStatementContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public LabeledStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_labeledStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterLabeledStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitLabeledStatement(this);
}
}
public final LabeledStatementContext labeledStatement() throws RecognitionException {
LabeledStatementContext _localctx = new LabeledStatementContext(_ctx, getState());
enterRule(_localctx, 290, RULE_labeledStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(1674);
identifier();
setState(1675);
match(COLON);
setState(1676);
statement();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LabeledStatementNoShortIfContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public StatementNoShortIfContext statementNoShortIf() {
return getRuleContext(StatementNoShortIfContext.class,0);
}
public LabeledStatementNoShortIfContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_labeledStatementNoShortIf; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterLabeledStatementNoShortIf(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitLabeledStatementNoShortIf(this);
}
}
public final LabeledStatementNoShortIfContext labeledStatementNoShortIf() throws RecognitionException {
LabeledStatementNoShortIfContext _localctx = new LabeledStatementNoShortIfContext(_ctx, getState());
enterRule(_localctx, 292, RULE_labeledStatementNoShortIf);
try {
enterOuterAlt(_localctx, 1);
{
setState(1678);
identifier();
setState(1679);
match(COLON);
setState(1680);
statementNoShortIf();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionStatementContext extends ParserRuleContext {
public StatementExpressionContext statementExpression() {
return getRuleContext(StatementExpressionContext.class,0);
}
public ExpressionStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterExpressionStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitExpressionStatement(this);
}
}
public final ExpressionStatementContext expressionStatement() throws RecognitionException {
ExpressionStatementContext _localctx = new ExpressionStatementContext(_ctx, getState());
enterRule(_localctx, 294, RULE_expressionStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(1682);
statementExpression();
setState(1683);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StatementExpressionContext extends ParserRuleContext {
public AssignmentContext assignment() {
return getRuleContext(AssignmentContext.class,0);
}
public PreIncrementExpressionContext preIncrementExpression() {
return getRuleContext(PreIncrementExpressionContext.class,0);
}
public PreDecrementExpressionContext preDecrementExpression() {
return getRuleContext(PreDecrementExpressionContext.class,0);
}
public PostIncrementExpressionContext postIncrementExpression() {
return getRuleContext(PostIncrementExpressionContext.class,0);
}
public PostDecrementExpressionContext postDecrementExpression() {
return getRuleContext(PostDecrementExpressionContext.class,0);
}
public MethodInvocationContext methodInvocation() {
return getRuleContext(MethodInvocationContext.class,0);
}
public ClassInstanceCreationExpressionContext classInstanceCreationExpression() {
return getRuleContext(ClassInstanceCreationExpressionContext.class,0);
}
public StatementExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_statementExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterStatementExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitStatementExpression(this);
}
}
public final StatementExpressionContext statementExpression() throws RecognitionException {
StatementExpressionContext _localctx = new StatementExpressionContext(_ctx, getState());
enterRule(_localctx, 296, RULE_statementExpression);
try {
setState(1692);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,171,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1685);
assignment();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1686);
preIncrementExpression();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1687);
preDecrementExpression();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1688);
postIncrementExpression();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1689);
postDecrementExpression();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(1690);
methodInvocation();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(1691);
classInstanceCreationExpression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IfThenStatementContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public IfThenStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ifThenStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterIfThenStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitIfThenStatement(this);
}
}
public final IfThenStatementContext ifThenStatement() throws RecognitionException {
IfThenStatementContext _localctx = new IfThenStatementContext(_ctx, getState());
enterRule(_localctx, 298, RULE_ifThenStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(1694);
match(IF);
setState(1695);
match(LPAREN);
setState(1696);
expression();
setState(1697);
match(RPAREN);
setState(1698);
statement();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IfThenElseStatementContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public StatementNoShortIfContext statementNoShortIf() {
return getRuleContext(StatementNoShortIfContext.class,0);
}
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public IfThenElseStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ifThenElseStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterIfThenElseStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitIfThenElseStatement(this);
}
}
public final IfThenElseStatementContext ifThenElseStatement() throws RecognitionException {
IfThenElseStatementContext _localctx = new IfThenElseStatementContext(_ctx, getState());
enterRule(_localctx, 300, RULE_ifThenElseStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(1700);
match(IF);
setState(1701);
match(LPAREN);
setState(1702);
expression();
setState(1703);
match(RPAREN);
setState(1704);
statementNoShortIf();
setState(1705);
match(ELSE);
setState(1706);
statement();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IfThenElseStatementNoShortIfContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public List<StatementNoShortIfContext> statementNoShortIf() {
return getRuleContexts(StatementNoShortIfContext.class);
}
public StatementNoShortIfContext statementNoShortIf(int i) {
return getRuleContext(StatementNoShortIfContext.class,i);
}
public IfThenElseStatementNoShortIfContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ifThenElseStatementNoShortIf; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterIfThenElseStatementNoShortIf(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitIfThenElseStatementNoShortIf(this);
}
}
public final IfThenElseStatementNoShortIfContext ifThenElseStatementNoShortIf() throws RecognitionException {
IfThenElseStatementNoShortIfContext _localctx = new IfThenElseStatementNoShortIfContext(_ctx, getState());
enterRule(_localctx, 302, RULE_ifThenElseStatementNoShortIf);
try {
enterOuterAlt(_localctx, 1);
{
setState(1708);
match(IF);
setState(1709);
match(LPAREN);
setState(1710);
expression();
setState(1711);
match(RPAREN);
setState(1712);
statementNoShortIf();
setState(1713);
match(ELSE);
setState(1714);
statementNoShortIf();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AssertStatementContext extends ParserRuleContext {
public List<ExpressionContext> expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public AssertStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assertStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterAssertStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitAssertStatement(this);
}
}
public final AssertStatementContext assertStatement() throws RecognitionException {
AssertStatementContext _localctx = new AssertStatementContext(_ctx, getState());
enterRule(_localctx, 304, RULE_assertStatement);
try {
setState(1726);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,172,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1716);
match(ASSERT);
setState(1717);
expression();
setState(1718);
match(SEMI);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1720);
match(ASSERT);
setState(1721);
expression();
setState(1722);
match(COLON);
setState(1723);
expression();
setState(1724);
match(SEMI);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SwitchStatementContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public SwitchBlockContext switchBlock() {
return getRuleContext(SwitchBlockContext.class,0);
}
public SwitchStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_switchStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterSwitchStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitSwitchStatement(this);
}
}
public final SwitchStatementContext switchStatement() throws RecognitionException {
SwitchStatementContext _localctx = new SwitchStatementContext(_ctx, getState());
enterRule(_localctx, 306, RULE_switchStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(1728);
match(SWITCH);
setState(1729);
match(LPAREN);
setState(1730);
expression();
setState(1731);
match(RPAREN);
setState(1732);
switchBlock();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SwitchBlockContext extends ParserRuleContext {
public List<SwitchBlockStatementGroupContext> switchBlockStatementGroup() {
return getRuleContexts(SwitchBlockStatementGroupContext.class);
}
public SwitchBlockStatementGroupContext switchBlockStatementGroup(int i) {
return getRuleContext(SwitchBlockStatementGroupContext.class,i);
}
public List<SwitchLabelContext> switchLabel() {
return getRuleContexts(SwitchLabelContext.class);
}
public SwitchLabelContext switchLabel(int i) {
return getRuleContext(SwitchLabelContext.class,i);
}
public SwitchBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_switchBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterSwitchBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitSwitchBlock(this);
}
}
public final SwitchBlockContext switchBlock() throws RecognitionException {
SwitchBlockContext _localctx = new SwitchBlockContext(_ctx, getState());
enterRule(_localctx, 308, RULE_switchBlock);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1734);
match(LBRACE);
setState(1738);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,173,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1735);
switchBlockStatementGroup();
}
}
}
setState(1740);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,173,_ctx);
}
setState(1744);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==CASE || _la==DEFAULT) {
{
{
setState(1741);
switchLabel();
}
}
setState(1746);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1747);
match(RBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SwitchBlockStatementGroupContext extends ParserRuleContext {
public SwitchLabelsContext switchLabels() {
return getRuleContext(SwitchLabelsContext.class,0);
}
public BlockStatementsContext blockStatements() {
return getRuleContext(BlockStatementsContext.class,0);
}
public SwitchBlockStatementGroupContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_switchBlockStatementGroup; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterSwitchBlockStatementGroup(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitSwitchBlockStatementGroup(this);
}
}
public final SwitchBlockStatementGroupContext switchBlockStatementGroup() throws RecognitionException {
SwitchBlockStatementGroupContext _localctx = new SwitchBlockStatementGroupContext(_ctx, getState());
enterRule(_localctx, 310, RULE_switchBlockStatementGroup);
try {
enterOuterAlt(_localctx, 1);
{
setState(1749);
switchLabels();
setState(1750);
blockStatements();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SwitchLabelsContext extends ParserRuleContext {
public List<SwitchLabelContext> switchLabel() {
return getRuleContexts(SwitchLabelContext.class);
}
public SwitchLabelContext switchLabel(int i) {
return getRuleContext(SwitchLabelContext.class,i);
}
public SwitchLabelsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_switchLabels; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterSwitchLabels(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitSwitchLabels(this);
}
}
public final SwitchLabelsContext switchLabels() throws RecognitionException {
SwitchLabelsContext _localctx = new SwitchLabelsContext(_ctx, getState());
enterRule(_localctx, 312, RULE_switchLabels);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1753);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(1752);
switchLabel();
}
}
setState(1755);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==CASE || _la==DEFAULT );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SwitchLabelContext extends ParserRuleContext {
public ConstantExpressionContext constantExpression() {
return getRuleContext(ConstantExpressionContext.class,0);
}
public EnumConstantNameContext enumConstantName() {
return getRuleContext(EnumConstantNameContext.class,0);
}
public SwitchLabelContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_switchLabel; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterSwitchLabel(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitSwitchLabel(this);
}
}
public final SwitchLabelContext switchLabel() throws RecognitionException {
SwitchLabelContext _localctx = new SwitchLabelContext(_ctx, getState());
enterRule(_localctx, 314, RULE_switchLabel);
try {
setState(1767);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,176,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1757);
match(CASE);
setState(1758);
constantExpression();
setState(1759);
match(COLON);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1761);
match(CASE);
setState(1762);
enumConstantName();
setState(1763);
match(COLON);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1765);
match(DEFAULT);
setState(1766);
match(COLON);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumConstantNameContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public EnumConstantNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumConstantName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterEnumConstantName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitEnumConstantName(this);
}
}
public final EnumConstantNameContext enumConstantName() throws RecognitionException {
EnumConstantNameContext _localctx = new EnumConstantNameContext(_ctx, getState());
enterRule(_localctx, 316, RULE_enumConstantName);
try {
enterOuterAlt(_localctx, 1);
{
setState(1769);
identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WhileStatementContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public WhileStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_whileStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterWhileStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitWhileStatement(this);
}
}
public final WhileStatementContext whileStatement() throws RecognitionException {
WhileStatementContext _localctx = new WhileStatementContext(_ctx, getState());
enterRule(_localctx, 318, RULE_whileStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(1771);
match(WHILE);
setState(1772);
match(LPAREN);
setState(1773);
expression();
setState(1774);
match(RPAREN);
setState(1775);
statement();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WhileStatementNoShortIfContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public StatementNoShortIfContext statementNoShortIf() {
return getRuleContext(StatementNoShortIfContext.class,0);
}
public WhileStatementNoShortIfContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_whileStatementNoShortIf; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterWhileStatementNoShortIf(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitWhileStatementNoShortIf(this);
}
}
public final WhileStatementNoShortIfContext whileStatementNoShortIf() throws RecognitionException {
WhileStatementNoShortIfContext _localctx = new WhileStatementNoShortIfContext(_ctx, getState());
enterRule(_localctx, 320, RULE_whileStatementNoShortIf);
try {
enterOuterAlt(_localctx, 1);
{
setState(1777);
match(WHILE);
setState(1778);
match(LPAREN);
setState(1779);
expression();
setState(1780);
match(RPAREN);
setState(1781);
statementNoShortIf();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DoStatementContext extends ParserRuleContext {
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public DoStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_doStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterDoStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitDoStatement(this);
}
}
public final DoStatementContext doStatement() throws RecognitionException {
DoStatementContext _localctx = new DoStatementContext(_ctx, getState());
enterRule(_localctx, 322, RULE_doStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(1783);
match(DO);
setState(1784);
statement();
setState(1785);
match(WHILE);
setState(1786);
match(LPAREN);
setState(1787);
expression();
setState(1788);
match(RPAREN);
setState(1789);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ForStatementContext extends ParserRuleContext {
public BasicForStatementContext basicForStatement() {
return getRuleContext(BasicForStatementContext.class,0);
}
public EnhancedForStatementContext enhancedForStatement() {
return getRuleContext(EnhancedForStatementContext.class,0);
}
public ForStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterForStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitForStatement(this);
}
}
public final ForStatementContext forStatement() throws RecognitionException {
ForStatementContext _localctx = new ForStatementContext(_ctx, getState());
enterRule(_localctx, 324, RULE_forStatement);
try {
setState(1793);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,177,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1791);
basicForStatement();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1792);
enhancedForStatement();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ForStatementNoShortIfContext extends ParserRuleContext {
public BasicForStatementNoShortIfContext basicForStatementNoShortIf() {
return getRuleContext(BasicForStatementNoShortIfContext.class,0);
}
public EnhancedForStatementNoShortIfContext enhancedForStatementNoShortIf() {
return getRuleContext(EnhancedForStatementNoShortIfContext.class,0);
}
public ForStatementNoShortIfContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forStatementNoShortIf; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterForStatementNoShortIf(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitForStatementNoShortIf(this);
}
}
public final ForStatementNoShortIfContext forStatementNoShortIf() throws RecognitionException {
ForStatementNoShortIfContext _localctx = new ForStatementNoShortIfContext(_ctx, getState());
enterRule(_localctx, 326, RULE_forStatementNoShortIf);
try {
setState(1797);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,178,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1795);
basicForStatementNoShortIf();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1796);
enhancedForStatementNoShortIf();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BasicForStatementContext extends ParserRuleContext {
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public ForInitContext forInit() {
return getRuleContext(ForInitContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ForUpdateContext forUpdate() {
return getRuleContext(ForUpdateContext.class,0);
}
public BasicForStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_basicForStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterBasicForStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitBasicForStatement(this);
}
}
public final BasicForStatementContext basicForStatement() throws RecognitionException {
BasicForStatementContext _localctx = new BasicForStatementContext(_ctx, getState());
enterRule(_localctx, 328, RULE_basicForStatement);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1799);
match(FOR);
setState(1800);
match(LPAREN);
setState(1802);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
setState(1801);
forInit();
}
}
setState(1804);
match(SEMI);
setState(1806);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
setState(1805);
expression();
}
}
setState(1808);
match(SEMI);
setState(1810);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
setState(1809);
forUpdate();
}
}
setState(1812);
match(RPAREN);
setState(1813);
statement();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BasicForStatementNoShortIfContext extends ParserRuleContext {
public StatementNoShortIfContext statementNoShortIf() {
return getRuleContext(StatementNoShortIfContext.class,0);
}
public ForInitContext forInit() {
return getRuleContext(ForInitContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ForUpdateContext forUpdate() {
return getRuleContext(ForUpdateContext.class,0);
}
public BasicForStatementNoShortIfContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_basicForStatementNoShortIf; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterBasicForStatementNoShortIf(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitBasicForStatementNoShortIf(this);
}
}
public final BasicForStatementNoShortIfContext basicForStatementNoShortIf() throws RecognitionException {
BasicForStatementNoShortIfContext _localctx = new BasicForStatementNoShortIfContext(_ctx, getState());
enterRule(_localctx, 330, RULE_basicForStatementNoShortIf);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1815);
match(FOR);
setState(1816);
match(LPAREN);
setState(1818);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
setState(1817);
forInit();
}
}
setState(1820);
match(SEMI);
setState(1822);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
setState(1821);
expression();
}
}
setState(1824);
match(SEMI);
setState(1826);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
setState(1825);
forUpdate();
}
}
setState(1828);
match(RPAREN);
setState(1829);
statementNoShortIf();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ForInitContext extends ParserRuleContext {
public StatementExpressionListContext statementExpressionList() {
return getRuleContext(StatementExpressionListContext.class,0);
}
public LocalVariableDeclarationContext localVariableDeclaration() {
return getRuleContext(LocalVariableDeclarationContext.class,0);
}
public ForInitContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forInit; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterForInit(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitForInit(this);
}
}
public final ForInitContext forInit() throws RecognitionException {
ForInitContext _localctx = new ForInitContext(_ctx, getState());
enterRule(_localctx, 332, RULE_forInit);
try {
setState(1833);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,185,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1831);
statementExpressionList();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1832);
localVariableDeclaration();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ForUpdateContext extends ParserRuleContext {
public StatementExpressionListContext statementExpressionList() {
return getRuleContext(StatementExpressionListContext.class,0);
}
public ForUpdateContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forUpdate; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterForUpdate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitForUpdate(this);
}
}
public final ForUpdateContext forUpdate() throws RecognitionException {
ForUpdateContext _localctx = new ForUpdateContext(_ctx, getState());
enterRule(_localctx, 334, RULE_forUpdate);
try {
enterOuterAlt(_localctx, 1);
{
setState(1835);
statementExpressionList();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StatementExpressionListContext extends ParserRuleContext {
public List<StatementExpressionContext> statementExpression() {
return getRuleContexts(StatementExpressionContext.class);
}
public StatementExpressionContext statementExpression(int i) {
return getRuleContext(StatementExpressionContext.class,i);
}
public StatementExpressionListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_statementExpressionList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterStatementExpressionList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitStatementExpressionList(this);
}
}
public final StatementExpressionListContext statementExpressionList() throws RecognitionException {
StatementExpressionListContext _localctx = new StatementExpressionListContext(_ctx, getState());
enterRule(_localctx, 336, RULE_statementExpressionList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1837);
statementExpression();
setState(1842);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1838);
match(COMMA);
setState(1839);
statementExpression();
}
}
setState(1844);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnhancedForStatementContext extends ParserRuleContext {
public UnannTypeContext unannType() {
return getRuleContext(UnannTypeContext.class,0);
}
public VariableDeclaratorIdContext variableDeclaratorId() {
return getRuleContext(VariableDeclaratorIdContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public List<VariableModifierContext> variableModifier() {
return getRuleContexts(VariableModifierContext.class);
}
public VariableModifierContext variableModifier(int i) {
return getRuleContext(VariableModifierContext.class,i);
}
public EnhancedForStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enhancedForStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterEnhancedForStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitEnhancedForStatement(this);
}
}
public final EnhancedForStatementContext enhancedForStatement() throws RecognitionException {
EnhancedForStatementContext _localctx = new EnhancedForStatementContext(_ctx, getState());
enterRule(_localctx, 338, RULE_enhancedForStatement);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1845);
match(FOR);
setState(1846);
match(LPAREN);
setState(1850);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==FINAL || _la==AT) {
{
{
setState(1847);
variableModifier();
}
}
setState(1852);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1853);
unannType();
setState(1854);
variableDeclaratorId();
setState(1855);
match(COLON);
setState(1856);
expression();
setState(1857);
match(RPAREN);
setState(1858);
statement();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnhancedForStatementNoShortIfContext extends ParserRuleContext {
public UnannTypeContext unannType() {
return getRuleContext(UnannTypeContext.class,0);
}
public VariableDeclaratorIdContext variableDeclaratorId() {
return getRuleContext(VariableDeclaratorIdContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public StatementNoShortIfContext statementNoShortIf() {
return getRuleContext(StatementNoShortIfContext.class,0);
}
public List<VariableModifierContext> variableModifier() {
return getRuleContexts(VariableModifierContext.class);
}
public VariableModifierContext variableModifier(int i) {
return getRuleContext(VariableModifierContext.class,i);
}
public EnhancedForStatementNoShortIfContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enhancedForStatementNoShortIf; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterEnhancedForStatementNoShortIf(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitEnhancedForStatementNoShortIf(this);
}
}
public final EnhancedForStatementNoShortIfContext enhancedForStatementNoShortIf() throws RecognitionException {
EnhancedForStatementNoShortIfContext _localctx = new EnhancedForStatementNoShortIfContext(_ctx, getState());
enterRule(_localctx, 340, RULE_enhancedForStatementNoShortIf);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1860);
match(FOR);
setState(1861);
match(LPAREN);
setState(1865);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==FINAL || _la==AT) {
{
{
setState(1862);
variableModifier();
}
}
setState(1867);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1868);
unannType();
setState(1869);
variableDeclaratorId();
setState(1870);
match(COLON);
setState(1871);
expression();
setState(1872);
match(RPAREN);
setState(1873);
statementNoShortIf();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BreakStatementContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public BreakStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_breakStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterBreakStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitBreakStatement(this);
}
}
public final BreakStatementContext breakStatement() throws RecognitionException {
BreakStatementContext _localctx = new BreakStatementContext(_ctx, getState());
enterRule(_localctx, 342, RULE_breakStatement);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1875);
match(BREAK);
setState(1877);
_errHandler.sync(this);
_la = _input.LA(1);
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) {
{
setState(1876);
identifier();
}
}
setState(1879);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ContinueStatementContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ContinueStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_continueStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterContinueStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitContinueStatement(this);
}
}
public final ContinueStatementContext continueStatement() throws RecognitionException {
ContinueStatementContext _localctx = new ContinueStatementContext(_ctx, getState());
enterRule(_localctx, 344, RULE_continueStatement);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1881);
match(CONTINUE);
setState(1883);
_errHandler.sync(this);
_la = _input.LA(1);
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) {
{
setState(1882);
identifier();
}
}
setState(1885);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ReturnStatementContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ReturnStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_returnStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterReturnStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitReturnStatement(this);
}
}
public final ReturnStatementContext returnStatement() throws RecognitionException {
ReturnStatementContext _localctx = new ReturnStatementContext(_ctx, getState());
enterRule(_localctx, 346, RULE_returnStatement);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1887);
match(RETURN);
setState(1889);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
setState(1888);
expression();
}
}
setState(1891);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ThrowStatementContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ThrowStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_throwStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterThrowStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitThrowStatement(this);
}
}
public final ThrowStatementContext throwStatement() throws RecognitionException {
ThrowStatementContext _localctx = new ThrowStatementContext(_ctx, getState());
enterRule(_localctx, 348, RULE_throwStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(1893);
match(THROW);
setState(1894);
expression();
setState(1895);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SynchronizedStatementContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public SynchronizedStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_synchronizedStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterSynchronizedStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitSynchronizedStatement(this);
}
}
public final SynchronizedStatementContext synchronizedStatement() throws RecognitionException {
SynchronizedStatementContext _localctx = new SynchronizedStatementContext(_ctx, getState());
enterRule(_localctx, 350, RULE_synchronizedStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(1897);
match(SYNCHRONIZED);
setState(1898);
match(LPAREN);
setState(1899);
expression();
setState(1900);
match(RPAREN);
setState(1901);
block();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TryStatementContext extends ParserRuleContext {
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public CatchesContext catches() {
return getRuleContext(CatchesContext.class,0);
}
public Finally_Context finally_() {
return getRuleContext(Finally_Context.class,0);
}
public TryWithResourcesStatementContext tryWithResourcesStatement() {
return getRuleContext(TryWithResourcesStatementContext.class,0);
}
public TryStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tryStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTryStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTryStatement(this);
}
}
public final TryStatementContext tryStatement() throws RecognitionException {
TryStatementContext _localctx = new TryStatementContext(_ctx, getState());
enterRule(_localctx, 352, RULE_tryStatement);
int _la;
try {
setState(1915);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,193,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1903);
match(TRY);
setState(1904);
block();
setState(1905);
catches();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1907);
match(TRY);
setState(1908);
block();
setState(1910);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==CATCH) {
{
setState(1909);
catches();
}
}
setState(1912);
finally_();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1914);
tryWithResourcesStatement();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CatchesContext extends ParserRuleContext {
public List<CatchClauseContext> catchClause() {
return getRuleContexts(CatchClauseContext.class);
}
public CatchClauseContext catchClause(int i) {
return getRuleContext(CatchClauseContext.class,i);
}
public CatchesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_catches; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterCatches(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitCatches(this);
}
}
public final CatchesContext catches() throws RecognitionException {
CatchesContext _localctx = new CatchesContext(_ctx, getState());
enterRule(_localctx, 354, RULE_catches);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1918);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(1917);
catchClause();
}
}
setState(1920);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==CATCH );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CatchClauseContext extends ParserRuleContext {
public CatchFormalParameterContext catchFormalParameter() {
return getRuleContext(CatchFormalParameterContext.class,0);
}
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public CatchClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_catchClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterCatchClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitCatchClause(this);
}
}
public final CatchClauseContext catchClause() throws RecognitionException {
CatchClauseContext _localctx = new CatchClauseContext(_ctx, getState());
enterRule(_localctx, 356, RULE_catchClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(1922);
match(CATCH);
setState(1923);
match(LPAREN);
setState(1924);
catchFormalParameter();
setState(1925);
match(RPAREN);
setState(1926);
block();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CatchFormalParameterContext extends ParserRuleContext {
public CatchTypeContext catchType() {
return getRuleContext(CatchTypeContext.class,0);
}
public VariableDeclaratorIdContext variableDeclaratorId() {
return getRuleContext(VariableDeclaratorIdContext.class,0);
}
public List<VariableModifierContext> variableModifier() {
return getRuleContexts(VariableModifierContext.class);
}
public VariableModifierContext variableModifier(int i) {
return getRuleContext(VariableModifierContext.class,i);
}
public CatchFormalParameterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_catchFormalParameter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterCatchFormalParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitCatchFormalParameter(this);
}
}
public final CatchFormalParameterContext catchFormalParameter() throws RecognitionException {
CatchFormalParameterContext _localctx = new CatchFormalParameterContext(_ctx, getState());
enterRule(_localctx, 358, RULE_catchFormalParameter);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1931);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==FINAL || _la==AT) {
{
{
setState(1928);
variableModifier();
}
}
setState(1933);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1934);
catchType();
setState(1935);
variableDeclaratorId();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CatchTypeContext extends ParserRuleContext {
public UnannClassTypeContext unannClassType() {
return getRuleContext(UnannClassTypeContext.class,0);
}
public List<ClassTypeContext> classType() {
return getRuleContexts(ClassTypeContext.class);
}
public ClassTypeContext classType(int i) {
return getRuleContext(ClassTypeContext.class,i);
}
public CatchTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_catchType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterCatchType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitCatchType(this);
}
}
public final CatchTypeContext catchType() throws RecognitionException {
CatchTypeContext _localctx = new CatchTypeContext(_ctx, getState());
enterRule(_localctx, 360, RULE_catchType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1937);
unannClassType();
setState(1942);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==BITOR) {
{
{
setState(1938);
match(BITOR);
setState(1939);
classType();
}
}
setState(1944);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Finally_Context extends ParserRuleContext {
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public Finally_Context(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_finally_; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterFinally_(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitFinally_(this);
}
}
public final Finally_Context finally_() throws RecognitionException {
Finally_Context _localctx = new Finally_Context(_ctx, getState());
enterRule(_localctx, 362, RULE_finally_);
try {
enterOuterAlt(_localctx, 1);
{
setState(1945);
match(FINALLY);
setState(1946);
block();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TryWithResourcesStatementContext extends ParserRuleContext {
public ResourceSpecificationContext resourceSpecification() {
return getRuleContext(ResourceSpecificationContext.class,0);
}
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public CatchesContext catches() {
return getRuleContext(CatchesContext.class,0);
}
public Finally_Context finally_() {
return getRuleContext(Finally_Context.class,0);
}
public TryWithResourcesStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tryWithResourcesStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTryWithResourcesStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTryWithResourcesStatement(this);
}
}
public final TryWithResourcesStatementContext tryWithResourcesStatement() throws RecognitionException {
TryWithResourcesStatementContext _localctx = new TryWithResourcesStatementContext(_ctx, getState());
enterRule(_localctx, 364, RULE_tryWithResourcesStatement);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1948);
match(TRY);
setState(1949);
resourceSpecification();
setState(1950);
block();
setState(1952);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==CATCH) {
{
setState(1951);
catches();
}
}
setState(1955);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FINALLY) {
{
setState(1954);
finally_();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ResourceSpecificationContext extends ParserRuleContext {
public ResourceListContext resourceList() {
return getRuleContext(ResourceListContext.class,0);
}
public ResourceSpecificationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_resourceSpecification; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterResourceSpecification(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitResourceSpecification(this);
}
}
public final ResourceSpecificationContext resourceSpecification() throws RecognitionException {
ResourceSpecificationContext _localctx = new ResourceSpecificationContext(_ctx, getState());
enterRule(_localctx, 366, RULE_resourceSpecification);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1957);
match(LPAREN);
setState(1958);
resourceList();
setState(1960);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SEMI) {
{
setState(1959);
match(SEMI);
}
}
setState(1962);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ResourceListContext extends ParserRuleContext {
public List<ResourceContext> resource() {
return getRuleContexts(ResourceContext.class);
}
public ResourceContext resource(int i) {
return getRuleContext(ResourceContext.class,i);
}
public ResourceListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_resourceList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterResourceList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitResourceList(this);
}
}
public final ResourceListContext resourceList() throws RecognitionException {
ResourceListContext _localctx = new ResourceListContext(_ctx, getState());
enterRule(_localctx, 368, RULE_resourceList);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1964);
resource();
setState(1969);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,200,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1965);
match(SEMI);
setState(1966);
resource();
}
}
}
setState(1971);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,200,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ResourceContext extends ParserRuleContext {
public UnannTypeContext unannType() {
return getRuleContext(UnannTypeContext.class,0);
}
public VariableDeclaratorIdContext variableDeclaratorId() {
return getRuleContext(VariableDeclaratorIdContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public List<VariableModifierContext> variableModifier() {
return getRuleContexts(VariableModifierContext.class);
}
public VariableModifierContext variableModifier(int i) {
return getRuleContext(VariableModifierContext.class,i);
}
public VariableAccessContext variableAccess() {
return getRuleContext(VariableAccessContext.class,0);
}
public ResourceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_resource; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterResource(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitResource(this);
}
}
public final ResourceContext resource() throws RecognitionException {
ResourceContext _localctx = new ResourceContext(_ctx, getState());
enterRule(_localctx, 370, RULE_resource);
int _la;
try {
setState(1984);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,202,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1975);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==FINAL || _la==AT) {
{
{
setState(1972);
variableModifier();
}
}
setState(1977);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1978);
unannType();
setState(1979);
variableDeclaratorId();
setState(1980);
match(ASSIGN);
setState(1981);
expression();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1983);
variableAccess();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VariableAccessContext extends ParserRuleContext {
public ExpressionNameContext expressionName() {
return getRuleContext(ExpressionNameContext.class,0);
}
public FieldAccessContext fieldAccess() {
return getRuleContext(FieldAccessContext.class,0);
}
public VariableAccessContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_variableAccess; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterVariableAccess(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitVariableAccess(this);
}
}
public final VariableAccessContext variableAccess() throws RecognitionException {
VariableAccessContext _localctx = new VariableAccessContext(_ctx, getState());
enterRule(_localctx, 372, RULE_variableAccess);
try {
setState(1988);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,203,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1986);
expressionName();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1987);
fieldAccess();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PrimaryContext extends ParserRuleContext {
public PrimaryNoNewArray_lfno_primaryContext primaryNoNewArray_lfno_primary() {
return getRuleContext(PrimaryNoNewArray_lfno_primaryContext.class,0);
}
public ArrayCreationExpressionContext arrayCreationExpression() {
return getRuleContext(ArrayCreationExpressionContext.class,0);
}
public List<PrimaryNoNewArray_lf_primaryContext> primaryNoNewArray_lf_primary() {
return getRuleContexts(PrimaryNoNewArray_lf_primaryContext.class);
}
public PrimaryNoNewArray_lf_primaryContext primaryNoNewArray_lf_primary(int i) {
return getRuleContext(PrimaryNoNewArray_lf_primaryContext.class,i);
}
public PrimaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primary; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPrimary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPrimary(this);
}
}
public final PrimaryContext primary() throws RecognitionException {
PrimaryContext _localctx = new PrimaryContext(_ctx, getState());
enterRule(_localctx, 374, RULE_primary);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1992);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,204,_ctx) ) {
case 1:
{
setState(1990);
primaryNoNewArray_lfno_primary();
}
break;
case 2:
{
setState(1991);
arrayCreationExpression();
}
break;
}
setState(1997);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,205,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1994);
primaryNoNewArray_lf_primary();
}
}
}
setState(1999);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,205,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PrimaryNoNewArrayContext extends ParserRuleContext {
public LiteralContext literal() {
return getRuleContext(LiteralContext.class,0);
}
public ClassLiteralContext classLiteral() {
return getRuleContext(ClassLiteralContext.class,0);
}
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ClassInstanceCreationExpressionContext classInstanceCreationExpression() {
return getRuleContext(ClassInstanceCreationExpressionContext.class,0);
}
public FieldAccessContext fieldAccess() {
return getRuleContext(FieldAccessContext.class,0);
}
public ArrayAccessContext arrayAccess() {
return getRuleContext(ArrayAccessContext.class,0);
}
public MethodInvocationContext methodInvocation() {
return getRuleContext(MethodInvocationContext.class,0);
}
public MethodReferenceContext methodReference() {
return getRuleContext(MethodReferenceContext.class,0);
}
public PrimaryNoNewArrayContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primaryNoNewArray; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPrimaryNoNewArray(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPrimaryNoNewArray(this);
}
}
public final PrimaryNoNewArrayContext primaryNoNewArray() throws RecognitionException {
PrimaryNoNewArrayContext _localctx = new PrimaryNoNewArrayContext(_ctx, getState());
enterRule(_localctx, 376, RULE_primaryNoNewArray);
try {
setState(2016);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,206,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2000);
literal();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2001);
classLiteral();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2002);
match(THIS);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2003);
typeName();
setState(2004);
match(DOT);
setState(2005);
match(THIS);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(2007);
match(LPAREN);
setState(2008);
expression();
setState(2009);
match(RPAREN);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(2011);
classInstanceCreationExpression();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(2012);
fieldAccess();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(2013);
arrayAccess();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(2014);
methodInvocation();
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(2015);
methodReference();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PrimaryNoNewArray_lf_arrayAccessContext extends ParserRuleContext {
public PrimaryNoNewArray_lf_arrayAccessContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primaryNoNewArray_lf_arrayAccess; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPrimaryNoNewArray_lf_arrayAccess(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPrimaryNoNewArray_lf_arrayAccess(this);
}
}
public final PrimaryNoNewArray_lf_arrayAccessContext primaryNoNewArray_lf_arrayAccess() throws RecognitionException {
PrimaryNoNewArray_lf_arrayAccessContext _localctx = new PrimaryNoNewArray_lf_arrayAccessContext(_ctx, getState());
enterRule(_localctx, 378, RULE_primaryNoNewArray_lf_arrayAccess);
try {
enterOuterAlt(_localctx, 1);
{
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PrimaryNoNewArray_lfno_arrayAccessContext extends ParserRuleContext {
public LiteralContext literal() {
return getRuleContext(LiteralContext.class,0);
}
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ClassInstanceCreationExpressionContext classInstanceCreationExpression() {
return getRuleContext(ClassInstanceCreationExpressionContext.class,0);
}
public FieldAccessContext fieldAccess() {
return getRuleContext(FieldAccessContext.class,0);
}
public MethodInvocationContext methodInvocation() {
return getRuleContext(MethodInvocationContext.class,0);
}
public MethodReferenceContext methodReference() {
return getRuleContext(MethodReferenceContext.class,0);
}
public PrimaryNoNewArray_lfno_arrayAccessContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primaryNoNewArray_lfno_arrayAccess; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPrimaryNoNewArray_lfno_arrayAccess(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPrimaryNoNewArray_lfno_arrayAccess(this);
}
}
public final PrimaryNoNewArray_lfno_arrayAccessContext primaryNoNewArray_lfno_arrayAccess() throws RecognitionException {
PrimaryNoNewArray_lfno_arrayAccessContext _localctx = new PrimaryNoNewArray_lfno_arrayAccessContext(_ctx, getState());
enterRule(_localctx, 380, RULE_primaryNoNewArray_lfno_arrayAccess);
int _la;
try {
setState(2048);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,208,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2020);
literal();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2021);
typeName();
setState(2026);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACK) {
{
{
setState(2022);
match(LBRACK);
setState(2023);
match(RBRACK);
}
}
setState(2028);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2029);
match(DOT);
setState(2030);
match(CLASS);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2032);
match(VOID);
setState(2033);
match(DOT);
setState(2034);
match(CLASS);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2035);
match(THIS);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(2036);
typeName();
setState(2037);
match(DOT);
setState(2038);
match(THIS);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(2040);
match(LPAREN);
setState(2041);
expression();
setState(2042);
match(RPAREN);
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(2044);
classInstanceCreationExpression();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(2045);
fieldAccess();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(2046);
methodInvocation();
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(2047);
methodReference();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PrimaryNoNewArray_lf_primaryContext extends ParserRuleContext {
public ClassInstanceCreationExpression_lf_primaryContext classInstanceCreationExpression_lf_primary() {
return getRuleContext(ClassInstanceCreationExpression_lf_primaryContext.class,0);
}
public FieldAccess_lf_primaryContext fieldAccess_lf_primary() {
return getRuleContext(FieldAccess_lf_primaryContext.class,0);
}
public ArrayAccess_lf_primaryContext arrayAccess_lf_primary() {
return getRuleContext(ArrayAccess_lf_primaryContext.class,0);
}
public MethodInvocation_lf_primaryContext methodInvocation_lf_primary() {
return getRuleContext(MethodInvocation_lf_primaryContext.class,0);
}
public MethodReference_lf_primaryContext methodReference_lf_primary() {
return getRuleContext(MethodReference_lf_primaryContext.class,0);
}
public PrimaryNoNewArray_lf_primaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primaryNoNewArray_lf_primary; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPrimaryNoNewArray_lf_primary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPrimaryNoNewArray_lf_primary(this);
}
}
public final PrimaryNoNewArray_lf_primaryContext primaryNoNewArray_lf_primary() throws RecognitionException {
PrimaryNoNewArray_lf_primaryContext _localctx = new PrimaryNoNewArray_lf_primaryContext(_ctx, getState());
enterRule(_localctx, 382, RULE_primaryNoNewArray_lf_primary);
try {
setState(2055);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,209,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2050);
classInstanceCreationExpression_lf_primary();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2051);
fieldAccess_lf_primary();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2052);
arrayAccess_lf_primary();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2053);
methodInvocation_lf_primary();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(2054);
methodReference_lf_primary();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext extends ParserRuleContext {
public PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary(this);
}
}
public final PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary() throws RecognitionException {
PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext _localctx = new PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext(_ctx, getState());
enterRule(_localctx, 384, RULE_primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary);
try {
enterOuterAlt(_localctx, 1);
{
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext extends ParserRuleContext {
public ClassInstanceCreationExpression_lf_primaryContext classInstanceCreationExpression_lf_primary() {
return getRuleContext(ClassInstanceCreationExpression_lf_primaryContext.class,0);
}
public FieldAccess_lf_primaryContext fieldAccess_lf_primary() {
return getRuleContext(FieldAccess_lf_primaryContext.class,0);
}
public MethodInvocation_lf_primaryContext methodInvocation_lf_primary() {
return getRuleContext(MethodInvocation_lf_primaryContext.class,0);
}
public MethodReference_lf_primaryContext methodReference_lf_primary() {
return getRuleContext(MethodReference_lf_primaryContext.class,0);
}
public PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary(this);
}
}
public final PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary() throws RecognitionException {
PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext _localctx = new PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext(_ctx, getState());
enterRule(_localctx, 386, RULE_primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary);
try {
setState(2063);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,210,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2059);
classInstanceCreationExpression_lf_primary();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2060);
fieldAccess_lf_primary();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2061);
methodInvocation_lf_primary();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2062);
methodReference_lf_primary();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PrimaryNoNewArray_lfno_primaryContext extends ParserRuleContext {
public LiteralContext literal() {
return getRuleContext(LiteralContext.class,0);
}
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public UnannPrimitiveTypeContext unannPrimitiveType() {
return getRuleContext(UnannPrimitiveTypeContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ClassInstanceCreationExpression_lfno_primaryContext classInstanceCreationExpression_lfno_primary() {
return getRuleContext(ClassInstanceCreationExpression_lfno_primaryContext.class,0);
}
public FieldAccess_lfno_primaryContext fieldAccess_lfno_primary() {
return getRuleContext(FieldAccess_lfno_primaryContext.class,0);
}
public ArrayAccess_lfno_primaryContext arrayAccess_lfno_primary() {
return getRuleContext(ArrayAccess_lfno_primaryContext.class,0);
}
public MethodInvocation_lfno_primaryContext methodInvocation_lfno_primary() {
return getRuleContext(MethodInvocation_lfno_primaryContext.class,0);
}
public MethodReference_lfno_primaryContext methodReference_lfno_primary() {
return getRuleContext(MethodReference_lfno_primaryContext.class,0);
}
public PrimaryNoNewArray_lfno_primaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primaryNoNewArray_lfno_primary; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPrimaryNoNewArray_lfno_primary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPrimaryNoNewArray_lfno_primary(this);
}
}
public final PrimaryNoNewArray_lfno_primaryContext primaryNoNewArray_lfno_primary() throws RecognitionException {
PrimaryNoNewArray_lfno_primaryContext _localctx = new PrimaryNoNewArray_lfno_primaryContext(_ctx, getState());
enterRule(_localctx, 388, RULE_primaryNoNewArray_lfno_primary);
int _la;
try {
setState(2105);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,213,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2065);
literal();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2066);
typeName();
setState(2071);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACK) {
{
{
setState(2067);
match(LBRACK);
setState(2068);
match(RBRACK);
}
}
setState(2073);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2074);
match(DOT);
setState(2075);
match(CLASS);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2077);
unannPrimitiveType();
setState(2082);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACK) {
{
{
setState(2078);
match(LBRACK);
setState(2079);
match(RBRACK);
}
}
setState(2084);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2085);
match(DOT);
setState(2086);
match(CLASS);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2088);
match(VOID);
setState(2089);
match(DOT);
setState(2090);
match(CLASS);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(2091);
match(THIS);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(2092);
typeName();
setState(2093);
match(DOT);
setState(2094);
match(THIS);
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(2096);
match(LPAREN);
setState(2097);
expression();
setState(2098);
match(RPAREN);
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(2100);
classInstanceCreationExpression_lfno_primary();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(2101);
fieldAccess_lfno_primary();
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(2102);
arrayAccess_lfno_primary();
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(2103);
methodInvocation_lfno_primary();
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(2104);
methodReference_lfno_primary();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext extends ParserRuleContext {
public PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary(this);
}
}
public final PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary() throws RecognitionException {
PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext _localctx = new PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext(_ctx, getState());
enterRule(_localctx, 390, RULE_primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary);
try {
enterOuterAlt(_localctx, 1);
{
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext extends ParserRuleContext {
public LiteralContext literal() {
return getRuleContext(LiteralContext.class,0);
}
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public UnannPrimitiveTypeContext unannPrimitiveType() {
return getRuleContext(UnannPrimitiveTypeContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ClassInstanceCreationExpression_lfno_primaryContext classInstanceCreationExpression_lfno_primary() {
return getRuleContext(ClassInstanceCreationExpression_lfno_primaryContext.class,0);
}
public FieldAccess_lfno_primaryContext fieldAccess_lfno_primary() {
return getRuleContext(FieldAccess_lfno_primaryContext.class,0);
}
public MethodInvocation_lfno_primaryContext methodInvocation_lfno_primary() {
return getRuleContext(MethodInvocation_lfno_primaryContext.class,0);
}
public MethodReference_lfno_primaryContext methodReference_lfno_primary() {
return getRuleContext(MethodReference_lfno_primaryContext.class,0);
}
public PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary(this);
}
}
public final PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary() throws RecognitionException {
PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext _localctx = new PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext(_ctx, getState());
enterRule(_localctx, 392, RULE_primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary);
int _la;
try {
setState(2148);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,216,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2109);
literal();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2110);
typeName();
setState(2115);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACK) {
{
{
setState(2111);
match(LBRACK);
setState(2112);
match(RBRACK);
}
}
setState(2117);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2118);
match(DOT);
setState(2119);
match(CLASS);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2121);
unannPrimitiveType();
setState(2126);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACK) {
{
{
setState(2122);
match(LBRACK);
setState(2123);
match(RBRACK);
}
}
setState(2128);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2129);
match(DOT);
setState(2130);
match(CLASS);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2132);
match(VOID);
setState(2133);
match(DOT);
setState(2134);
match(CLASS);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(2135);
match(THIS);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(2136);
typeName();
setState(2137);
match(DOT);
setState(2138);
match(THIS);
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(2140);
match(LPAREN);
setState(2141);
expression();
setState(2142);
match(RPAREN);
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(2144);
classInstanceCreationExpression_lfno_primary();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(2145);
fieldAccess_lfno_primary();
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(2146);
methodInvocation_lfno_primary();
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(2147);
methodReference_lfno_primary();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassLiteralContext extends ParserRuleContext {
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public NumericTypeContext numericType() {
return getRuleContext(NumericTypeContext.class,0);
}
public ClassLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterClassLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitClassLiteral(this);
}
}
public final ClassLiteralContext classLiteral() throws RecognitionException {
ClassLiteralContext _localctx = new ClassLiteralContext(_ctx, getState());
enterRule(_localctx, 394, RULE_classLiteral);
int _la;
try {
setState(2167);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__0:
case T__1:
case T__2:
case T__3:
case T__4:
case T__5:
case T__6:
case T__7:
case T__8:
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case SHORT:
case Identifier:
enterOuterAlt(_localctx, 1);
{
setState(2153);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__0:
case T__1:
case T__2:
case T__3:
case T__4:
case T__5:
case T__6:
case T__7:
case T__8:
case Identifier:
{
setState(2150);
typeName();
}
break;
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case SHORT:
{
setState(2151);
numericType();
}
break;
case BOOLEAN:
{
setState(2152);
match(BOOLEAN);
}
break;
default:
throw new NoViableAltException(this);
}
setState(2159);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACK) {
{
{
setState(2155);
match(LBRACK);
setState(2156);
match(RBRACK);
}
}
setState(2161);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2162);
match(DOT);
setState(2163);
match(CLASS);
}
break;
case VOID:
enterOuterAlt(_localctx, 2);
{
setState(2164);
match(VOID);
setState(2165);
match(DOT);
setState(2166);
match(CLASS);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassInstanceCreationExpressionContext extends ParserRuleContext {
public List<IdentifierContext> identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public TypeArgumentsContext typeArguments() {
return getRuleContext(TypeArgumentsContext.class,0);
}
public List<AnnotationContext> annotation() {
return getRuleContexts(AnnotationContext.class);
}
public AnnotationContext annotation(int i) {
return getRuleContext(AnnotationContext.class,i);
}
public TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() {
return getRuleContext(TypeArgumentsOrDiamondContext.class,0);
}
public ArgumentListContext argumentList() {
return getRuleContext(ArgumentListContext.class,0);
}
public ClassBodyContext classBody() {
return getRuleContext(ClassBodyContext.class,0);
}
public ExpressionNameContext expressionName() {
return getRuleContext(ExpressionNameContext.class,0);
}
public PrimaryContext primary() {
return getRuleContext(PrimaryContext.class,0);
}
public ClassInstanceCreationExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classInstanceCreationExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterClassInstanceCreationExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitClassInstanceCreationExpression(this);
}
}
public final ClassInstanceCreationExpressionContext classInstanceCreationExpression() throws RecognitionException {
ClassInstanceCreationExpressionContext _localctx = new ClassInstanceCreationExpressionContext(_ctx, getState());
enterRule(_localctx, 396, RULE_classInstanceCreationExpression);
int _la;
try {
setState(2252);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,237,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2169);
match(NEW);
setState(2171);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(2170);
typeArguments();
}
}
setState(2176);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(2173);
annotation();
}
}
setState(2178);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2179);
identifier();
setState(2190);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DOT) {
{
{
setState(2180);
match(DOT);
setState(2184);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(2181);
annotation();
}
}
setState(2186);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2187);
identifier();
}
}
setState(2192);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2194);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(2193);
typeArgumentsOrDiamond();
}
}
setState(2196);
match(LPAREN);
setState(2198);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
setState(2197);
argumentList();
}
}
setState(2200);
match(RPAREN);
setState(2202);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LBRACE) {
{
setState(2201);
classBody();
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2204);
expressionName();
setState(2205);
match(DOT);
setState(2206);
match(NEW);
setState(2208);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(2207);
typeArguments();
}
}
setState(2213);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(2210);
annotation();
}
}
setState(2215);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2216);
identifier();
setState(2218);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(2217);
typeArgumentsOrDiamond();
}
}
setState(2220);
match(LPAREN);
setState(2222);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
setState(2221);
argumentList();
}
}
setState(2224);
match(RPAREN);
setState(2226);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LBRACE) {
{
setState(2225);
classBody();
}
}
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2228);
primary();
setState(2229);
match(DOT);
setState(2230);
match(NEW);
setState(2232);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(2231);
typeArguments();
}
}
setState(2237);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(2234);
annotation();
}
}
setState(2239);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2240);
identifier();
setState(2242);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(2241);
typeArgumentsOrDiamond();
}
}
setState(2244);
match(LPAREN);
setState(2246);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
setState(2245);
argumentList();
}
}
setState(2248);
match(RPAREN);
setState(2250);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LBRACE) {
{
setState(2249);
classBody();
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassInstanceCreationExpression_lf_primaryContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TypeArgumentsContext typeArguments() {
return getRuleContext(TypeArgumentsContext.class,0);
}
public List<AnnotationContext> annotation() {
return getRuleContexts(AnnotationContext.class);
}
public AnnotationContext annotation(int i) {
return getRuleContext(AnnotationContext.class,i);
}
public TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() {
return getRuleContext(TypeArgumentsOrDiamondContext.class,0);
}
public ArgumentListContext argumentList() {
return getRuleContext(ArgumentListContext.class,0);
}
public ClassBodyContext classBody() {
return getRuleContext(ClassBodyContext.class,0);
}
public ClassInstanceCreationExpression_lf_primaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classInstanceCreationExpression_lf_primary; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterClassInstanceCreationExpression_lf_primary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitClassInstanceCreationExpression_lf_primary(this);
}
}
public final ClassInstanceCreationExpression_lf_primaryContext classInstanceCreationExpression_lf_primary() throws RecognitionException {
ClassInstanceCreationExpression_lf_primaryContext _localctx = new ClassInstanceCreationExpression_lf_primaryContext(_ctx, getState());
enterRule(_localctx, 398, RULE_classInstanceCreationExpression_lf_primary);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2254);
match(DOT);
setState(2255);
match(NEW);
setState(2257);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(2256);
typeArguments();
}
}
setState(2262);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(2259);
annotation();
}
}
setState(2264);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2265);
identifier();
setState(2267);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(2266);
typeArgumentsOrDiamond();
}
}
setState(2269);
match(LPAREN);
setState(2271);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
setState(2270);
argumentList();
}
}
setState(2273);
match(RPAREN);
setState(2275);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,242,_ctx) ) {
case 1:
{
setState(2274);
classBody();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassInstanceCreationExpression_lfno_primaryContext extends ParserRuleContext {
public List<IdentifierContext> identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public TypeArgumentsContext typeArguments() {
return getRuleContext(TypeArgumentsContext.class,0);
}
public List<AnnotationContext> annotation() {
return getRuleContexts(AnnotationContext.class);
}
public AnnotationContext annotation(int i) {
return getRuleContext(AnnotationContext.class,i);
}
public TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() {
return getRuleContext(TypeArgumentsOrDiamondContext.class,0);
}
public ArgumentListContext argumentList() {
return getRuleContext(ArgumentListContext.class,0);
}
public ClassBodyContext classBody() {
return getRuleContext(ClassBodyContext.class,0);
}
public ExpressionNameContext expressionName() {
return getRuleContext(ExpressionNameContext.class,0);
}
public ClassInstanceCreationExpression_lfno_primaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classInstanceCreationExpression_lfno_primary; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterClassInstanceCreationExpression_lfno_primary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitClassInstanceCreationExpression_lfno_primary(this);
}
}
public final ClassInstanceCreationExpression_lfno_primaryContext classInstanceCreationExpression_lfno_primary() throws RecognitionException {
ClassInstanceCreationExpression_lfno_primaryContext _localctx = new ClassInstanceCreationExpression_lfno_primaryContext(_ctx, getState());
enterRule(_localctx, 400, RULE_classInstanceCreationExpression_lfno_primary);
int _la;
try {
setState(2336);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NEW:
enterOuterAlt(_localctx, 1);
{
setState(2277);
match(NEW);
setState(2279);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(2278);
typeArguments();
}
}
setState(2284);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(2281);
annotation();
}
}
setState(2286);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2287);
identifier();
setState(2298);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DOT) {
{
{
setState(2288);
match(DOT);
setState(2292);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(2289);
annotation();
}
}
setState(2294);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2295);
identifier();
}
}
setState(2300);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2302);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(2301);
typeArgumentsOrDiamond();
}
}
setState(2304);
match(LPAREN);
setState(2306);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
setState(2305);
argumentList();
}
}
setState(2308);
match(RPAREN);
setState(2310);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,249,_ctx) ) {
case 1:
{
setState(2309);
classBody();
}
break;
}
}
break;
case T__0:
case T__1:
case T__2:
case T__3:
case T__4:
case T__5:
case T__6:
case T__7:
case T__8:
case Identifier:
enterOuterAlt(_localctx, 2);
{
setState(2312);
expressionName();
setState(2313);
match(DOT);
setState(2314);
match(NEW);
setState(2316);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(2315);
typeArguments();
}
}
setState(2321);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(2318);
annotation();
}
}
setState(2323);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2324);
identifier();
setState(2326);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(2325);
typeArgumentsOrDiamond();
}
}
setState(2328);
match(LPAREN);
setState(2330);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
setState(2329);
argumentList();
}
}
setState(2332);
match(RPAREN);
setState(2334);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,254,_ctx) ) {
case 1:
{
setState(2333);
classBody();
}
break;
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeArgumentsOrDiamondContext extends ParserRuleContext {
public TypeArgumentsContext typeArguments() {
return getRuleContext(TypeArgumentsContext.class,0);
}
public TypeArgumentsOrDiamondContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeArgumentsOrDiamond; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterTypeArgumentsOrDiamond(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitTypeArgumentsOrDiamond(this);
}
}
public final TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() throws RecognitionException {
TypeArgumentsOrDiamondContext _localctx = new TypeArgumentsOrDiamondContext(_ctx, getState());
enterRule(_localctx, 402, RULE_typeArgumentsOrDiamond);
try {
setState(2341);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,256,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2338);
typeArguments();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2339);
match(LT);
setState(2340);
match(GT);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FieldAccessContext extends ParserRuleContext {
public PrimaryContext primary() {
return getRuleContext(PrimaryContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public FieldAccessContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fieldAccess; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterFieldAccess(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitFieldAccess(this);
}
}
public final FieldAccessContext fieldAccess() throws RecognitionException {
FieldAccessContext _localctx = new FieldAccessContext(_ctx, getState());
enterRule(_localctx, 404, RULE_fieldAccess);
try {
setState(2356);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,257,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2343);
primary();
setState(2344);
match(DOT);
setState(2345);
identifier();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2347);
match(SUPER);
setState(2348);
match(DOT);
setState(2349);
identifier();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2350);
typeName();
setState(2351);
match(DOT);
setState(2352);
match(SUPER);
setState(2353);
match(DOT);
setState(2354);
identifier();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FieldAccess_lf_primaryContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public FieldAccess_lf_primaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fieldAccess_lf_primary; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterFieldAccess_lf_primary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitFieldAccess_lf_primary(this);
}
}
public final FieldAccess_lf_primaryContext fieldAccess_lf_primary() throws RecognitionException {
FieldAccess_lf_primaryContext _localctx = new FieldAccess_lf_primaryContext(_ctx, getState());
enterRule(_localctx, 406, RULE_fieldAccess_lf_primary);
try {
enterOuterAlt(_localctx, 1);
{
setState(2358);
match(DOT);
setState(2359);
identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FieldAccess_lfno_primaryContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public FieldAccess_lfno_primaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fieldAccess_lfno_primary; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterFieldAccess_lfno_primary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitFieldAccess_lfno_primary(this);
}
}
public final FieldAccess_lfno_primaryContext fieldAccess_lfno_primary() throws RecognitionException {
FieldAccess_lfno_primaryContext _localctx = new FieldAccess_lfno_primaryContext(_ctx, getState());
enterRule(_localctx, 408, RULE_fieldAccess_lfno_primary);
try {
setState(2370);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SUPER:
enterOuterAlt(_localctx, 1);
{
setState(2361);
match(SUPER);
setState(2362);
match(DOT);
setState(2363);
identifier();
}
break;
case T__0:
case T__1:
case T__2:
case T__3:
case T__4:
case T__5:
case T__6:
case T__7:
case T__8:
case Identifier:
enterOuterAlt(_localctx, 2);
{
setState(2364);
typeName();
setState(2365);
match(DOT);
setState(2366);
match(SUPER);
setState(2367);
match(DOT);
setState(2368);
identifier();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArrayAccessContext extends ParserRuleContext {
public ExpressionNameContext expressionName() {
return getRuleContext(ExpressionNameContext.class,0);
}
public List<ExpressionContext> expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public PrimaryNoNewArray_lfno_arrayAccessContext primaryNoNewArray_lfno_arrayAccess() {
return getRuleContext(PrimaryNoNewArray_lfno_arrayAccessContext.class,0);
}
public List<PrimaryNoNewArray_lf_arrayAccessContext> primaryNoNewArray_lf_arrayAccess() {
return getRuleContexts(PrimaryNoNewArray_lf_arrayAccessContext.class);
}
public PrimaryNoNewArray_lf_arrayAccessContext primaryNoNewArray_lf_arrayAccess(int i) {
return getRuleContext(PrimaryNoNewArray_lf_arrayAccessContext.class,i);
}
public ArrayAccessContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arrayAccess; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterArrayAccess(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitArrayAccess(this);
}
}
public final ArrayAccessContext arrayAccess() throws RecognitionException {
ArrayAccessContext _localctx = new ArrayAccessContext(_ctx, getState());
enterRule(_localctx, 410, RULE_arrayAccess);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2382);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,259,_ctx) ) {
case 1:
{
setState(2372);
expressionName();
setState(2373);
match(LBRACK);
setState(2374);
expression();
setState(2375);
match(RBRACK);
}
break;
case 2:
{
setState(2377);
primaryNoNewArray_lfno_arrayAccess();
setState(2378);
match(LBRACK);
setState(2379);
expression();
setState(2380);
match(RBRACK);
}
break;
}
setState(2391);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACK) {
{
{
setState(2384);
primaryNoNewArray_lf_arrayAccess();
setState(2385);
match(LBRACK);
setState(2386);
expression();
setState(2387);
match(RBRACK);
}
}
setState(2393);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArrayAccess_lf_primaryContext extends ParserRuleContext {
public PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary() {
return getRuleContext(PrimaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primaryContext.class,0);
}
public List<ExpressionContext> expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List<PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext> primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary() {
return getRuleContexts(PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext.class);
}
public PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary(int i) {
return getRuleContext(PrimaryNoNewArray_lf_primary_lf_arrayAccess_lf_primaryContext.class,i);
}
public ArrayAccess_lf_primaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arrayAccess_lf_primary; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterArrayAccess_lf_primary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitArrayAccess_lf_primary(this);
}
}
public final ArrayAccess_lf_primaryContext arrayAccess_lf_primary() throws RecognitionException {
ArrayAccess_lf_primaryContext _localctx = new ArrayAccess_lf_primaryContext(_ctx, getState());
enterRule(_localctx, 412, RULE_arrayAccess_lf_primary);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(2394);
primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary();
setState(2395);
match(LBRACK);
setState(2396);
expression();
setState(2397);
match(RBRACK);
}
setState(2406);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,261,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(2399);
primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary();
setState(2400);
match(LBRACK);
setState(2401);
expression();
setState(2402);
match(RBRACK);
}
}
}
setState(2408);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,261,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArrayAccess_lfno_primaryContext extends ParserRuleContext {
public ExpressionNameContext expressionName() {
return getRuleContext(ExpressionNameContext.class,0);
}
public List<ExpressionContext> expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary() {
return getRuleContext(PrimaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primaryContext.class,0);
}
public List<PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext> primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary() {
return getRuleContexts(PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext.class);
}
public PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary(int i) {
return getRuleContext(PrimaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primaryContext.class,i);
}
public ArrayAccess_lfno_primaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arrayAccess_lfno_primary; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterArrayAccess_lfno_primary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitArrayAccess_lfno_primary(this);
}
}
public final ArrayAccess_lfno_primaryContext arrayAccess_lfno_primary() throws RecognitionException {
ArrayAccess_lfno_primaryContext _localctx = new ArrayAccess_lfno_primaryContext(_ctx, getState());
enterRule(_localctx, 414, RULE_arrayAccess_lfno_primary);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(2419);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,262,_ctx) ) {
case 1:
{
setState(2409);
expressionName();
setState(2410);
match(LBRACK);
setState(2411);
expression();
setState(2412);
match(RBRACK);
}
break;
case 2:
{
setState(2414);
primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary();
setState(2415);
match(LBRACK);
setState(2416);
expression();
setState(2417);
match(RBRACK);
}
break;
}
setState(2428);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,263,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(2421);
primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary();
setState(2422);
match(LBRACK);
setState(2423);
expression();
setState(2424);
match(RBRACK);
}
}
}
setState(2430);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,263,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MethodInvocationContext extends ParserRuleContext {
public MethodNameContext methodName() {
return getRuleContext(MethodNameContext.class,0);
}
public ArgumentListContext argumentList() {
return getRuleContext(ArgumentListContext.class,0);
}
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TypeArgumentsContext typeArguments() {
return getRuleContext(TypeArgumentsContext.class,0);
}
public ExpressionNameContext expressionName() {
return getRuleContext(ExpressionNameContext.class,0);
}
public PrimaryContext primary() {
return getRuleContext(PrimaryContext.class,0);
}
public MethodInvocationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_methodInvocation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterMethodInvocation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitMethodInvocation(this);
}
}
public final MethodInvocationContext methodInvocation() throws RecognitionException {
MethodInvocationContext _localctx = new MethodInvocationContext(_ctx, getState());
enterRule(_localctx, 416, RULE_methodInvocation);
int _la;
try {
setState(2500);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,275,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2431);
methodName();
setState(2432);
match(LPAREN);
setState(2434);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
setState(2433);
argumentList();
}
}
setState(2436);
match(RPAREN);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2438);
typeName();
setState(2439);
match(DOT);
setState(2441);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(2440);
typeArguments();
}
}
setState(2443);
identifier();
setState(2444);
match(LPAREN);
setState(2446);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
setState(2445);
argumentList();
}
}
setState(2448);
match(RPAREN);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2450);
expressionName();
setState(2451);
match(DOT);
setState(2453);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(2452);
typeArguments();
}
}
setState(2455);
identifier();
setState(2456);
match(LPAREN);
setState(2458);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
setState(2457);
argumentList();
}
}
setState(2460);
match(RPAREN);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2462);
primary();
setState(2463);
match(DOT);
setState(2465);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(2464);
typeArguments();
}
}
setState(2467);
identifier();
setState(2468);
match(LPAREN);
setState(2470);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
setState(2469);
argumentList();
}
}
setState(2472);
match(RPAREN);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(2474);
match(SUPER);
setState(2475);
match(DOT);
setState(2477);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(2476);
typeArguments();
}
}
setState(2479);
identifier();
setState(2480);
match(LPAREN);
setState(2482);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
setState(2481);
argumentList();
}
}
setState(2484);
match(RPAREN);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(2486);
typeName();
setState(2487);
match(DOT);
setState(2488);
match(SUPER);
setState(2489);
match(DOT);
setState(2491);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(2490);
typeArguments();
}
}
setState(2493);
identifier();
setState(2494);
match(LPAREN);
setState(2496);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
setState(2495);
argumentList();
}
}
setState(2498);
match(RPAREN);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MethodInvocation_lf_primaryContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TypeArgumentsContext typeArguments() {
return getRuleContext(TypeArgumentsContext.class,0);
}
public ArgumentListContext argumentList() {
return getRuleContext(ArgumentListContext.class,0);
}
public MethodInvocation_lf_primaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_methodInvocation_lf_primary; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterMethodInvocation_lf_primary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitMethodInvocation_lf_primary(this);
}
}
public final MethodInvocation_lf_primaryContext methodInvocation_lf_primary() throws RecognitionException {
MethodInvocation_lf_primaryContext _localctx = new MethodInvocation_lf_primaryContext(_ctx, getState());
enterRule(_localctx, 418, RULE_methodInvocation_lf_primary);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2502);
match(DOT);
setState(2504);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(2503);
typeArguments();
}
}
setState(2506);
identifier();
setState(2507);
match(LPAREN);
setState(2509);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
setState(2508);
argumentList();
}
}
setState(2511);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MethodInvocation_lfno_primaryContext extends ParserRuleContext {
public MethodNameContext methodName() {
return getRuleContext(MethodNameContext.class,0);
}
public ArgumentListContext argumentList() {
return getRuleContext(ArgumentListContext.class,0);
}
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TypeArgumentsContext typeArguments() {
return getRuleContext(TypeArgumentsContext.class,0);
}
public ExpressionNameContext expressionName() {
return getRuleContext(ExpressionNameContext.class,0);
}
public MethodInvocation_lfno_primaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_methodInvocation_lfno_primary; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterMethodInvocation_lfno_primary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitMethodInvocation_lfno_primary(this);
}
}
public final MethodInvocation_lfno_primaryContext methodInvocation_lfno_primary() throws RecognitionException {
MethodInvocation_lfno_primaryContext _localctx = new MethodInvocation_lfno_primaryContext(_ctx, getState());
enterRule(_localctx, 420, RULE_methodInvocation_lfno_primary);
int _la;
try {
setState(2570);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,287,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2513);
methodName();
setState(2514);
match(LPAREN);
setState(2516);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
setState(2515);
argumentList();
}
}
setState(2518);
match(RPAREN);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2520);
typeName();
setState(2521);
match(DOT);
setState(2523);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(2522);
typeArguments();
}
}
setState(2525);
identifier();
setState(2526);
match(LPAREN);
setState(2528);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
setState(2527);
argumentList();
}
}
setState(2530);
match(RPAREN);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2532);
expressionName();
setState(2533);
match(DOT);
setState(2535);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(2534);
typeArguments();
}
}
setState(2537);
identifier();
setState(2538);
match(LPAREN);
setState(2540);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
setState(2539);
argumentList();
}
}
setState(2542);
match(RPAREN);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2544);
match(SUPER);
setState(2545);
match(DOT);
setState(2547);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(2546);
typeArguments();
}
}
setState(2549);
identifier();
setState(2550);
match(LPAREN);
setState(2552);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
setState(2551);
argumentList();
}
}
setState(2554);
match(RPAREN);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(2556);
typeName();
setState(2557);
match(DOT);
setState(2558);
match(SUPER);
setState(2559);
match(DOT);
setState(2561);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(2560);
typeArguments();
}
}
setState(2563);
identifier();
setState(2564);
match(LPAREN);
setState(2566);
_errHandler.sync(this);
_la = _input.LA(1);
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)) {
{
setState(2565);
argumentList();
}
}
setState(2568);
match(RPAREN);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArgumentListContext extends ParserRuleContext {
public List<ExpressionContext> expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public ArgumentListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_argumentList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterArgumentList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitArgumentList(this);
}
}
public final ArgumentListContext argumentList() throws RecognitionException {
ArgumentListContext _localctx = new ArgumentListContext(_ctx, getState());
enterRule(_localctx, 422, RULE_argumentList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2572);
expression();
setState(2577);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2573);
match(COMMA);
setState(2574);
expression();
}
}
setState(2579);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MethodReferenceContext extends ParserRuleContext {
public ExpressionNameContext expressionName() {
return getRuleContext(ExpressionNameContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TypeArgumentsContext typeArguments() {
return getRuleContext(TypeArgumentsContext.class,0);
}
public ReferenceTypeContext referenceType() {
return getRuleContext(ReferenceTypeContext.class,0);
}
public PrimaryContext primary() {
return getRuleContext(PrimaryContext.class,0);
}
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public ClassTypeContext classType() {
return getRuleContext(ClassTypeContext.class,0);
}
public ArrayTypeContext arrayType() {
return getRuleContext(ArrayTypeContext.class,0);
}
public MethodReferenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_methodReference; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterMethodReference(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitMethodReference(this);
}
}
public final MethodReferenceContext methodReference() throws RecognitionException {
MethodReferenceContext _localctx = new MethodReferenceContext(_ctx, getState());
enterRule(_localctx, 424, RULE_methodReference);
int _la;
try {
setState(2627);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,295,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2580);
expressionName();
setState(2581);
match(COLONCOLON);
setState(2583);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(2582);
typeArguments();
}
}
setState(2585);
identifier();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2587);
referenceType();
setState(2588);
match(COLONCOLON);
setState(2590);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(2589);
typeArguments();
}
}
setState(2592);
identifier();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2594);
primary();
setState(2595);
match(COLONCOLON);
setState(2597);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(2596);
typeArguments();
}
}
setState(2599);
identifier();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2601);
match(SUPER);
setState(2602);
match(COLONCOLON);
setState(2604);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(2603);
typeArguments();
}
}
setState(2606);
identifier();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(2607);
typeName();
setState(2608);
match(DOT);
setState(2609);
match(SUPER);
setState(2610);
match(COLONCOLON);
setState(2612);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(2611);
typeArguments();
}
}
setState(2614);
identifier();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(2616);
classType();
setState(2617);
match(COLONCOLON);
setState(2619);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(2618);
typeArguments();
}
}
setState(2621);
match(NEW);
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(2623);
arrayType();
setState(2624);
match(COLONCOLON);
setState(2625);
match(NEW);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MethodReference_lf_primaryContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TypeArgumentsContext typeArguments() {
return getRuleContext(TypeArgumentsContext.class,0);
}
public MethodReference_lf_primaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_methodReference_lf_primary; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterMethodReference_lf_primary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitMethodReference_lf_primary(this);
}
}
public final MethodReference_lf_primaryContext methodReference_lf_primary() throws RecognitionException {
MethodReference_lf_primaryContext _localctx = new MethodReference_lf_primaryContext(_ctx, getState());
enterRule(_localctx, 426, RULE_methodReference_lf_primary);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2629);
match(COLONCOLON);
setState(2631);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(2630);
typeArguments();
}
}
setState(2633);
identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MethodReference_lfno_primaryContext extends ParserRuleContext {
public ExpressionNameContext expressionName() {
return getRuleContext(ExpressionNameContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TypeArgumentsContext typeArguments() {
return getRuleContext(TypeArgumentsContext.class,0);
}
public ReferenceTypeContext referenceType() {
return getRuleContext(ReferenceTypeContext.class,0);
}
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public ClassTypeContext classType() {
return getRuleContext(ClassTypeContext.class,0);
}
public ArrayTypeContext arrayType() {
return getRuleContext(ArrayTypeContext.class,0);
}
public MethodReference_lfno_primaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_methodReference_lfno_primary; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterMethodReference_lfno_primary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitMethodReference_lfno_primary(this);
}
}
public final MethodReference_lfno_primaryContext methodReference_lfno_primary() throws RecognitionException {
MethodReference_lfno_primaryContext _localctx = new MethodReference_lfno_primaryContext(_ctx, getState());
enterRule(_localctx, 428, RULE_methodReference_lfno_primary);
int _la;
try {
setState(2675);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,302,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2635);
expressionName();
setState(2636);
match(COLONCOLON);
setState(2638);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(2637);
typeArguments();
}
}
setState(2640);
identifier();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2642);
referenceType();
setState(2643);
match(COLONCOLON);
setState(2645);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(2644);
typeArguments();
}
}
setState(2647);
identifier();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2649);
match(SUPER);
setState(2650);
match(COLONCOLON);
setState(2652);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(2651);
typeArguments();
}
}
setState(2654);
identifier();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2655);
typeName();
setState(2656);
match(DOT);
setState(2657);
match(SUPER);
setState(2658);
match(COLONCOLON);
setState(2660);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(2659);
typeArguments();
}
}
setState(2662);
identifier();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(2664);
classType();
setState(2665);
match(COLONCOLON);
setState(2667);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(2666);
typeArguments();
}
}
setState(2669);
match(NEW);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(2671);
arrayType();
setState(2672);
match(COLONCOLON);
setState(2673);
match(NEW);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArrayCreationExpressionContext extends ParserRuleContext {
public PrimitiveTypeContext primitiveType() {
return getRuleContext(PrimitiveTypeContext.class,0);
}
public DimExprsContext dimExprs() {
return getRuleContext(DimExprsContext.class,0);
}
public DimsContext dims() {
return getRuleContext(DimsContext.class,0);
}
public ClassOrInterfaceTypeContext classOrInterfaceType() {
return getRuleContext(ClassOrInterfaceTypeContext.class,0);
}
public ArrayInitializerContext arrayInitializer() {
return getRuleContext(ArrayInitializerContext.class,0);
}
public ArrayCreationExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arrayCreationExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterArrayCreationExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitArrayCreationExpression(this);
}
}
public final ArrayCreationExpressionContext arrayCreationExpression() throws RecognitionException {
ArrayCreationExpressionContext _localctx = new ArrayCreationExpressionContext(_ctx, getState());
enterRule(_localctx, 430, RULE_arrayCreationExpression);
try {
setState(2699);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,305,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2677);
match(NEW);
setState(2678);
primitiveType();
setState(2679);
dimExprs();
setState(2681);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,303,_ctx) ) {
case 1:
{
setState(2680);
dims();
}
break;
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2683);
match(NEW);
setState(2684);
classOrInterfaceType();
setState(2685);
dimExprs();
setState(2687);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,304,_ctx) ) {
case 1:
{
setState(2686);
dims();
}
break;
}
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2689);
match(NEW);
setState(2690);
primitiveType();
setState(2691);
dims();
setState(2692);
arrayInitializer();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2694);
match(NEW);
setState(2695);
classOrInterfaceType();
setState(2696);
dims();
setState(2697);
arrayInitializer();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DimExprsContext extends ParserRuleContext {
public List<DimExprContext> dimExpr() {
return getRuleContexts(DimExprContext.class);
}
public DimExprContext dimExpr(int i) {
return getRuleContext(DimExprContext.class,i);
}
public DimExprsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dimExprs; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterDimExprs(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitDimExprs(this);
}
}
public final DimExprsContext dimExprs() throws RecognitionException {
DimExprsContext _localctx = new DimExprsContext(_ctx, getState());
enterRule(_localctx, 432, RULE_dimExprs);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(2702);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(2701);
dimExpr();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(2704);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,306,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DimExprContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public List<AnnotationContext> annotation() {
return getRuleContexts(AnnotationContext.class);
}
public AnnotationContext annotation(int i) {
return getRuleContext(AnnotationContext.class,i);
}
public DimExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dimExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterDimExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitDimExpr(this);
}
}
public final DimExprContext dimExpr() throws RecognitionException {
DimExprContext _localctx = new DimExprContext(_ctx, getState());
enterRule(_localctx, 434, RULE_dimExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2709);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(2706);
annotation();
}
}
setState(2711);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2712);
match(LBRACK);
setState(2713);
expression();
setState(2714);
match(RBRACK);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstantExpressionContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ConstantExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constantExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterConstantExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitConstantExpression(this);
}
}
public final ConstantExpressionContext constantExpression() throws RecognitionException {
ConstantExpressionContext _localctx = new ConstantExpressionContext(_ctx, getState());
enterRule(_localctx, 436, RULE_constantExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(2716);
expression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionContext extends ParserRuleContext {
public LambdaExpressionContext lambdaExpression() {
return getRuleContext(LambdaExpressionContext.class,0);
}
public AssignmentExpressionContext assignmentExpression() {
return getRuleContext(AssignmentExpressionContext.class,0);
}
public ExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitExpression(this);
}
}
public final ExpressionContext expression() throws RecognitionException {
ExpressionContext _localctx = new ExpressionContext(_ctx, getState());
enterRule(_localctx, 438, RULE_expression);
try {
setState(2720);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,308,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2718);
lambdaExpression();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2719);
assignmentExpression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LambdaExpressionContext extends ParserRuleContext {
public LambdaParametersContext lambdaParameters() {
return getRuleContext(LambdaParametersContext.class,0);
}
public LambdaBodyContext lambdaBody() {
return getRuleContext(LambdaBodyContext.class,0);
}
public LambdaExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lambdaExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterLambdaExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitLambdaExpression(this);
}
}
public final LambdaExpressionContext lambdaExpression() throws RecognitionException {
LambdaExpressionContext _localctx = new LambdaExpressionContext(_ctx, getState());
enterRule(_localctx, 440, RULE_lambdaExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(2722);
lambdaParameters();
setState(2723);
match(ARROW);
setState(2724);
lambdaBody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LambdaParametersContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public FormalParameterListContext formalParameterList() {
return getRuleContext(FormalParameterListContext.class,0);
}
public InferredFormalParameterListContext inferredFormalParameterList() {
return getRuleContext(InferredFormalParameterListContext.class,0);
}
public LambdaParametersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lambdaParameters; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterLambdaParameters(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitLambdaParameters(this);
}
}
public final LambdaParametersContext lambdaParameters() throws RecognitionException {
LambdaParametersContext _localctx = new LambdaParametersContext(_ctx, getState());
enterRule(_localctx, 442, RULE_lambdaParameters);
int _la;
try {
setState(2736);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,310,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2726);
identifier();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2727);
match(LPAREN);
setState(2729);
_errHandler.sync(this);
_la = _input.LA(1);
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) {
{
setState(2728);
formalParameterList();
}
}
setState(2731);
match(RPAREN);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2732);
match(LPAREN);
setState(2733);
inferredFormalParameterList();
setState(2734);
match(RPAREN);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InferredFormalParameterListContext extends ParserRuleContext {
public List<IdentifierContext> identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public InferredFormalParameterListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_inferredFormalParameterList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInferredFormalParameterList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInferredFormalParameterList(this);
}
}
public final InferredFormalParameterListContext inferredFormalParameterList() throws RecognitionException {
InferredFormalParameterListContext _localctx = new InferredFormalParameterListContext(_ctx, getState());
enterRule(_localctx, 444, RULE_inferredFormalParameterList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2738);
identifier();
setState(2743);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(2739);
match(COMMA);
setState(2740);
identifier();
}
}
setState(2745);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LambdaBodyContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public LambdaBodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lambdaBody; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterLambdaBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitLambdaBody(this);
}
}
public final LambdaBodyContext lambdaBody() throws RecognitionException {
LambdaBodyContext _localctx = new LambdaBodyContext(_ctx, getState());
enterRule(_localctx, 446, RULE_lambdaBody);
try {
setState(2748);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__0:
case T__1:
case T__2:
case T__3:
case T__4:
case T__5:
case T__6:
case T__7:
case T__8:
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case NEW:
case SHORT:
case SUPER:
case THIS:
case VOID:
case IntegerLiteral:
case FloatingPointLiteral:
case BooleanLiteral:
case CharacterLiteral:
case StringLiteral:
case NullLiteral:
case LPAREN:
case AT:
case BANG:
case TILDE:
case INC:
case DEC:
case ADD:
case SUB:
case Identifier:
enterOuterAlt(_localctx, 1);
{
setState(2746);
expression();
}
break;
case LBRACE:
enterOuterAlt(_localctx, 2);
{
setState(2747);
block();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AssignmentExpressionContext extends ParserRuleContext {
public ConditionalExpressionContext conditionalExpression() {
return getRuleContext(ConditionalExpressionContext.class,0);
}
public AssignmentContext assignment() {
return getRuleContext(AssignmentContext.class,0);
}
public AssignmentExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assignmentExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterAssignmentExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitAssignmentExpression(this);
}
}
public final AssignmentExpressionContext assignmentExpression() throws RecognitionException {
AssignmentExpressionContext _localctx = new AssignmentExpressionContext(_ctx, getState());
enterRule(_localctx, 448, RULE_assignmentExpression);
try {
setState(2752);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,313,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2750);
conditionalExpression();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2751);
assignment();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AssignmentContext extends ParserRuleContext {
public LeftHandSideContext leftHandSide() {
return getRuleContext(LeftHandSideContext.class,0);
}
public AssignmentOperatorContext assignmentOperator() {
return getRuleContext(AssignmentOperatorContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public AssignmentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assignment; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterAssignment(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitAssignment(this);
}
}
public final AssignmentContext assignment() throws RecognitionException {
AssignmentContext _localctx = new AssignmentContext(_ctx, getState());
enterRule(_localctx, 450, RULE_assignment);
try {
enterOuterAlt(_localctx, 1);
{
setState(2754);
leftHandSide();
setState(2755);
assignmentOperator();
setState(2756);
expression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LeftHandSideContext extends ParserRuleContext {
public ExpressionNameContext expressionName() {
return getRuleContext(ExpressionNameContext.class,0);
}
public FieldAccessContext fieldAccess() {
return getRuleContext(FieldAccessContext.class,0);
}
public ArrayAccessContext arrayAccess() {
return getRuleContext(ArrayAccessContext.class,0);
}
public LeftHandSideContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_leftHandSide; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterLeftHandSide(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitLeftHandSide(this);
}
}
public final LeftHandSideContext leftHandSide() throws RecognitionException {
LeftHandSideContext _localctx = new LeftHandSideContext(_ctx, getState());
enterRule(_localctx, 452, RULE_leftHandSide);
try {
setState(2761);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,314,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2758);
expressionName();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2759);
fieldAccess();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2760);
arrayAccess();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AssignmentOperatorContext extends ParserRuleContext {
public AssignmentOperatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assignmentOperator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterAssignmentOperator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitAssignmentOperator(this);
}
}
public final AssignmentOperatorContext assignmentOperator() throws RecognitionException {
AssignmentOperatorContext _localctx = new AssignmentOperatorContext(_ctx, getState());
enterRule(_localctx, 454, RULE_assignmentOperator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2763);
_la = _input.LA(1);
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)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConditionalExpressionContext extends ParserRuleContext {
public ConditionalOrExpressionContext conditionalOrExpression() {
return getRuleContext(ConditionalOrExpressionContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ConditionalExpressionContext conditionalExpression() {
return getRuleContext(ConditionalExpressionContext.class,0);
}
public LambdaExpressionContext lambdaExpression() {
return getRuleContext(LambdaExpressionContext.class,0);
}
public ConditionalExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_conditionalExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterConditionalExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitConditionalExpression(this);
}
}
public final ConditionalExpressionContext conditionalExpression() throws RecognitionException {
ConditionalExpressionContext _localctx = new ConditionalExpressionContext(_ctx, getState());
enterRule(_localctx, 456, RULE_conditionalExpression);
try {
setState(2774);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,316,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2765);
conditionalOrExpression(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2766);
conditionalOrExpression(0);
setState(2767);
match(QUESTION);
setState(2768);
expression();
setState(2769);
match(COLON);
setState(2772);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,315,_ctx) ) {
case 1:
{
setState(2770);
conditionalExpression();
}
break;
case 2:
{
setState(2771);
lambdaExpression();
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConditionalOrExpressionContext extends ParserRuleContext {
public ConditionalAndExpressionContext conditionalAndExpression() {
return getRuleContext(ConditionalAndExpressionContext.class,0);
}
public ConditionalOrExpressionContext conditionalOrExpression() {
return getRuleContext(ConditionalOrExpressionContext.class,0);
}
public ConditionalOrExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_conditionalOrExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterConditionalOrExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitConditionalOrExpression(this);
}
}
public final ConditionalOrExpressionContext conditionalOrExpression() throws RecognitionException {
return conditionalOrExpression(0);
}
private ConditionalOrExpressionContext conditionalOrExpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ConditionalOrExpressionContext _localctx = new ConditionalOrExpressionContext(_ctx, _parentState);
ConditionalOrExpressionContext _prevctx = _localctx;
int _startState = 458;
enterRecursionRule(_localctx, 458, RULE_conditionalOrExpression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(2777);
conditionalAndExpression(0);
}
_ctx.stop = _input.LT(-1);
setState(2784);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,317,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new ConditionalOrExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_conditionalOrExpression);
setState(2779);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(2780);
match(OR);
setState(2781);
conditionalAndExpression(0);
}
}
}
setState(2786);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,317,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class ConditionalAndExpressionContext extends ParserRuleContext {
public InclusiveOrExpressionContext inclusiveOrExpression() {
return getRuleContext(InclusiveOrExpressionContext.class,0);
}
public ConditionalAndExpressionContext conditionalAndExpression() {
return getRuleContext(ConditionalAndExpressionContext.class,0);
}
public ConditionalAndExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_conditionalAndExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterConditionalAndExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitConditionalAndExpression(this);
}
}
public final ConditionalAndExpressionContext conditionalAndExpression() throws RecognitionException {
return conditionalAndExpression(0);
}
private ConditionalAndExpressionContext conditionalAndExpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ConditionalAndExpressionContext _localctx = new ConditionalAndExpressionContext(_ctx, _parentState);
ConditionalAndExpressionContext _prevctx = _localctx;
int _startState = 460;
enterRecursionRule(_localctx, 460, RULE_conditionalAndExpression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(2788);
inclusiveOrExpression(0);
}
_ctx.stop = _input.LT(-1);
setState(2795);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,318,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new ConditionalAndExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_conditionalAndExpression);
setState(2790);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(2791);
match(AND);
setState(2792);
inclusiveOrExpression(0);
}
}
}
setState(2797);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,318,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class InclusiveOrExpressionContext extends ParserRuleContext {
public ExclusiveOrExpressionContext exclusiveOrExpression() {
return getRuleContext(ExclusiveOrExpressionContext.class,0);
}
public InclusiveOrExpressionContext inclusiveOrExpression() {
return getRuleContext(InclusiveOrExpressionContext.class,0);
}
public InclusiveOrExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_inclusiveOrExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterInclusiveOrExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitInclusiveOrExpression(this);
}
}
public final InclusiveOrExpressionContext inclusiveOrExpression() throws RecognitionException {
return inclusiveOrExpression(0);
}
private InclusiveOrExpressionContext inclusiveOrExpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
InclusiveOrExpressionContext _localctx = new InclusiveOrExpressionContext(_ctx, _parentState);
InclusiveOrExpressionContext _prevctx = _localctx;
int _startState = 462;
enterRecursionRule(_localctx, 462, RULE_inclusiveOrExpression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(2799);
exclusiveOrExpression(0);
}
_ctx.stop = _input.LT(-1);
setState(2806);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,319,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new InclusiveOrExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_inclusiveOrExpression);
setState(2801);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(2802);
match(BITOR);
setState(2803);
exclusiveOrExpression(0);
}
}
}
setState(2808);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,319,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class ExclusiveOrExpressionContext extends ParserRuleContext {
public AndExpressionContext andExpression() {
return getRuleContext(AndExpressionContext.class,0);
}
public ExclusiveOrExpressionContext exclusiveOrExpression() {
return getRuleContext(ExclusiveOrExpressionContext.class,0);
}
public ExclusiveOrExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_exclusiveOrExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterExclusiveOrExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitExclusiveOrExpression(this);
}
}
public final ExclusiveOrExpressionContext exclusiveOrExpression() throws RecognitionException {
return exclusiveOrExpression(0);
}
private ExclusiveOrExpressionContext exclusiveOrExpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ExclusiveOrExpressionContext _localctx = new ExclusiveOrExpressionContext(_ctx, _parentState);
ExclusiveOrExpressionContext _prevctx = _localctx;
int _startState = 464;
enterRecursionRule(_localctx, 464, RULE_exclusiveOrExpression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(2810);
andExpression(0);
}
_ctx.stop = _input.LT(-1);
setState(2817);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,320,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new ExclusiveOrExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_exclusiveOrExpression);
setState(2812);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(2813);
match(CARET);
setState(2814);
andExpression(0);
}
}
}
setState(2819);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,320,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class AndExpressionContext extends ParserRuleContext {
public EqualityExpressionContext equalityExpression() {
return getRuleContext(EqualityExpressionContext.class,0);
}
public AndExpressionContext andExpression() {
return getRuleContext(AndExpressionContext.class,0);
}
public AndExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_andExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterAndExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitAndExpression(this);
}
}
public final AndExpressionContext andExpression() throws RecognitionException {
return andExpression(0);
}
private AndExpressionContext andExpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
AndExpressionContext _localctx = new AndExpressionContext(_ctx, _parentState);
AndExpressionContext _prevctx = _localctx;
int _startState = 466;
enterRecursionRule(_localctx, 466, RULE_andExpression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(2821);
equalityExpression(0);
}
_ctx.stop = _input.LT(-1);
setState(2828);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,321,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new AndExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_andExpression);
setState(2823);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(2824);
match(BITAND);
setState(2825);
equalityExpression(0);
}
}
}
setState(2830);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,321,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class EqualityExpressionContext extends ParserRuleContext {
public RelationalExpressionContext relationalExpression() {
return getRuleContext(RelationalExpressionContext.class,0);
}
public EqualityExpressionContext equalityExpression() {
return getRuleContext(EqualityExpressionContext.class,0);
}
public EqualityExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_equalityExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterEqualityExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitEqualityExpression(this);
}
}
public final EqualityExpressionContext equalityExpression() throws RecognitionException {
return equalityExpression(0);
}
private EqualityExpressionContext equalityExpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
EqualityExpressionContext _localctx = new EqualityExpressionContext(_ctx, _parentState);
EqualityExpressionContext _prevctx = _localctx;
int _startState = 468;
enterRecursionRule(_localctx, 468, RULE_equalityExpression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(2832);
relationalExpression(0);
}
_ctx.stop = _input.LT(-1);
setState(2842);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,323,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(2840);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,322,_ctx) ) {
case 1:
{
_localctx = new EqualityExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_equalityExpression);
setState(2834);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(2835);
match(EQUAL);
setState(2836);
relationalExpression(0);
}
break;
case 2:
{
_localctx = new EqualityExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_equalityExpression);
setState(2837);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(2838);
match(NOTEQUAL);
setState(2839);
relationalExpression(0);
}
break;
}
}
}
setState(2844);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,323,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class RelationalExpressionContext extends ParserRuleContext {
public ShiftExpressionContext shiftExpression() {
return getRuleContext(ShiftExpressionContext.class,0);
}
public RelationalExpressionContext relationalExpression() {
return getRuleContext(RelationalExpressionContext.class,0);
}
public ReferenceTypeContext referenceType() {
return getRuleContext(ReferenceTypeContext.class,0);
}
public RelationalExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_relationalExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterRelationalExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitRelationalExpression(this);
}
}
public final RelationalExpressionContext relationalExpression() throws RecognitionException {
return relationalExpression(0);
}
private RelationalExpressionContext relationalExpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
RelationalExpressionContext _localctx = new RelationalExpressionContext(_ctx, _parentState);
RelationalExpressionContext _prevctx = _localctx;
int _startState = 470;
enterRecursionRule(_localctx, 470, RULE_relationalExpression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(2846);
shiftExpression(0);
}
_ctx.stop = _input.LT(-1);
setState(2865);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,325,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(2863);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,324,_ctx) ) {
case 1:
{
_localctx = new RelationalExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_relationalExpression);
setState(2848);
if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
setState(2849);
match(LT);
setState(2850);
shiftExpression(0);
}
break;
case 2:
{
_localctx = new RelationalExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_relationalExpression);
setState(2851);
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
setState(2852);
match(GT);
setState(2853);
shiftExpression(0);
}
break;
case 3:
{
_localctx = new RelationalExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_relationalExpression);
setState(2854);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(2855);
match(LE);
setState(2856);
shiftExpression(0);
}
break;
case 4:
{
_localctx = new RelationalExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_relationalExpression);
setState(2857);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(2858);
match(GE);
setState(2859);
shiftExpression(0);
}
break;
case 5:
{
_localctx = new RelationalExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_relationalExpression);
setState(2860);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(2861);
match(INSTANCEOF);
setState(2862);
referenceType();
}
break;
}
}
}
setState(2867);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,325,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class ShiftExpressionContext extends ParserRuleContext {
public AdditiveExpressionContext additiveExpression() {
return getRuleContext(AdditiveExpressionContext.class,0);
}
public ShiftExpressionContext shiftExpression() {
return getRuleContext(ShiftExpressionContext.class,0);
}
public ShiftExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_shiftExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterShiftExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitShiftExpression(this);
}
}
public final ShiftExpressionContext shiftExpression() throws RecognitionException {
return shiftExpression(0);
}
private ShiftExpressionContext shiftExpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ShiftExpressionContext _localctx = new ShiftExpressionContext(_ctx, _parentState);
ShiftExpressionContext _prevctx = _localctx;
int _startState = 472;
enterRecursionRule(_localctx, 472, RULE_shiftExpression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(2869);
additiveExpression(0);
}
_ctx.stop = _input.LT(-1);
setState(2886);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,327,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(2884);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,326,_ctx) ) {
case 1:
{
_localctx = new ShiftExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_shiftExpression);
setState(2871);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(2872);
match(LT);
setState(2873);
match(LT);
setState(2874);
additiveExpression(0);
}
break;
case 2:
{
_localctx = new ShiftExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_shiftExpression);
setState(2875);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(2876);
match(GT);
setState(2877);
match(GT);
setState(2878);
additiveExpression(0);
}
break;
case 3:
{
_localctx = new ShiftExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_shiftExpression);
setState(2879);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(2880);
match(GT);
setState(2881);
match(GT);
setState(2882);
match(GT);
setState(2883);
additiveExpression(0);
}
break;
}
}
}
setState(2888);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,327,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class AdditiveExpressionContext extends ParserRuleContext {
public MultiplicativeExpressionContext multiplicativeExpression() {
return getRuleContext(MultiplicativeExpressionContext.class,0);
}
public AdditiveExpressionContext additiveExpression() {
return getRuleContext(AdditiveExpressionContext.class,0);
}
public AdditiveExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_additiveExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterAdditiveExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitAdditiveExpression(this);
}
}
public final AdditiveExpressionContext additiveExpression() throws RecognitionException {
return additiveExpression(0);
}
private AdditiveExpressionContext additiveExpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
AdditiveExpressionContext _localctx = new AdditiveExpressionContext(_ctx, _parentState);
AdditiveExpressionContext _prevctx = _localctx;
int _startState = 474;
enterRecursionRule(_localctx, 474, RULE_additiveExpression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(2890);
multiplicativeExpression(0);
}
_ctx.stop = _input.LT(-1);
setState(2900);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,329,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(2898);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,328,_ctx) ) {
case 1:
{
_localctx = new AdditiveExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_additiveExpression);
setState(2892);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(2893);
match(ADD);
setState(2894);
multiplicativeExpression(0);
}
break;
case 2:
{
_localctx = new AdditiveExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_additiveExpression);
setState(2895);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(2896);
match(SUB);
setState(2897);
multiplicativeExpression(0);
}
break;
}
}
}
setState(2902);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,329,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class MultiplicativeExpressionContext extends ParserRuleContext {
public UnaryExpressionContext unaryExpression() {
return getRuleContext(UnaryExpressionContext.class,0);
}
public MultiplicativeExpressionContext multiplicativeExpression() {
return getRuleContext(MultiplicativeExpressionContext.class,0);
}
public MultiplicativeExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_multiplicativeExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterMultiplicativeExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitMultiplicativeExpression(this);
}
}
public final MultiplicativeExpressionContext multiplicativeExpression() throws RecognitionException {
return multiplicativeExpression(0);
}
private MultiplicativeExpressionContext multiplicativeExpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
MultiplicativeExpressionContext _localctx = new MultiplicativeExpressionContext(_ctx, _parentState);
MultiplicativeExpressionContext _prevctx = _localctx;
int _startState = 476;
enterRecursionRule(_localctx, 476, RULE_multiplicativeExpression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(2904);
unaryExpression();
}
_ctx.stop = _input.LT(-1);
setState(2917);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,331,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(2915);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,330,_ctx) ) {
case 1:
{
_localctx = new MultiplicativeExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_multiplicativeExpression);
setState(2906);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(2907);
match(MUL);
setState(2908);
unaryExpression();
}
break;
case 2:
{
_localctx = new MultiplicativeExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_multiplicativeExpression);
setState(2909);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(2910);
match(DIV);
setState(2911);
unaryExpression();
}
break;
case 3:
{
_localctx = new MultiplicativeExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_multiplicativeExpression);
setState(2912);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(2913);
match(MOD);
setState(2914);
unaryExpression();
}
break;
}
}
}
setState(2919);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,331,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class UnaryExpressionContext extends ParserRuleContext {
public PreIncrementExpressionContext preIncrementExpression() {
return getRuleContext(PreIncrementExpressionContext.class,0);
}
public PreDecrementExpressionContext preDecrementExpression() {
return getRuleContext(PreDecrementExpressionContext.class,0);
}
public UnaryExpressionContext unaryExpression() {
return getRuleContext(UnaryExpressionContext.class,0);
}
public UnaryExpressionNotPlusMinusContext unaryExpressionNotPlusMinus() {
return getRuleContext(UnaryExpressionNotPlusMinusContext.class,0);
}
public UnaryExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unaryExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnaryExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnaryExpression(this);
}
}
public final UnaryExpressionContext unaryExpression() throws RecognitionException {
UnaryExpressionContext _localctx = new UnaryExpressionContext(_ctx, getState());
enterRule(_localctx, 478, RULE_unaryExpression);
try {
setState(2927);
_errHandler.sync(this);
switch (_input.LA(1)) {
case INC:
enterOuterAlt(_localctx, 1);
{
setState(2920);
preIncrementExpression();
}
break;
case DEC:
enterOuterAlt(_localctx, 2);
{
setState(2921);
preDecrementExpression();
}
break;
case ADD:
enterOuterAlt(_localctx, 3);
{
setState(2922);
match(ADD);
setState(2923);
unaryExpression();
}
break;
case SUB:
enterOuterAlt(_localctx, 4);
{
setState(2924);
match(SUB);
setState(2925);
unaryExpression();
}
break;
case T__0:
case T__1:
case T__2:
case T__3:
case T__4:
case T__5:
case T__6:
case T__7:
case T__8:
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case NEW:
case SHORT:
case SUPER:
case THIS:
case VOID:
case IntegerLiteral:
case FloatingPointLiteral:
case BooleanLiteral:
case CharacterLiteral:
case StringLiteral:
case NullLiteral:
case LPAREN:
case AT:
case BANG:
case TILDE:
case Identifier:
enterOuterAlt(_localctx, 5);
{
setState(2926);
unaryExpressionNotPlusMinus();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PreIncrementExpressionContext extends ParserRuleContext {
public UnaryExpressionContext unaryExpression() {
return getRuleContext(UnaryExpressionContext.class,0);
}
public PreIncrementExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_preIncrementExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPreIncrementExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPreIncrementExpression(this);
}
}
public final PreIncrementExpressionContext preIncrementExpression() throws RecognitionException {
PreIncrementExpressionContext _localctx = new PreIncrementExpressionContext(_ctx, getState());
enterRule(_localctx, 480, RULE_preIncrementExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(2929);
match(INC);
setState(2930);
unaryExpression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PreDecrementExpressionContext extends ParserRuleContext {
public UnaryExpressionContext unaryExpression() {
return getRuleContext(UnaryExpressionContext.class,0);
}
public PreDecrementExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_preDecrementExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPreDecrementExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPreDecrementExpression(this);
}
}
public final PreDecrementExpressionContext preDecrementExpression() throws RecognitionException {
PreDecrementExpressionContext _localctx = new PreDecrementExpressionContext(_ctx, getState());
enterRule(_localctx, 482, RULE_preDecrementExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(2932);
match(DEC);
setState(2933);
unaryExpression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UnaryExpressionNotPlusMinusContext extends ParserRuleContext {
public PostfixExpressionContext postfixExpression() {
return getRuleContext(PostfixExpressionContext.class,0);
}
public UnaryExpressionContext unaryExpression() {
return getRuleContext(UnaryExpressionContext.class,0);
}
public CastExpressionContext castExpression() {
return getRuleContext(CastExpressionContext.class,0);
}
public UnaryExpressionNotPlusMinusContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unaryExpressionNotPlusMinus; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterUnaryExpressionNotPlusMinus(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitUnaryExpressionNotPlusMinus(this);
}
}
public final UnaryExpressionNotPlusMinusContext unaryExpressionNotPlusMinus() throws RecognitionException {
UnaryExpressionNotPlusMinusContext _localctx = new UnaryExpressionNotPlusMinusContext(_ctx, getState());
enterRule(_localctx, 484, RULE_unaryExpressionNotPlusMinus);
try {
setState(2941);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,333,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2935);
postfixExpression();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2936);
match(TILDE);
setState(2937);
unaryExpression();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2938);
match(BANG);
setState(2939);
unaryExpression();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2940);
castExpression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PostfixExpressionContext extends ParserRuleContext {
public PrimaryContext primary() {
return getRuleContext(PrimaryContext.class,0);
}
public ExpressionNameContext expressionName() {
return getRuleContext(ExpressionNameContext.class,0);
}
public List<PostIncrementExpression_lf_postfixExpressionContext> postIncrementExpression_lf_postfixExpression() {
return getRuleContexts(PostIncrementExpression_lf_postfixExpressionContext.class);
}
public PostIncrementExpression_lf_postfixExpressionContext postIncrementExpression_lf_postfixExpression(int i) {
return getRuleContext(PostIncrementExpression_lf_postfixExpressionContext.class,i);
}
public List<PostDecrementExpression_lf_postfixExpressionContext> postDecrementExpression_lf_postfixExpression() {
return getRuleContexts(PostDecrementExpression_lf_postfixExpressionContext.class);
}
public PostDecrementExpression_lf_postfixExpressionContext postDecrementExpression_lf_postfixExpression(int i) {
return getRuleContext(PostDecrementExpression_lf_postfixExpressionContext.class,i);
}
public PostfixExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_postfixExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPostfixExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPostfixExpression(this);
}
}
public final PostfixExpressionContext postfixExpression() throws RecognitionException {
PostfixExpressionContext _localctx = new PostfixExpressionContext(_ctx, getState());
enterRule(_localctx, 486, RULE_postfixExpression);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(2945);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,334,_ctx) ) {
case 1:
{
setState(2943);
primary();
}
break;
case 2:
{
setState(2944);
expressionName();
}
break;
}
setState(2951);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,336,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
setState(2949);
_errHandler.sync(this);
switch (_input.LA(1)) {
case INC:
{
setState(2947);
postIncrementExpression_lf_postfixExpression();
}
break;
case DEC:
{
setState(2948);
postDecrementExpression_lf_postfixExpression();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
setState(2953);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,336,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PostIncrementExpressionContext extends ParserRuleContext {
public PostfixExpressionContext postfixExpression() {
return getRuleContext(PostfixExpressionContext.class,0);
}
public PostIncrementExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_postIncrementExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPostIncrementExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPostIncrementExpression(this);
}
}
public final PostIncrementExpressionContext postIncrementExpression() throws RecognitionException {
PostIncrementExpressionContext _localctx = new PostIncrementExpressionContext(_ctx, getState());
enterRule(_localctx, 488, RULE_postIncrementExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(2954);
postfixExpression();
setState(2955);
match(INC);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PostIncrementExpression_lf_postfixExpressionContext extends ParserRuleContext {
public PostIncrementExpression_lf_postfixExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_postIncrementExpression_lf_postfixExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPostIncrementExpression_lf_postfixExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPostIncrementExpression_lf_postfixExpression(this);
}
}
public final PostIncrementExpression_lf_postfixExpressionContext postIncrementExpression_lf_postfixExpression() throws RecognitionException {
PostIncrementExpression_lf_postfixExpressionContext _localctx = new PostIncrementExpression_lf_postfixExpressionContext(_ctx, getState());
enterRule(_localctx, 490, RULE_postIncrementExpression_lf_postfixExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(2957);
match(INC);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PostDecrementExpressionContext extends ParserRuleContext {
public PostfixExpressionContext postfixExpression() {
return getRuleContext(PostfixExpressionContext.class,0);
}
public PostDecrementExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_postDecrementExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPostDecrementExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPostDecrementExpression(this);
}
}
public final PostDecrementExpressionContext postDecrementExpression() throws RecognitionException {
PostDecrementExpressionContext _localctx = new PostDecrementExpressionContext(_ctx, getState());
enterRule(_localctx, 492, RULE_postDecrementExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(2959);
postfixExpression();
setState(2960);
match(DEC);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PostDecrementExpression_lf_postfixExpressionContext extends ParserRuleContext {
public PostDecrementExpression_lf_postfixExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_postDecrementExpression_lf_postfixExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterPostDecrementExpression_lf_postfixExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitPostDecrementExpression_lf_postfixExpression(this);
}
}
public final PostDecrementExpression_lf_postfixExpressionContext postDecrementExpression_lf_postfixExpression() throws RecognitionException {
PostDecrementExpression_lf_postfixExpressionContext _localctx = new PostDecrementExpression_lf_postfixExpressionContext(_ctx, getState());
enterRule(_localctx, 494, RULE_postDecrementExpression_lf_postfixExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(2962);
match(DEC);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CastExpressionContext extends ParserRuleContext {
public PrimitiveTypeContext primitiveType() {
return getRuleContext(PrimitiveTypeContext.class,0);
}
public UnaryExpressionContext unaryExpression() {
return getRuleContext(UnaryExpressionContext.class,0);
}
public ReferenceTypeContext referenceType() {
return getRuleContext(ReferenceTypeContext.class,0);
}
public UnaryExpressionNotPlusMinusContext unaryExpressionNotPlusMinus() {
return getRuleContext(UnaryExpressionNotPlusMinusContext.class,0);
}
public List<AdditionalBoundContext> additionalBound() {
return getRuleContexts(AdditionalBoundContext.class);
}
public AdditionalBoundContext additionalBound(int i) {
return getRuleContext(AdditionalBoundContext.class,i);
}
public LambdaExpressionContext lambdaExpression() {
return getRuleContext(LambdaExpressionContext.class,0);
}
public CastExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_castExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterCastExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitCastExpression(this);
}
}
public final CastExpressionContext castExpression() throws RecognitionException {
CastExpressionContext _localctx = new CastExpressionContext(_ctx, getState());
enterRule(_localctx, 496, RULE_castExpression);
int _la;
try {
setState(2991);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,339,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2964);
match(LPAREN);
setState(2965);
primitiveType();
setState(2966);
match(RPAREN);
setState(2967);
unaryExpression();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2969);
match(LPAREN);
setState(2970);
referenceType();
setState(2974);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==BITAND) {
{
{
setState(2971);
additionalBound();
}
}
setState(2976);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2977);
match(RPAREN);
setState(2978);
unaryExpressionNotPlusMinus();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2980);
match(LPAREN);
setState(2981);
referenceType();
setState(2985);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==BITAND) {
{
{
setState(2982);
additionalBound();
}
}
setState(2987);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(2988);
match(RPAREN);
setState(2989);
lambdaExpression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IdentifierContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(Java9Parser.Identifier, 0); }
public IdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).enterIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof Java9Listener ) ((Java9Listener)listener).exitIdentifier(this);
}
}
public final IdentifierContext identifier() throws RecognitionException {
IdentifierContext _localctx = new IdentifierContext(_ctx, getState());
enterRule(_localctx, 498, RULE_identifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2993);
_la = _input.LA(1);
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) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
switch (ruleIndex) {
case 25:
return moduleName_sempred((ModuleNameContext)_localctx, predIndex);
case 26:
return packageName_sempred((PackageNameContext)_localctx, predIndex);
case 28:
return packageOrTypeName_sempred((PackageOrTypeNameContext)_localctx, predIndex);
case 31:
return ambiguousName_sempred((AmbiguousNameContext)_localctx, predIndex);
case 229:
return conditionalOrExpression_sempred((ConditionalOrExpressionContext)_localctx, predIndex);
case 230:
return conditionalAndExpression_sempred((ConditionalAndExpressionContext)_localctx, predIndex);
case 231:
return inclusiveOrExpression_sempred((InclusiveOrExpressionContext)_localctx, predIndex);
case 232:
return exclusiveOrExpression_sempred((ExclusiveOrExpressionContext)_localctx, predIndex);
case 233:
return andExpression_sempred((AndExpressionContext)_localctx, predIndex);
case 234:
return equalityExpression_sempred((EqualityExpressionContext)_localctx, predIndex);
case 235:
return relationalExpression_sempred((RelationalExpressionContext)_localctx, predIndex);
case 236:
return shiftExpression_sempred((ShiftExpressionContext)_localctx, predIndex);
case 237:
return additiveExpression_sempred((AdditiveExpressionContext)_localctx, predIndex);
case 238:
return multiplicativeExpression_sempred((MultiplicativeExpressionContext)_localctx, predIndex);
}
return true;
}
private boolean moduleName_sempred(ModuleNameContext _localctx, int predIndex) {
switch (predIndex) {
case 0:
return precpred(_ctx, 1);
}
return true;
}
private boolean packageName_sempred(PackageNameContext _localctx, int predIndex) {
switch (predIndex) {
case 1:
return precpred(_ctx, 1);
}
return true;
}
private boolean packageOrTypeName_sempred(PackageOrTypeNameContext _localctx, int predIndex) {
switch (predIndex) {
case 2:
return precpred(_ctx, 1);
}
return true;
}
private boolean ambiguousName_sempred(AmbiguousNameContext _localctx, int predIndex) {
switch (predIndex) {
case 3:
return precpred(_ctx, 1);
}
return true;
}
private boolean conditionalOrExpression_sempred(ConditionalOrExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 4:
return precpred(_ctx, 1);
}
return true;
}
private boolean conditionalAndExpression_sempred(ConditionalAndExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 5:
return precpred(_ctx, 1);
}
return true;
}
private boolean inclusiveOrExpression_sempred(InclusiveOrExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 6:
return precpred(_ctx, 1);
}
return true;
}
private boolean exclusiveOrExpression_sempred(ExclusiveOrExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 7:
return precpred(_ctx, 1);
}
return true;
}
private boolean andExpression_sempred(AndExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 8:
return precpred(_ctx, 1);
}
return true;
}
private boolean equalityExpression_sempred(EqualityExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 9:
return precpred(_ctx, 2);
case 10:
return precpred(_ctx, 1);
}
return true;
}
private boolean relationalExpression_sempred(RelationalExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 11:
return precpred(_ctx, 5);
case 12:
return precpred(_ctx, 4);
case 13:
return precpred(_ctx, 3);
case 14:
return precpred(_ctx, 2);
case 15:
return precpred(_ctx, 1);
}
return true;
}
private boolean shiftExpression_sempred(ShiftExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 16:
return precpred(_ctx, 3);
case 17:
return precpred(_ctx, 2);
case 18:
return precpred(_ctx, 1);
}
return true;
}
private boolean additiveExpression_sempred(AdditiveExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 19:
return precpred(_ctx, 2);
case 20:
return precpred(_ctx, 1);
}
return true;
}
private boolean multiplicativeExpression_sempred(MultiplicativeExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 21:
return precpred(_ctx, 3);
case 22:
return precpred(_ctx, 2);
case 23:
return precpred(_ctx, 1);
}
return true;
}
private static final int _serializedATNSegments = 2;
private static final String _serializedATNSegment0 =
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3x\u0bb6\4\2\t\2\4"+
"\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"+
"\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"+
"\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"+
"\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!"+
"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
",\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"+
"\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="+
"\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+
"\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+
"\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+
"`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t"+
"k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4"+
"w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080"+
"\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084\t\u0084\4\u0085"+
"\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087\4\u0088\t\u0088\4\u0089\t\u0089"+
"\4\u008a\t\u008a\4\u008b\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e"+
"\t\u008e\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092\t\u0092"+
"\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095\t\u0095\4\u0096\t\u0096\4\u0097"+
"\t\u0097\4\u0098\t\u0098\4\u0099\t\u0099\4\u009a\t\u009a\4\u009b\t\u009b"+
"\4\u009c\t\u009c\4\u009d\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f\4\u00a0"+
"\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3\t\u00a3\4\u00a4\t\u00a4"+
"\4\u00a5\t\u00a5\4\u00a6\t\u00a6\4\u00a7\t\u00a7\4\u00a8\t\u00a8\4\u00a9"+
"\t\u00a9\4\u00aa\t\u00aa\4\u00ab\t\u00ab\4\u00ac\t\u00ac\4\u00ad\t\u00ad"+
"\4\u00ae\t\u00ae\4\u00af\t\u00af\4\u00b0\t\u00b0\4\u00b1\t\u00b1\4\u00b2"+
"\t\u00b2\4\u00b3\t\u00b3\4\u00b4\t\u00b4\4\u00b5\t\u00b5\4\u00b6\t\u00b6"+
"\4\u00b7\t\u00b7\4\u00b8\t\u00b8\4\u00b9\t\u00b9\4\u00ba\t\u00ba\4\u00bb"+
"\t\u00bb\4\u00bc\t\u00bc\4\u00bd\t\u00bd\4\u00be\t\u00be\4\u00bf\t\u00bf"+
"\4\u00c0\t\u00c0\4\u00c1\t\u00c1\4\u00c2\t\u00c2\4\u00c3\t\u00c3\4\u00c4"+
"\t\u00c4\4\u00c5\t\u00c5\4\u00c6\t\u00c6\4\u00c7\t\u00c7\4\u00c8\t\u00c8"+
"\4\u00c9\t\u00c9\4\u00ca\t\u00ca\4\u00cb\t\u00cb\4\u00cc\t\u00cc\4\u00cd"+
"\t\u00cd\4\u00ce\t\u00ce\4\u00cf\t\u00cf\4\u00d0\t\u00d0\4\u00d1\t\u00d1"+
"\4\u00d2\t\u00d2\4\u00d3\t\u00d3\4\u00d4\t\u00d4\4\u00d5\t\u00d5\4\u00d6"+
"\t\u00d6\4\u00d7\t\u00d7\4\u00d8\t\u00d8\4\u00d9\t\u00d9\4\u00da\t\u00da"+
"\4\u00db\t\u00db\4\u00dc\t\u00dc\4\u00dd\t\u00dd\4\u00de\t\u00de\4\u00df"+
"\t\u00df\4\u00e0\t\u00e0\4\u00e1\t\u00e1\4\u00e2\t\u00e2\4\u00e3\t\u00e3"+
"\4\u00e4\t\u00e4\4\u00e5\t\u00e5\4\u00e6\t\u00e6\4\u00e7\t\u00e7\4\u00e8"+
"\t\u00e8\4\u00e9\t\u00e9\4\u00ea\t\u00ea\4\u00eb\t\u00eb\4\u00ec\t\u00ec"+
"\4\u00ed\t\u00ed\4\u00ee\t\u00ee\4\u00ef\t\u00ef\4\u00f0\t\u00f0\4\u00f1"+
"\t\u00f1\4\u00f2\t\u00f2\4\u00f3\t\u00f3\4\u00f4\t\u00f4\4\u00f5\t\u00f5"+
"\4\u00f6\t\u00f6\4\u00f7\t\u00f7\4\u00f8\t\u00f8\4\u00f9\t\u00f9\4\u00fa"+
"\t\u00fa\4\u00fb\t\u00fb\3\2\3\2\3\3\7\3\u01fa\n\3\f\3\16\3\u01fd\13\3"+
"\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"+
"\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"+
"\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"+
"\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"+
"\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"+
"\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"+
"\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"+
"\17\7\17\u0255\n\17\f\17\16\17\u0258\13\17\3\17\3\17\3\20\3\20\3\20\3"+
"\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"+
"\16\21\u026b\13\21\3\21\3\21\3\21\7\21\u0270\n\21\f\21\16\21\u0273\13"+
"\21\3\21\3\21\7\21\u0277\n\21\f\21\16\21\u027a\13\21\3\22\7\22\u027d\n"+
"\22\f\22\16\22\u0280\13\22\3\22\3\22\5\22\u0284\n\22\3\23\3\23\3\24\3"+
"\24\3\24\3\24\3\24\7\24\u028d\n\24\f\24\16\24\u0290\13\24\5\24\u0292\n"+
"\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"+
"\f\27\16\27\u02a1\13\27\3\30\3\30\5\30\u02a5\n\30\3\31\7\31\u02a8\n\31"+
"\f\31\16\31\u02ab\13\31\3\31\3\31\5\31\u02af\n\31\3\32\3\32\3\32\3\32"+
"\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"+
"\33\u02c0\13\33\3\34\3\34\3\34\3\34\3\34\3\34\7\34\u02c8\n\34\f\34\16"+
"\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"+
"\3\36\3\36\3\36\7\36\u02da\n\36\f\36\16\36\u02dd\13\36\3\37\3\37\3\37"+
"\3\37\3\37\5\37\u02e4\n\37\3 \3 \3!\3!\3!\3!\3!\3!\7!\u02ee\n!\f!\16!"+
"\u02f1\13!\3\"\3\"\5\"\u02f5\n\"\3#\5#\u02f8\n#\3#\7#\u02fb\n#\f#\16#"+
"\u02fe\13#\3#\7#\u0301\n#\f#\16#\u0304\13#\3#\3#\3$\7$\u0309\n$\f$\16"+
"$\u030c\13$\3$\3$\3%\7%\u0311\n%\f%\16%\u0314\13%\3%\3%\3%\3%\3&\3&\3"+
"\'\3\'\3\'\3\'\5\'\u0320\n\'\3(\3(\3(\3(\3)\3)\3)\3)\3)\3)\3*\3*\3*\3"+
"*\3*\3*\3*\3+\3+\3+\3+\3+\3+\3+\3,\3,\3,\5,\u033d\n,\3-\7-\u0340\n-\f"+
"-\16-\u0343\13-\3-\5-\u0346\n-\3-\3-\3-\3-\7-\u034c\n-\f-\16-\u034f\13"+
"-\3-\3-\3.\3.\3.\3.\3.\5.\u0358\n.\3/\3/\7/\u035c\n/\f/\16/\u035f\13/"+
"\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"+
"\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"+
"\n\61\f\61\16\61\u037c\13\61\5\61\u037e\n\61\3\61\3\61\3\62\3\62\3\62"+
"\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"+
"\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"+
"\f\66\16\66\u039d\13\66\3\66\3\66\3\66\5\66\u03a2\n\66\3\66\5\66\u03a5"+
"\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"+
"\3\67\5\67\u03b4\n\67\38\38\38\38\39\39\39\79\u03bd\n9\f9\169\u03c0\13"+
"9\3:\3:\3:\3;\3;\3;\3<\3<\3<\7<\u03cb\n<\f<\16<\u03ce\13<\3=\3=\7=\u03d2"+
"\n=\f=\16=\u03d5\13=\3=\3=\3>\3>\3>\3>\5>\u03dd\n>\3?\3?\3?\3?\3?\5?\u03e4"+
"\n?\3@\7@\u03e7\n@\f@\16@\u03ea\13@\3@\3@\3@\3@\3A\3A\3A\3A\3A\3A\3A\3"+
"A\5A\u03f8\nA\3B\3B\3B\7B\u03fd\nB\fB\16B\u0400\13B\3C\3C\3C\5C\u0405"+
"\nC\3D\3D\5D\u0409\nD\3E\3E\5E\u040d\nE\3F\3F\5F\u0411\nF\3G\3G\5G\u0415"+
"\nG\3H\3H\3H\5H\u041a\nH\3I\3I\5I\u041e\nI\3I\3I\7I\u0422\nI\fI\16I\u0425"+
"\13I\3J\3J\5J\u0429\nJ\3J\3J\3J\7J\u042e\nJ\fJ\16J\u0431\13J\3J\3J\5J"+
"\u0435\nJ\5J\u0437\nJ\3K\3K\7K\u043b\nK\fK\16K\u043e\13K\3K\3K\5K\u0442"+
"\nK\3L\3L\5L\u0446\nL\3M\3M\3N\3N\3O\3O\3P\3P\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q"+
"\3Q\5Q\u0459\nQ\3R\7R\u045c\nR\fR\16R\u045f\13R\3R\3R\3R\3S\3S\3S\3S\3"+
"S\3S\3S\3S\3S\3S\5S\u046e\nS\3T\3T\3T\5T\u0473\nT\3T\3T\7T\u0477\nT\f"+
"T\16T\u047a\13T\3T\3T\3T\5T\u047f\nT\5T\u0481\nT\3U\3U\5U\u0485\nU\3V"+
"\3V\3V\5V\u048a\nV\3V\3V\5V\u048e\nV\3W\3W\3W\3W\3W\3W\5W\u0496\nW\3X"+
"\3X\3X\7X\u049b\nX\fX\16X\u049e\13X\3X\3X\3X\7X\u04a3\nX\fX\16X\u04a6"+
"\13X\5X\u04a8\nX\3Y\7Y\u04ab\nY\fY\16Y\u04ae\13Y\3Y\3Y\3Y\3Z\3Z\5Z\u04b5"+
"\nZ\3[\7[\u04b8\n[\f[\16[\u04bb\13[\3[\3[\7[\u04bf\n[\f[\16[\u04c2\13"+
"[\3[\3[\3[\3[\5[\u04c8\n[\3\\\7\\\u04cb\n\\\f\\\16\\\u04ce\13\\\3\\\3"+
"\\\3\\\3\\\5\\\u04d4\n\\\3\\\3\\\3]\3]\3]\3^\3^\3^\7^\u04de\n^\f^\16^"+
"\u04e1\13^\3_\3_\5_\u04e5\n_\3`\3`\5`\u04e9\n`\3a\3a\3b\3b\3b\3c\7c\u04f1"+
"\nc\fc\16c\u04f4\13c\3c\3c\5c\u04f8\nc\3c\3c\3d\3d\3d\3d\5d\u0500\nd\3"+
"e\5e\u0503\ne\3e\3e\3e\5e\u0508\ne\3e\3e\3f\3f\3g\3g\5g\u0510\ng\3g\5"+
"g\u0513\ng\3g\3g\3h\5h\u0518\nh\3h\3h\3h\5h\u051d\nh\3h\3h\3h\5h\u0522"+
"\nh\3h\3h\3h\5h\u0527\nh\3h\3h\3h\3h\3h\5h\u052e\nh\3h\3h\3h\5h\u0533"+
"\nh\3h\3h\3h\3h\3h\3h\5h\u053b\nh\3h\3h\3h\5h\u0540\nh\3h\3h\3h\5h\u0545"+
"\nh\3i\7i\u0548\ni\fi\16i\u054b\13i\3i\3i\3i\5i\u0550\ni\3i\3i\3j\3j\5"+
"j\u0556\nj\3j\5j\u0559\nj\3j\5j\u055c\nj\3j\3j\3k\3k\3k\7k\u0563\nk\f"+
"k\16k\u0566\13k\3l\7l\u0569\nl\fl\16l\u056c\13l\3l\3l\3l\5l\u0571\nl\3"+
"l\5l\u0574\nl\3l\5l\u0577\nl\3m\3m\3n\3n\7n\u057d\nn\fn\16n\u0580\13n"+
"\3o\3o\5o\u0584\no\3p\7p\u0587\np\fp\16p\u058a\13p\3p\3p\3p\5p\u058f\n"+
"p\3p\5p\u0592\np\3p\3p\3q\3q\3q\3q\3q\3q\3q\5q\u059d\nq\3r\3r\3r\3s\3"+
"s\7s\u05a4\ns\fs\16s\u05a7\13s\3s\3s\3t\3t\3t\3t\3t\5t\u05b0\nt\3u\7u"+
"\u05b3\nu\fu\16u\u05b6\13u\3u\3u\3u\3u\3v\3v\3v\3v\5v\u05c0\nv\3w\7w\u05c3"+
"\nw\fw\16w\u05c6\13w\3w\3w\3w\3x\3x\3x\3x\3x\3x\3x\5x\u05d2\nx\3y\7y\u05d5"+
"\ny\fy\16y\u05d8\13y\3y\3y\3y\3y\3y\3z\3z\7z\u05e1\nz\fz\16z\u05e4\13"+
"z\3z\3z\3{\3{\3{\3{\3{\5{\u05ed\n{\3|\7|\u05f0\n|\f|\16|\u05f3\13|\3|"+
"\3|\3|\3|\3|\5|\u05fa\n|\3|\5|\u05fd\n|\3|\3|\3}\3}\3}\5}\u0604\n}\3~"+
"\3~\3~\3\177\3\177\3\177\5\177\u060c\n\177\3\u0080\3\u0080\3\u0080\3\u0080"+
"\5\u0080\u0612\n\u0080\3\u0080\3\u0080\3\u0081\3\u0081\3\u0081\7\u0081"+
"\u0619\n\u0081\f\u0081\16\u0081\u061c\13\u0081\3\u0082\3\u0082\3\u0082"+
"\3\u0082\3\u0083\3\u0083\3\u0083\5\u0083\u0625\n\u0083\3\u0084\3\u0084"+
"\5\u0084\u0629\n\u0084\3\u0084\5\u0084\u062c\n\u0084\3\u0084\3\u0084\3"+
"\u0085\3\u0085\3\u0085\7\u0085\u0633\n\u0085\f\u0085\16\u0085\u0636\13"+
"\u0085\3\u0086\3\u0086\3\u0086\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087"+
"\3\u0087\3\u0088\3\u0088\5\u0088\u0643\n\u0088\3\u0088\5\u0088\u0646\n"+
"\u0088\3\u0088\3\u0088\3\u0089\3\u0089\3\u0089\7\u0089\u064d\n\u0089\f"+
"\u0089\16\u0089\u0650\13\u0089\3\u008a\3\u008a\5\u008a\u0654\n\u008a\3"+
"\u008a\3\u008a\3\u008b\6\u008b\u0659\n\u008b\r\u008b\16\u008b\u065a\3"+
"\u008c\3\u008c\3\u008c\5\u008c\u0660\n\u008c\3\u008d\3\u008d\3\u008d\3"+
"\u008e\7\u008e\u0666\n\u008e\f\u008e\16\u008e\u0669\13\u008e\3\u008e\3"+
"\u008e\3\u008e\3\u008f\3\u008f\3\u008f\3\u008f\3\u008f\3\u008f\5\u008f"+
"\u0674\n\u008f\3\u0090\3\u0090\3\u0090\3\u0090\3\u0090\5\u0090\u067b\n"+
"\u0090\3\u0091\3\u0091\3\u0091\3\u0091\3\u0091\3\u0091\3\u0091\3\u0091"+
"\3\u0091\3\u0091\3\u0091\3\u0091\5\u0091\u0689\n\u0091\3\u0092\3\u0092"+
"\3\u0093\3\u0093\3\u0093\3\u0093\3\u0094\3\u0094\3\u0094\3\u0094\3\u0095"+
"\3\u0095\3\u0095\3\u0096\3\u0096\3\u0096\3\u0096\3\u0096\3\u0096\3\u0096"+
"\5\u0096\u069f\n\u0096\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097"+
"\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098\3\u0098\3\u0099"+
"\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u009a\3\u009a"+
"\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\5\u009a"+
"\u06c1\n\u009a\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009b\3\u009c"+
"\3\u009c\7\u009c\u06cb\n\u009c\f\u009c\16\u009c\u06ce\13\u009c\3\u009c"+
"\7\u009c\u06d1\n\u009c\f\u009c\16\u009c\u06d4\13\u009c\3\u009c\3\u009c"+
"\3\u009d\3\u009d\3\u009d\3\u009e\6\u009e\u06dc\n\u009e\r\u009e\16\u009e"+
"\u06dd\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f"+
"\3\u009f\3\u009f\5\u009f\u06ea\n\u009f\3\u00a0\3\u00a0\3\u00a1\3\u00a1"+
"\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a2\3\u00a2\3\u00a2\3\u00a2\3\u00a2"+
"\3\u00a2\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3"+
"\3\u00a4\3\u00a4\5\u00a4\u0704\n\u00a4\3\u00a5\3\u00a5\5\u00a5\u0708\n"+
"\u00a5\3\u00a6\3\u00a6\3\u00a6\5\u00a6\u070d\n\u00a6\3\u00a6\3\u00a6\5"+
"\u00a6\u0711\n\u00a6\3\u00a6\3\u00a6\5\u00a6\u0715\n\u00a6\3\u00a6\3\u00a6"+
"\3\u00a6\3\u00a7\3\u00a7\3\u00a7\5\u00a7\u071d\n\u00a7\3\u00a7\3\u00a7"+
"\5\u00a7\u0721\n\u00a7\3\u00a7\3\u00a7\5\u00a7\u0725\n\u00a7\3\u00a7\3"+
"\u00a7\3\u00a7\3\u00a8\3\u00a8\5\u00a8\u072c\n\u00a8\3\u00a9\3\u00a9\3"+
"\u00aa\3\u00aa\3\u00aa\7\u00aa\u0733\n\u00aa\f\u00aa\16\u00aa\u0736\13"+
"\u00aa\3\u00ab\3\u00ab\3\u00ab\7\u00ab\u073b\n\u00ab\f\u00ab\16\u00ab"+
"\u073e\13\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab"+
"\3\u00ac\3\u00ac\3\u00ac\7\u00ac\u074a\n\u00ac\f\u00ac\16\u00ac\u074d"+
"\13\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ad"+
"\3\u00ad\5\u00ad\u0758\n\u00ad\3\u00ad\3\u00ad\3\u00ae\3\u00ae\5\u00ae"+
"\u075e\n\u00ae\3\u00ae\3\u00ae\3\u00af\3\u00af\5\u00af\u0764\n\u00af\3"+
"\u00af\3\u00af\3\u00b0\3\u00b0\3\u00b0\3\u00b0\3\u00b1\3\u00b1\3\u00b1"+
"\3\u00b1\3\u00b1\3\u00b1\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2"+
"\3\u00b2\5\u00b2\u0779\n\u00b2\3\u00b2\3\u00b2\3\u00b2\5\u00b2\u077e\n"+
"\u00b2\3\u00b3\6\u00b3\u0781\n\u00b3\r\u00b3\16\u00b3\u0782\3\u00b4\3"+
"\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b5\7\u00b5\u078c\n\u00b5\f"+
"\u00b5\16\u00b5\u078f\13\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b6\3\u00b6"+
"\3\u00b6\7\u00b6\u0797\n\u00b6\f\u00b6\16\u00b6\u079a\13\u00b6\3\u00b7"+
"\3\u00b7\3\u00b7\3\u00b8\3\u00b8\3\u00b8\3\u00b8\5\u00b8\u07a3\n\u00b8"+
"\3\u00b8\5\u00b8\u07a6\n\u00b8\3\u00b9\3\u00b9\3\u00b9\5\u00b9\u07ab\n"+
"\u00b9\3\u00b9\3\u00b9\3\u00ba\3\u00ba\3\u00ba\7\u00ba\u07b2\n\u00ba\f"+
"\u00ba\16\u00ba\u07b5\13\u00ba\3\u00bb\7\u00bb\u07b8\n\u00bb\f\u00bb\16"+
"\u00bb\u07bb\13\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb"+
"\5\u00bb\u07c3\n\u00bb\3\u00bc\3\u00bc\5\u00bc\u07c7\n\u00bc\3\u00bd\3"+
"\u00bd\5\u00bd\u07cb\n\u00bd\3\u00bd\7\u00bd\u07ce\n\u00bd\f\u00bd\16"+
"\u00bd\u07d1\13\u00bd\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be"+
"\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be\3\u00be"+
"\3\u00be\5\u00be\u07e3\n\u00be\3\u00bf\3\u00bf\3\u00c0\3\u00c0\3\u00c0"+
"\3\u00c0\7\u00c0\u07eb\n\u00c0\f\u00c0\16\u00c0\u07ee\13\u00c0\3\u00c0"+
"\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0"+
"\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0"+
"\5\u00c0\u0803\n\u00c0\3\u00c1\3\u00c1\3\u00c1\3\u00c1\3\u00c1\5\u00c1"+
"\u080a\n\u00c1\3\u00c2\3\u00c2\3\u00c3\3\u00c3\3\u00c3\3\u00c3\5\u00c3"+
"\u0812\n\u00c3\3\u00c4\3\u00c4\3\u00c4\3\u00c4\7\u00c4\u0818\n\u00c4\f"+
"\u00c4\16\u00c4\u081b\13\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4"+
"\3\u00c4\7\u00c4\u0823\n\u00c4\f\u00c4\16\u00c4\u0826\13\u00c4\3\u00c4"+
"\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4"+
"\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4"+
"\3\u00c4\5\u00c4\u083c\n\u00c4\3\u00c5\3\u00c5\3\u00c6\3\u00c6\3\u00c6"+
"\3\u00c6\7\u00c6\u0844\n\u00c6\f\u00c6\16\u00c6\u0847\13\u00c6\3\u00c6"+
"\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6\7\u00c6\u084f\n\u00c6\f\u00c6"+
"\16\u00c6\u0852\13\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6"+
"\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c6"+
"\3\u00c6\3\u00c6\3\u00c6\3\u00c6\5\u00c6\u0867\n\u00c6\3\u00c7\3\u00c7"+
"\3\u00c7\5\u00c7\u086c\n\u00c7\3\u00c7\3\u00c7\7\u00c7\u0870\n\u00c7\f"+
"\u00c7\16\u00c7\u0873\13\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7\3\u00c7"+
"\5\u00c7\u087a\n\u00c7\3\u00c8\3\u00c8\5\u00c8\u087e\n\u00c8\3\u00c8\7"+
"\u00c8\u0881\n\u00c8\f\u00c8\16\u00c8\u0884\13\u00c8\3\u00c8\3\u00c8\3"+
"\u00c8\7\u00c8\u0889\n\u00c8\f\u00c8\16\u00c8\u088c\13\u00c8\3\u00c8\7"+
"\u00c8\u088f\n\u00c8\f\u00c8\16\u00c8\u0892\13\u00c8\3\u00c8\5\u00c8\u0895"+
"\n\u00c8\3\u00c8\3\u00c8\5\u00c8\u0899\n\u00c8\3\u00c8\3\u00c8\5\u00c8"+
"\u089d\n\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8\5\u00c8\u08a3\n\u00c8\3"+
"\u00c8\7\u00c8\u08a6\n\u00c8\f\u00c8\16\u00c8\u08a9\13\u00c8\3\u00c8\3"+
"\u00c8\5\u00c8\u08ad\n\u00c8\3\u00c8\3\u00c8\5\u00c8\u08b1\n\u00c8\3\u00c8"+
"\3\u00c8\5\u00c8\u08b5\n\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c8\5\u00c8"+
"\u08bb\n\u00c8\3\u00c8\7\u00c8\u08be\n\u00c8\f\u00c8\16\u00c8\u08c1\13"+
"\u00c8\3\u00c8\3\u00c8\5\u00c8\u08c5\n\u00c8\3\u00c8\3\u00c8\5\u00c8\u08c9"+
"\n\u00c8\3\u00c8\3\u00c8\5\u00c8\u08cd\n\u00c8\5\u00c8\u08cf\n\u00c8\3"+
"\u00c9\3\u00c9\3\u00c9\5\u00c9\u08d4\n\u00c9\3\u00c9\7\u00c9\u08d7\n\u00c9"+
"\f\u00c9\16\u00c9\u08da\13\u00c9\3\u00c9\3\u00c9\5\u00c9\u08de\n\u00c9"+
"\3\u00c9\3\u00c9\5\u00c9\u08e2\n\u00c9\3\u00c9\3\u00c9\5\u00c9\u08e6\n"+
"\u00c9\3\u00ca\3\u00ca\5\u00ca\u08ea\n\u00ca\3\u00ca\7\u00ca\u08ed\n\u00ca"+
"\f\u00ca\16\u00ca\u08f0\13\u00ca\3\u00ca\3\u00ca\3\u00ca\7\u00ca\u08f5"+
"\n\u00ca\f\u00ca\16\u00ca\u08f8\13\u00ca\3\u00ca\7\u00ca\u08fb\n\u00ca"+
"\f\u00ca\16\u00ca\u08fe\13\u00ca\3\u00ca\5\u00ca\u0901\n\u00ca\3\u00ca"+
"\3\u00ca\5\u00ca\u0905\n\u00ca\3\u00ca\3\u00ca\5\u00ca\u0909\n\u00ca\3"+
"\u00ca\3\u00ca\3\u00ca\3\u00ca\5\u00ca\u090f\n\u00ca\3\u00ca\7\u00ca\u0912"+
"\n\u00ca\f\u00ca\16\u00ca\u0915\13\u00ca\3\u00ca\3\u00ca\5\u00ca\u0919"+
"\n\u00ca\3\u00ca\3\u00ca\5\u00ca\u091d\n\u00ca\3\u00ca\3\u00ca\5\u00ca"+
"\u0921\n\u00ca\5\u00ca\u0923\n\u00ca\3\u00cb\3\u00cb\3\u00cb\5\u00cb\u0928"+
"\n\u00cb\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc"+
"\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cc\5\u00cc\u0937\n\u00cc\3\u00cd"+
"\3\u00cd\3\u00cd\3\u00ce\3\u00ce\3\u00ce\3\u00ce\3\u00ce\3\u00ce\3\u00ce"+
"\3\u00ce\3\u00ce\5\u00ce\u0945\n\u00ce\3\u00cf\3\u00cf\3\u00cf\3\u00cf"+
"\3\u00cf\3\u00cf\3\u00cf\3\u00cf\3\u00cf\3\u00cf\5\u00cf\u0951\n\u00cf"+
"\3\u00cf\3\u00cf\3\u00cf\3\u00cf\3\u00cf\7\u00cf\u0958\n\u00cf\f\u00cf"+
"\16\u00cf\u095b\13\u00cf\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d0"+
"\3\u00d0\3\u00d0\3\u00d0\3\u00d0\7\u00d0\u0967\n\u00d0\f\u00d0\16\u00d0"+
"\u096a\13\u00d0\3\u00d1\3\u00d1\3\u00d1\3\u00d1\3\u00d1\3\u00d1\3\u00d1"+
"\3\u00d1\3\u00d1\3\u00d1\5\u00d1\u0976\n\u00d1\3\u00d1\3\u00d1\3\u00d1"+
"\3\u00d1\3\u00d1\7\u00d1\u097d\n\u00d1\f\u00d1\16\u00d1\u0980\13\u00d1"+
"\3\u00d2\3\u00d2\3\u00d2\5\u00d2\u0985\n\u00d2\3\u00d2\3\u00d2\3\u00d2"+
"\3\u00d2\3\u00d2\5\u00d2\u098c\n\u00d2\3\u00d2\3\u00d2\3\u00d2\5\u00d2"+
"\u0991\n\u00d2\3\u00d2\3\u00d2\3\u00d2\3\u00d2\3\u00d2\5\u00d2\u0998\n"+
"\u00d2\3\u00d2\3\u00d2\3\u00d2\5\u00d2\u099d\n\u00d2\3\u00d2\3\u00d2\3"+
"\u00d2\3\u00d2\3\u00d2\5\u00d2\u09a4\n\u00d2\3\u00d2\3\u00d2\3\u00d2\5"+
"\u00d2\u09a9\n\u00d2\3\u00d2\3\u00d2\3\u00d2\3\u00d2\3\u00d2\5\u00d2\u09b0"+
"\n\u00d2\3\u00d2\3\u00d2\3\u00d2\5\u00d2\u09b5\n\u00d2\3\u00d2\3\u00d2"+
"\3\u00d2\3\u00d2\3\u00d2\3\u00d2\3\u00d2\5\u00d2\u09be\n\u00d2\3\u00d2"+
"\3\u00d2\3\u00d2\5\u00d2\u09c3\n\u00d2\3\u00d2\3\u00d2\5\u00d2\u09c7\n"+
"\u00d2\3\u00d3\3\u00d3\5\u00d3\u09cb\n\u00d3\3\u00d3\3\u00d3\3\u00d3\5"+
"\u00d3\u09d0\n\u00d3\3\u00d3\3\u00d3\3\u00d4\3\u00d4\3\u00d4\5\u00d4\u09d7"+
"\n\u00d4\3\u00d4\3\u00d4\3\u00d4\3\u00d4\3\u00d4\5\u00d4\u09de\n\u00d4"+
"\3\u00d4\3\u00d4\3\u00d4\5\u00d4\u09e3\n\u00d4\3\u00d4\3\u00d4\3\u00d4"+
"\3\u00d4\3\u00d4\5\u00d4\u09ea\n\u00d4\3\u00d4\3\u00d4\3\u00d4\5\u00d4"+
"\u09ef\n\u00d4\3\u00d4\3\u00d4\3\u00d4\3\u00d4\3\u00d4\5\u00d4\u09f6\n"+
"\u00d4\3\u00d4\3\u00d4\3\u00d4\5\u00d4\u09fb\n\u00d4\3\u00d4\3\u00d4\3"+
"\u00d4\3\u00d4\3\u00d4\3\u00d4\3\u00d4\5\u00d4\u0a04\n\u00d4\3\u00d4\3"+
"\u00d4\3\u00d4\5\u00d4\u0a09\n\u00d4\3\u00d4\3\u00d4\5\u00d4\u0a0d\n\u00d4"+
"\3\u00d5\3\u00d5\3\u00d5\7\u00d5\u0a12\n\u00d5\f\u00d5\16\u00d5\u0a15"+
"\13\u00d5\3\u00d6\3\u00d6\3\u00d6\5\u00d6\u0a1a\n\u00d6\3\u00d6\3\u00d6"+
"\3\u00d6\3\u00d6\3\u00d6\5\u00d6\u0a21\n\u00d6\3\u00d6\3\u00d6\3\u00d6"+
"\3\u00d6\3\u00d6\5\u00d6\u0a28\n\u00d6\3\u00d6\3\u00d6\3\u00d6\3\u00d6"+
"\3\u00d6\5\u00d6\u0a2f\n\u00d6\3\u00d6\3\u00d6\3\u00d6\3\u00d6\3\u00d6"+
"\3\u00d6\5\u00d6\u0a37\n\u00d6\3\u00d6\3\u00d6\3\u00d6\3\u00d6\3\u00d6"+
"\5\u00d6\u0a3e\n\u00d6\3\u00d6\3\u00d6\3\u00d6\3\u00d6\3\u00d6\3\u00d6"+
"\5\u00d6\u0a46\n\u00d6\3\u00d7\3\u00d7\5\u00d7\u0a4a\n\u00d7\3\u00d7\3"+
"\u00d7\3\u00d8\3\u00d8\3\u00d8\5\u00d8\u0a51\n\u00d8\3\u00d8\3\u00d8\3"+
"\u00d8\3\u00d8\3\u00d8\5\u00d8\u0a58\n\u00d8\3\u00d8\3\u00d8\3\u00d8\3"+
"\u00d8\3\u00d8\5\u00d8\u0a5f\n\u00d8\3\u00d8\3\u00d8\3\u00d8\3\u00d8\3"+
"\u00d8\3\u00d8\5\u00d8\u0a67\n\u00d8\3\u00d8\3\u00d8\3\u00d8\3\u00d8\3"+
"\u00d8\5\u00d8\u0a6e\n\u00d8\3\u00d8\3\u00d8\3\u00d8\3\u00d8\3\u00d8\3"+
"\u00d8\5\u00d8\u0a76\n\u00d8\3\u00d9\3\u00d9\3\u00d9\3\u00d9\5\u00d9\u0a7c"+
"\n\u00d9\3\u00d9\3\u00d9\3\u00d9\3\u00d9\5\u00d9\u0a82\n\u00d9\3\u00d9"+
"\3\u00d9\3\u00d9\3\u00d9\3\u00d9\3\u00d9\3\u00d9\3\u00d9\3\u00d9\3\u00d9"+
"\5\u00d9\u0a8e\n\u00d9\3\u00da\6\u00da\u0a91\n\u00da\r\u00da\16\u00da"+
"\u0a92\3\u00db\7\u00db\u0a96\n\u00db\f\u00db\16\u00db\u0a99\13\u00db\3"+
"\u00db\3\u00db\3\u00db\3\u00db\3\u00dc\3\u00dc\3\u00dd\3\u00dd\5\u00dd"+
"\u0aa3\n\u00dd\3\u00de\3\u00de\3\u00de\3\u00de\3\u00df\3\u00df\3\u00df"+
"\5\u00df\u0aac\n\u00df\3\u00df\3\u00df\3\u00df\3\u00df\3\u00df\5\u00df"+
"\u0ab3\n\u00df\3\u00e0\3\u00e0\3\u00e0\7\u00e0\u0ab8\n\u00e0\f\u00e0\16"+
"\u00e0\u0abb\13\u00e0\3\u00e1\3\u00e1\5\u00e1\u0abf\n\u00e1\3\u00e2\3"+
"\u00e2\5\u00e2\u0ac3\n\u00e2\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e4\3"+
"\u00e4\3\u00e4\5\u00e4\u0acc\n\u00e4\3\u00e5\3\u00e5\3\u00e6\3\u00e6\3"+
"\u00e6\3\u00e6\3\u00e6\3\u00e6\3\u00e6\5\u00e6\u0ad7\n\u00e6\5\u00e6\u0ad9"+
"\n\u00e6\3\u00e7\3\u00e7\3\u00e7\3\u00e7\3\u00e7\3\u00e7\7\u00e7\u0ae1"+
"\n\u00e7\f\u00e7\16\u00e7\u0ae4\13\u00e7\3\u00e8\3\u00e8\3\u00e8\3\u00e8"+
"\3\u00e8\3\u00e8\7\u00e8\u0aec\n\u00e8\f\u00e8\16\u00e8\u0aef\13\u00e8"+
"\3\u00e9\3\u00e9\3\u00e9\3\u00e9\3\u00e9\3\u00e9\7\u00e9\u0af7\n\u00e9"+
"\f\u00e9\16\u00e9\u0afa\13\u00e9\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00ea"+
"\3\u00ea\7\u00ea\u0b02\n\u00ea\f\u00ea\16\u00ea\u0b05\13\u00ea\3\u00eb"+
"\3\u00eb\3\u00eb\3\u00eb\3\u00eb\3\u00eb\7\u00eb\u0b0d\n\u00eb\f\u00eb"+
"\16\u00eb\u0b10\13\u00eb\3\u00ec\3\u00ec\3\u00ec\3\u00ec\3\u00ec\3\u00ec"+
"\3\u00ec\3\u00ec\3\u00ec\7\u00ec\u0b1b\n\u00ec\f\u00ec\16\u00ec\u0b1e"+
"\13\u00ec\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed"+
"\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed\3\u00ed"+
"\3\u00ed\7\u00ed\u0b32\n\u00ed\f\u00ed\16\u00ed\u0b35\13\u00ed\3\u00ee"+
"\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee"+
"\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\7\u00ee\u0b47\n\u00ee"+
"\f\u00ee\16\u00ee\u0b4a\13\u00ee\3\u00ef\3\u00ef\3\u00ef\3\u00ef\3\u00ef"+
"\3\u00ef\3\u00ef\3\u00ef\3\u00ef\7\u00ef\u0b55\n\u00ef\f\u00ef\16\u00ef"+
"\u0b58\13\u00ef\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0"+
"\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f0\7\u00f0\u0b66\n\u00f0\f\u00f0"+
"\16\u00f0\u0b69\13\u00f0\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1\3\u00f1"+
"\3\u00f1\5\u00f1\u0b72\n\u00f1\3\u00f2\3\u00f2\3\u00f2\3\u00f3\3\u00f3"+
"\3\u00f3\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4\3\u00f4\5\u00f4\u0b80"+
"\n\u00f4\3\u00f5\3\u00f5\5\u00f5\u0b84\n\u00f5\3\u00f5\3\u00f5\7\u00f5"+
"\u0b88\n\u00f5\f\u00f5\16\u00f5\u0b8b\13\u00f5\3\u00f6\3\u00f6\3\u00f6"+
"\3\u00f7\3\u00f7\3\u00f8\3\u00f8\3\u00f8\3\u00f9\3\u00f9\3\u00fa\3\u00fa"+
"\3\u00fa\3\u00fa\3\u00fa\3\u00fa\3\u00fa\3\u00fa\7\u00fa\u0b9f\n\u00fa"+
"\f\u00fa\16\u00fa\u0ba2\13\u00fa\3\u00fa\3\u00fa\3\u00fa\3\u00fa\3\u00fa"+
"\3\u00fa\7\u00fa\u0baa\n\u00fa\f\u00fa\16\u00fa\u0bad\13\u00fa\3\u00fa"+
"\3\u00fa\3\u00fa\5\u00fa\u0bb2\n\u00fa\3\u00fb\3\u00fb\3\u00fb\2\20\64"+
"\66:@\u01cc\u01ce\u01d0\u01d2\u01d4\u01d6\u01d8\u01da\u01dc\u01de\u00fc"+
"\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFH"+
"JLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c"+
"\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4"+
"\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc"+
"\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4"+
"\u00d6\u00d8\u00da\u00dc\u00de\u00e0\u00e2\u00e4\u00e6\u00e8\u00ea\u00ec"+
"\u00ee\u00f0\u00f2\u00f4\u00f6\u00f8\u00fa\u00fc\u00fe\u0100\u0102\u0104"+
"\u0106\u0108\u010a\u010c\u010e\u0110\u0112\u0114\u0116\u0118\u011a\u011c"+
"\u011e\u0120\u0122\u0124\u0126\u0128\u012a\u012c\u012e\u0130\u0132\u0134"+
"\u0136\u0138\u013a\u013c\u013e\u0140\u0142\u0144\u0146\u0148\u014a\u014c"+
"\u014e\u0150\u0152\u0154\u0156\u0158\u015a\u015c\u015e\u0160\u0162\u0164"+
"\u0166\u0168\u016a\u016c\u016e\u0170\u0172\u0174\u0176\u0178\u017a\u017c"+
"\u017e\u0180\u0182\u0184\u0186\u0188\u018a\u018c\u018e\u0190\u0192\u0194"+
"\u0196\u0198\u019a\u019c\u019e\u01a0\u01a2\u01a4\u01a6\u01a8\u01aa\u01ac"+
"\u01ae\u01b0\u01b2\u01b4\u01b6\u01b8\u01ba\u01bc\u01be\u01c0\u01c2\u01c4"+
"\u01c6\u01c8\u01ca\u01cc\u01ce\u01d0\u01d2\u01d4\u01d6\u01d8\u01da\u01dc"+
"\u01de\u01e0\u01e2\u01e4\u01e6\u01e8\u01ea\u01ec\u01ee\u01f0\u01f2\u01f4"+
"\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"+
"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"+
"\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"+
"\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"+
"\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"+
"\2\"\u027e\3\2\2\2$\u0285\3\2\2\2&\u0291\3\2\2\2(\u0293\3\2\2\2*\u0296"+
"\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"+
"\2\64\u02b6\3\2\2\2\66\u02c1\3\2\2\28\u02d1\3\2\2\2:\u02d3\3\2\2\2<\u02e3"+
"\3\2\2\2>\u02e5\3\2\2\2@\u02e7\3\2\2\2B\u02f4\3\2\2\2D\u02f7\3\2\2\2F"+
"\u030a\3\2\2\2H\u0312\3\2\2\2J\u0319\3\2\2\2L\u031f\3\2\2\2N\u0321\3\2"+
"\2\2P\u0325\3\2\2\2R\u032b\3\2\2\2T\u0332\3\2\2\2V\u033c\3\2\2\2X\u0341"+
"\3\2\2\2Z\u0357\3\2\2\2\\\u0359\3\2\2\2^\u0363\3\2\2\2`\u0372\3\2\2\2"+
"b\u0381\3\2\2\2d\u0385\3\2\2\2f\u0392\3\2\2\2h\u0396\3\2\2\2j\u039b\3"+
"\2\2\2l\u03b3\3\2\2\2n\u03b5\3\2\2\2p\u03b9\3\2\2\2r\u03c1\3\2\2\2t\u03c4"+
"\3\2\2\2v\u03c7\3\2\2\2x\u03cf\3\2\2\2z\u03dc\3\2\2\2|\u03e3\3\2\2\2~"+
"\u03e8\3\2\2\2\u0080\u03f7\3\2\2\2\u0082\u03f9\3\2\2\2\u0084\u0401\3\2"+
"\2\2\u0086\u0406\3\2\2\2\u0088\u040c\3\2\2\2\u008a\u0410\3\2\2\2\u008c"+
"\u0414\3\2\2\2\u008e\u0419\3\2\2\2\u0090\u041d\3\2\2\2\u0092\u0436\3\2"+
"\2\2\u0094\u0438\3\2\2\2\u0096\u0443\3\2\2\2\u0098\u0447\3\2\2\2\u009a"+
"\u0449\3\2\2\2\u009c\u044b\3\2\2\2\u009e\u044d\3\2\2\2\u00a0\u0458\3\2"+
"\2\2\u00a2\u045d\3\2\2\2\u00a4\u046d\3\2\2\2\u00a6\u0480\3\2\2\2\u00a8"+
"\u0484\3\2\2\2\u00aa\u0486\3\2\2\2\u00ac\u0495\3\2\2\2\u00ae\u04a7\3\2"+
"\2\2\u00b0\u04ac\3\2\2\2\u00b2\u04b4\3\2\2\2\u00b4\u04c7\3\2\2\2\u00b6"+
"\u04cc\3\2\2\2\u00b8\u04d7\3\2\2\2\u00ba\u04da\3\2\2\2\u00bc\u04e4\3\2"+
"\2\2\u00be\u04e8\3\2\2\2\u00c0\u04ea\3\2\2\2\u00c2\u04ec\3\2\2\2\u00c4"+
"\u04f2\3\2\2\2\u00c6\u04ff\3\2\2\2\u00c8\u0502\3\2\2\2\u00ca\u050b\3\2"+
"\2\2\u00cc\u050d\3\2\2\2\u00ce\u0544\3\2\2\2\u00d0\u0549\3\2\2\2\u00d2"+
"\u0553\3\2\2\2\u00d4\u055f\3\2\2\2\u00d6\u056a\3\2\2\2\u00d8\u0578\3\2"+
"\2\2\u00da\u057a\3\2\2\2\u00dc\u0583\3\2\2\2\u00de\u0588\3\2\2\2\u00e0"+
"\u059c\3\2\2\2\u00e2\u059e\3\2\2\2\u00e4\u05a1\3\2\2\2\u00e6\u05af\3\2"+
"\2\2\u00e8\u05b4\3\2\2\2\u00ea\u05bf\3\2\2\2\u00ec\u05c4\3\2\2\2\u00ee"+
"\u05d1\3\2\2\2\u00f0\u05d6\3\2\2\2\u00f2\u05de\3\2\2\2\u00f4\u05ec\3\2"+
"\2\2\u00f6\u05f1\3\2\2\2\u00f8\u0603\3\2\2\2\u00fa\u0605\3\2\2\2\u00fc"+
"\u060b\3\2\2\2\u00fe\u060d\3\2\2\2\u0100\u0615\3\2\2\2\u0102\u061d\3\2"+
"\2\2\u0104\u0624\3\2\2\2\u0106\u0626\3\2\2\2\u0108\u062f\3\2\2\2\u010a"+
"\u0637\3\2\2\2\u010c\u063a\3\2\2\2\u010e\u0640\3\2\2\2\u0110\u0649\3\2"+
"\2\2\u0112\u0651\3\2\2\2\u0114\u0658\3\2\2\2\u0116\u065f\3\2\2\2\u0118"+
"\u0661\3\2\2\2\u011a\u0667\3\2\2\2\u011c\u0673\3\2\2\2\u011e\u067a\3\2"+
"\2\2\u0120\u0688\3\2\2\2\u0122\u068a\3\2\2\2\u0124\u068c\3\2\2\2\u0126"+
"\u0690\3\2\2\2\u0128\u0694\3\2\2\2\u012a\u069e\3\2\2\2\u012c\u06a0\3\2"+
"\2\2\u012e\u06a6\3\2\2\2\u0130\u06ae\3\2\2\2\u0132\u06c0\3\2\2\2\u0134"+
"\u06c2\3\2\2\2\u0136\u06c8\3\2\2\2\u0138\u06d7\3\2\2\2\u013a\u06db\3\2"+
"\2\2\u013c\u06e9\3\2\2\2\u013e\u06eb\3\2\2\2\u0140\u06ed\3\2\2\2\u0142"+
"\u06f3\3\2\2\2\u0144\u06f9\3\2\2\2\u0146\u0703\3\2\2\2\u0148\u0707\3\2"+
"\2\2\u014a\u0709\3\2\2\2\u014c\u0719\3\2\2\2\u014e\u072b\3\2\2\2\u0150"+
"\u072d\3\2\2\2\u0152\u072f\3\2\2\2\u0154\u0737\3\2\2\2\u0156\u0746\3\2"+
"\2\2\u0158\u0755\3\2\2\2\u015a\u075b\3\2\2\2\u015c\u0761\3\2\2\2\u015e"+
"\u0767\3\2\2\2\u0160\u076b\3\2\2\2\u0162\u077d\3\2\2\2\u0164\u0780\3\2"+
"\2\2\u0166\u0784\3\2\2\2\u0168\u078d\3\2\2\2\u016a\u0793\3\2\2\2\u016c"+
"\u079b\3\2\2\2\u016e\u079e\3\2\2\2\u0170\u07a7\3\2\2\2\u0172\u07ae\3\2"+
"\2\2\u0174\u07c2\3\2\2\2\u0176\u07c6\3\2\2\2\u0178\u07ca\3\2\2\2\u017a"+
"\u07e2\3\2\2\2\u017c\u07e4\3\2\2\2\u017e\u0802\3\2\2\2\u0180\u0809\3\2"+
"\2\2\u0182\u080b\3\2\2\2\u0184\u0811\3\2\2\2\u0186\u083b\3\2\2\2\u0188"+
"\u083d\3\2\2\2\u018a\u0866\3\2\2\2\u018c\u0879\3\2\2\2\u018e\u08ce\3\2"+
"\2\2\u0190\u08d0\3\2\2\2\u0192\u0922\3\2\2\2\u0194\u0927\3\2\2\2\u0196"+
"\u0936\3\2\2\2\u0198\u0938\3\2\2\2\u019a\u0944\3\2\2\2\u019c\u0950\3\2"+
"\2\2\u019e\u095c\3\2\2\2\u01a0\u0975\3\2\2\2\u01a2\u09c6\3\2\2\2\u01a4"+
"\u09c8\3\2\2\2\u01a6\u0a0c\3\2\2\2\u01a8\u0a0e\3\2\2\2\u01aa\u0a45\3\2"+
"\2\2\u01ac\u0a47\3\2\2\2\u01ae\u0a75\3\2\2\2\u01b0\u0a8d\3\2\2\2\u01b2"+
"\u0a90\3\2\2\2\u01b4\u0a97\3\2\2\2\u01b6\u0a9e\3\2\2\2\u01b8\u0aa2\3\2"+
"\2\2\u01ba\u0aa4\3\2\2\2\u01bc\u0ab2\3\2\2\2\u01be\u0ab4\3\2\2\2\u01c0"+
"\u0abe\3\2\2\2\u01c2\u0ac2\3\2\2\2\u01c4\u0ac4\3\2\2\2\u01c6\u0acb\3\2"+
"\2\2\u01c8\u0acd\3\2\2\2\u01ca\u0ad8\3\2\2\2\u01cc\u0ada\3\2\2\2\u01ce"+
"\u0ae5\3\2\2\2\u01d0\u0af0\3\2\2\2\u01d2\u0afb\3\2\2\2\u01d4\u0b06\3\2"+
"\2\2\u01d6\u0b11\3\2\2\2\u01d8\u0b1f\3\2\2\2\u01da\u0b36\3\2\2\2\u01dc"+
"\u0b4b\3\2\2\2\u01de\u0b59\3\2\2\2\u01e0\u0b71\3\2\2\2\u01e2\u0b73\3\2"+
"\2\2\u01e4\u0b76\3\2\2\2\u01e6\u0b7f\3\2\2\2\u01e8\u0b83\3\2\2\2\u01ea"+
"\u0b8c\3\2\2\2\u01ec\u0b8f\3\2\2\2\u01ee\u0b91\3\2\2\2\u01f0\u0b94\3\2"+
"\2\2\u01f2\u0bb1\3\2\2\2\u01f4\u0bb3\3\2\2\2\u01f6\u01f7\t\2\2\2\u01f7"+
"\3\3\2\2\2\u01f8\u01fa\5\u00fc\177\2\u01f9\u01f8\3\2\2\2\u01fa\u01fd\3"+
"\2\2\2\u01fb\u01f9\3\2\2\2\u01fb\u01fc\3\2\2\2\u01fc\u01fe\3\2\2\2\u01fd"+
"\u01fb\3\2\2\2\u01fe\u0207\5\6\4\2\u01ff\u0201\5\u00fc\177\2\u0200\u01ff"+
"\3\2\2\2\u0201\u0204\3\2\2\2\u0202\u0200\3\2\2\2\u0202\u0203\3\2\2\2\u0203"+
"\u0205\3\2\2\2\u0204\u0202\3\2\2\2\u0205\u0207\7\17\2\2\u0206\u01fb\3"+
"\2\2\2\u0206\u0202\3\2\2\2\u0207\5\3\2\2\2\u0208\u020b\5\b\5\2\u0209\u020b"+
"\5\n\6\2\u020a\u0208\3\2\2\2\u020a\u0209\3\2\2\2\u020b\7\3\2\2\2\u020c"+
"\u020d\t\3\2\2\u020d\t\3\2\2\2\u020e\u020f\t\4\2\2\u020f\13\3\2\2\2\u0210"+
"\u0214\5\16\b\2\u0211\u0214\5\34\17\2\u0212\u0214\5\36\20\2\u0213\u0210"+
"\3\2\2\2\u0213\u0211\3\2\2\2\u0213\u0212\3\2\2\2\u0214\r\3\2\2\2\u0215"+
"\u0218\5\24\13\2\u0216\u0218\5\32\16\2\u0217\u0215\3\2\2\2\u0217\u0216"+
"\3\2\2\2\u0218\u021d\3\2\2\2\u0219\u021c\5\22\n\2\u021a\u021c\5\30\r\2"+
"\u021b\u0219\3\2\2\2\u021b\u021a\3\2\2\2\u021c\u021f\3\2\2\2\u021d\u021b"+
"\3\2\2\2\u021d\u021e\3\2\2\2\u021e\17\3\2\2\2\u021f\u021d\3\2\2\2\u0220"+
"\u0222\5\u00fc\177\2\u0221\u0220\3\2\2\2\u0222\u0225\3\2\2\2\u0223\u0221"+
"\3\2\2\2\u0223\u0224\3\2\2\2\u0224\u0226\3\2\2\2\u0225\u0223\3\2\2\2\u0226"+
"\u0228\5\u01f4\u00fb\2\u0227\u0229\5*\26\2\u0228\u0227\3\2\2\2\u0228\u0229"+
"\3\2\2\2\u0229\u0237\3\2\2\2\u022a\u022b\5\16\b\2\u022b\u022f\7N\2\2\u022c"+
"\u022e\5\u00fc\177\2\u022d\u022c\3\2\2\2\u022e\u0231\3\2\2\2\u022f\u022d"+
"\3\2\2\2\u022f\u0230\3\2\2\2\u0230\u0232\3\2\2\2\u0231\u022f\3\2\2\2\u0232"+
"\u0234\5\u01f4\u00fb\2\u0233\u0235\5*\26\2\u0234\u0233\3\2\2\2\u0234\u0235"+
"\3\2\2\2\u0235\u0237\3\2\2\2\u0236\u0223\3\2\2\2\u0236\u022a\3\2\2\2\u0237"+
"\21\3\2\2\2\u0238\u023c\7N\2\2\u0239\u023b\5\u00fc\177\2\u023a\u0239\3"+
"\2\2\2\u023b\u023e\3\2\2\2\u023c\u023a\3\2\2\2\u023c\u023d\3\2\2\2\u023d"+
"\u023f\3\2\2\2\u023e\u023c\3\2\2\2\u023f\u0241\5\u01f4\u00fb\2\u0240\u0242"+
"\5*\26\2\u0241\u0240\3\2\2\2\u0241\u0242\3\2\2\2\u0242\23\3\2\2\2\u0243"+
"\u0245\5\u00fc\177\2\u0244\u0243\3\2\2\2\u0245\u0248\3\2\2\2\u0246\u0244"+
"\3\2\2\2\u0246\u0247\3\2\2\2\u0247\u0249\3\2\2\2\u0248\u0246\3\2\2\2\u0249"+
"\u024b\5\u01f4\u00fb\2\u024a\u024c\5*\26\2\u024b\u024a\3\2\2\2\u024b\u024c"+
"\3\2\2\2\u024c\25\3\2\2\2\u024d\u024e\5\20\t\2\u024e\27\3\2\2\2\u024f"+
"\u0250\5\22\n\2\u0250\31\3\2\2\2\u0251\u0252\5\24\13\2\u0252\33\3\2\2"+
"\2\u0253\u0255\5\u00fc\177\2\u0254\u0253\3\2\2\2\u0255\u0258\3\2\2\2\u0256"+
"\u0254\3\2\2\2\u0256\u0257\3\2\2\2\u0257\u0259\3\2\2\2\u0258\u0256\3\2"+
"\2\2\u0259\u025a\5\u01f4\u00fb\2\u025a\35\3\2\2\2\u025b\u025c\5\4\3\2"+
"\u025c\u025d\5 \21\2\u025d\u0265\3\2\2\2\u025e\u025f\5\16\b\2\u025f\u0260"+
"\5 \21\2\u0260\u0265\3\2\2\2\u0261\u0262\5\34\17\2\u0262\u0263\5 \21\2"+
"\u0263\u0265\3\2\2\2\u0264\u025b\3\2\2\2\u0264\u025e\3\2\2\2\u0264\u0261"+
"\3\2\2\2\u0265\37\3\2\2\2\u0266\u0268\5\u00fc\177\2\u0267\u0266\3\2\2"+
"\2\u0268\u026b\3\2\2\2\u0269\u0267\3\2\2\2\u0269\u026a\3\2\2\2\u026a\u026c"+
"\3\2\2\2\u026b\u0269\3\2\2\2\u026c\u026d\7J\2\2\u026d\u0278\7K\2\2\u026e"+
"\u0270\5\u00fc\177\2\u026f\u026e\3\2\2\2\u0270\u0273\3\2\2\2\u0271\u026f"+
"\3\2\2\2\u0271\u0272\3\2\2\2\u0272\u0274\3\2\2\2\u0273\u0271\3\2\2\2\u0274"+
"\u0275\7J\2\2\u0275\u0277\7K\2\2\u0276\u0271\3\2\2\2\u0277\u027a\3\2\2"+
"\2\u0278\u0276\3\2\2\2\u0278\u0279\3\2\2\2\u0279!\3\2\2\2\u027a\u0278"+
"\3\2\2\2\u027b\u027d\5$\23\2\u027c\u027b\3\2\2\2\u027d\u0280\3\2\2\2\u027e"+
"\u027c\3\2\2\2\u027e\u027f\3\2\2\2\u027f\u0281\3\2\2\2\u0280\u027e\3\2"+
"\2\2\u0281\u0283\5\u01f4\u00fb\2\u0282\u0284\5&\24\2\u0283\u0282\3\2\2"+
"\2\u0283\u0284\3\2\2\2\u0284#\3\2\2\2\u0285\u0286\5\u00fc\177\2\u0286"+
"%\3\2\2\2\u0287\u0288\7\35\2\2\u0288\u0292\5\34\17\2\u0289\u028a\7\35"+
"\2\2\u028a\u028e\5\16\b\2\u028b\u028d\5(\25\2\u028c\u028b\3\2\2\2\u028d"+
"\u0290\3\2\2\2\u028e\u028c\3\2\2\2\u028e\u028f\3\2\2\2\u028f\u0292\3\2"+
"\2\2\u0290\u028e\3\2\2\2\u0291\u0287\3\2\2\2\u0291\u0289\3\2\2\2\u0292"+
"\'\3\2\2\2\u0293\u0294\7f\2\2\u0294\u0295\5\26\f\2\u0295)\3\2\2\2\u0296"+
"\u0297\7T\2\2\u0297\u0298\5,\27\2\u0298\u0299\7S\2\2\u0299+\3\2\2\2\u029a"+
"\u029f\5.\30\2\u029b\u029c\7M\2\2\u029c\u029e\5.\30\2\u029d\u029b\3\2"+
"\2\2\u029e\u02a1\3\2\2\2\u029f\u029d\3\2\2\2\u029f\u02a0\3\2\2\2\u02a0"+
"-\3\2\2\2\u02a1\u029f\3\2\2\2\u02a2\u02a5\5\f\7\2\u02a3\u02a5\5\60\31"+
"\2\u02a4\u02a2\3\2\2\2\u02a4\u02a3\3\2\2\2\u02a5/\3\2\2\2\u02a6\u02a8"+
"\5\u00fc\177\2\u02a7\u02a6\3\2\2\2\u02a8\u02ab\3\2\2\2\u02a9\u02a7\3\2"+
"\2\2\u02a9\u02aa\3\2\2\2\u02aa\u02ac\3\2\2\2\u02ab\u02a9\3\2\2\2\u02ac"+
"\u02ae\7W\2\2\u02ad\u02af\5\62\32\2\u02ae\u02ad\3\2\2\2\u02ae\u02af\3"+
"\2\2\2\u02af\61\3\2\2\2\u02b0\u02b1\7\35\2\2\u02b1\u02b5\5\f\7\2\u02b2"+
"\u02b3\7\64\2\2\u02b3\u02b5\5\f\7\2\u02b4\u02b0\3\2\2\2\u02b4\u02b2\3"+
"\2\2\2\u02b5\63\3\2\2\2\u02b6\u02b7\b\33\1\2\u02b7\u02b8\5\u01f4\u00fb"+
"\2\u02b8\u02be\3\2\2\2\u02b9\u02ba\f\3\2\2\u02ba\u02bb\7N\2\2\u02bb\u02bd"+
"\5\u01f4\u00fb\2\u02bc\u02b9\3\2\2\2\u02bd\u02c0\3\2\2\2\u02be\u02bc\3"+
"\2\2\2\u02be\u02bf\3\2\2\2\u02bf\65\3\2\2\2\u02c0\u02be\3\2\2\2\u02c1"+
"\u02c2\b\34\1\2\u02c2\u02c3\5\u01f4\u00fb\2\u02c3\u02c9\3\2\2\2\u02c4"+
"\u02c5\f\3\2\2\u02c5\u02c6\7N\2\2\u02c6\u02c8\5\u01f4\u00fb\2\u02c7\u02c4"+
"\3\2\2\2\u02c8\u02cb\3\2\2\2\u02c9\u02c7\3\2\2\2\u02c9\u02ca\3\2\2\2\u02ca"+
"\67\3\2\2\2\u02cb\u02c9\3\2\2\2\u02cc\u02d2\5\u01f4\u00fb\2\u02cd\u02ce"+
"\5:\36\2\u02ce\u02cf\7N\2\2\u02cf\u02d0\5\u01f4\u00fb\2\u02d0\u02d2\3"+
"\2\2\2\u02d1\u02cc\3\2\2\2\u02d1\u02cd\3\2\2\2\u02d29\3\2\2\2\u02d3\u02d4"+
"\b\36\1\2\u02d4\u02d5\5\u01f4\u00fb\2\u02d5\u02db\3\2\2\2\u02d6\u02d7"+
"\f\3\2\2\u02d7\u02d8\7N\2\2\u02d8\u02da\5\u01f4\u00fb\2\u02d9\u02d6\3"+
"\2\2\2\u02da\u02dd\3\2\2\2\u02db\u02d9\3\2\2\2\u02db\u02dc\3\2\2\2\u02dc"+
";\3\2\2\2\u02dd\u02db\3\2\2\2\u02de\u02e4\5\u01f4\u00fb\2\u02df\u02e0"+
"\5@!\2\u02e0\u02e1\7N\2\2\u02e1\u02e2\5\u01f4\u00fb\2\u02e2\u02e4\3\2"+
"\2\2\u02e3\u02de\3\2\2\2\u02e3\u02df\3\2\2\2\u02e4=\3\2\2\2\u02e5\u02e6"+
"\5\u01f4\u00fb\2\u02e6?\3\2\2\2\u02e7\u02e8\b!\1\2\u02e8\u02e9\5\u01f4"+
"\u00fb\2\u02e9\u02ef\3\2\2\2\u02ea\u02eb\f\3\2\2\u02eb\u02ec\7N\2\2\u02ec"+
"\u02ee\5\u01f4\u00fb\2\u02ed\u02ea\3\2\2\2\u02ee\u02f1\3\2\2\2\u02ef\u02ed"+
"\3\2\2\2\u02ef\u02f0\3\2\2\2\u02f0A\3\2\2\2\u02f1\u02ef\3\2\2\2\u02f2"+
"\u02f5\5D#\2\u02f3\u02f5\5F$\2\u02f4\u02f2\3\2\2\2\u02f4\u02f3\3\2\2\2"+
"\u02f5C\3\2\2\2\u02f6\u02f8\5H%\2\u02f7\u02f6\3\2\2\2\u02f7\u02f8\3\2"+
"\2\2\u02f8\u02fc\3\2\2\2\u02f9\u02fb\5L\'\2\u02fa\u02f9\3\2\2\2\u02fb"+
"\u02fe\3\2\2\2\u02fc\u02fa\3\2\2\2\u02fc\u02fd\3\2\2\2\u02fd\u0302\3\2"+
"\2\2\u02fe\u02fc\3\2\2\2\u02ff\u0301\5V,\2\u0300\u02ff\3\2\2\2\u0301\u0304"+
"\3\2\2\2\u0302\u0300\3\2\2\2\u0302\u0303\3\2\2\2\u0303\u0305\3\2\2\2\u0304"+
"\u0302\3\2\2\2\u0305\u0306\7\2\2\3\u0306E\3\2\2\2\u0307\u0309\5L\'\2\u0308"+
"\u0307\3\2\2\2\u0309\u030c\3\2\2\2\u030a\u0308\3\2\2\2\u030a\u030b\3\2"+
"\2\2\u030b\u030d\3\2\2\2\u030c\u030a\3\2\2\2\u030d\u030e\5X-\2\u030eG"+
"\3\2\2\2\u030f\u0311\5J&\2\u0310\u030f\3\2\2\2\u0311\u0314\3\2\2\2\u0312"+
"\u0310\3\2\2\2\u0312\u0313\3\2\2\2\u0313\u0315\3\2\2\2\u0314\u0312\3\2"+
"\2\2\u0315\u0316\7,\2\2\u0316\u0317\5\66\34\2\u0317\u0318\7L\2\2\u0318"+
"I\3\2\2\2\u0319\u031a\5\u00fc\177\2\u031aK\3\2\2\2\u031b\u0320\5N(\2\u031c"+
"\u0320\5P)\2\u031d\u0320\5R*\2\u031e\u0320\5T+\2\u031f\u031b\3\2\2\2\u031f"+
"\u031c\3\2\2\2\u031f\u031d\3\2\2\2\u031f\u031e\3\2\2\2\u0320M\3\2\2\2"+
"\u0321\u0322\7%\2\2\u0322\u0323\58\35\2\u0323\u0324\7L\2\2\u0324O\3\2"+
"\2\2\u0325\u0326\7%\2\2\u0326\u0327\5:\36\2\u0327\u0328\7N\2\2\u0328\u0329"+
"\7d\2\2\u0329\u032a\7L\2\2\u032aQ\3\2\2\2\u032b\u032c\7%\2\2\u032c\u032d"+
"\7\62\2\2\u032d\u032e\58\35\2\u032e\u032f\7N\2\2\u032f\u0330\5\u01f4\u00fb"+
"\2\u0330\u0331\7L\2\2\u0331S\3\2\2\2\u0332\u0333\7%\2\2\u0333\u0334\7"+
"\62\2\2\u0334\u0335\58\35\2\u0335\u0336\7N\2\2\u0336\u0337\7d\2\2\u0337"+
"\u0338\7L\2\2\u0338U\3\2\2\2\u0339\u033d\5h\65\2\u033a\u033d\5\u00dco"+
"\2\u033b\u033d\7L\2\2\u033c\u0339\3\2\2\2\u033c\u033a\3\2\2\2\u033c\u033b"+
"\3\2\2\2\u033dW\3\2\2\2\u033e\u0340\5\u00fc\177\2\u033f\u033e\3\2\2\2"+
"\u0340\u0343\3\2\2\2\u0341\u033f\3\2\2\2\u0341\u0342\3\2\2\2\u0342\u0345"+
"\3\2\2\2\u0343\u0341\3\2\2\2\u0344\u0346\7\3\2\2\u0345\u0344\3\2\2\2\u0345"+
"\u0346\3\2\2\2\u0346\u0347\3\2\2\2\u0347\u0348\7\4\2\2\u0348\u0349\5\64"+
"\33\2\u0349\u034d\7H\2\2\u034a\u034c\5Z.\2\u034b\u034a\3\2\2\2\u034c\u034f"+
"\3\2\2\2\u034d\u034b\3\2\2\2\u034d\u034e\3\2\2\2\u034e\u0350\3\2\2\2\u034f"+
"\u034d\3\2\2\2\u0350\u0351\7I\2\2\u0351Y\3\2\2\2\u0352\u0358\5\\/\2\u0353"+
"\u0358\5^\60\2\u0354\u0358\5`\61\2\u0355\u0358\5b\62\2\u0356\u0358\5d"+
"\63\2\u0357\u0352\3\2\2\2\u0357\u0353\3\2\2\2\u0357\u0354\3\2\2\2\u0357"+
"\u0355\3\2\2\2\u0357\u0356\3\2\2\2\u0358[\3\2\2\2\u0359\u035d\7\5\2\2"+
"\u035a\u035c\5f\64\2\u035b\u035a\3\2\2\2\u035c\u035f\3\2\2\2\u035d\u035b"+
"\3\2\2\2\u035d\u035e\3\2\2\2\u035e\u0360\3\2\2\2\u035f\u035d\3\2\2\2\u0360"+
"\u0361\5\64\33\2\u0361\u0362\7L\2\2\u0362]\3\2\2\2\u0363\u0364\7\6\2\2"+
"\u0364\u036e\5\66\34\2\u0365\u0366\7\7\2\2\u0366\u036b\5\64\33\2\u0367"+
"\u0368\7M\2\2\u0368\u036a\5\64\33\2\u0369\u0367\3\2\2\2\u036a\u036d\3"+
"\2\2\2\u036b\u0369\3\2\2\2\u036b\u036c\3\2\2\2\u036c\u036f\3\2\2\2\u036d"+
"\u036b\3\2\2\2\u036e\u0365\3\2\2\2\u036e\u036f\3\2\2\2\u036f\u0370\3\2"+
"\2\2\u0370\u0371\7L\2\2\u0371_\3\2\2\2\u0372\u0373\7\b\2\2\u0373\u037d"+
"\5\66\34\2\u0374\u0375\7\7\2\2\u0375\u037a\5\64\33\2\u0376\u0377\7M\2"+
"\2\u0377\u0379\5\64\33\2\u0378\u0376\3\2\2\2\u0379\u037c\3\2\2\2\u037a"+
"\u0378\3\2\2\2\u037a\u037b\3\2\2\2\u037b\u037e\3\2\2\2\u037c\u037a\3\2"+
"\2\2\u037d\u0374\3\2\2\2\u037d\u037e\3\2\2\2\u037e\u037f\3\2\2\2\u037f"+
"\u0380\7L\2\2\u0380a\3\2\2\2\u0381\u0382\7\t\2\2\u0382\u0383\58\35\2\u0383"+
"\u0384\7L\2\2\u0384c\3\2\2\2\u0385\u0386\7\n\2\2\u0386\u0387\58\35\2\u0387"+
"\u0388\7\13\2\2\u0388\u038d\58\35\2\u0389\u038a\7M\2\2\u038a\u038c\58"+
"\35\2\u038b\u0389\3\2\2\2\u038c\u038f\3\2\2\2\u038d\u038b\3\2\2\2\u038d"+
"\u038e\3\2\2\2\u038e\u0390\3\2\2\2\u038f\u038d\3\2\2\2\u0390\u0391\7L"+
"\2\2\u0391e\3\2\2\2\u0392\u0393\t\5\2\2\u0393g\3\2\2\2\u0394\u0397\5j"+
"\66\2\u0395\u0397\5\u00d0i\2\u0396\u0394\3\2\2\2\u0396\u0395\3\2\2\2\u0397"+
"i\3\2\2\2\u0398\u039a\5l\67\2\u0399\u0398\3\2\2\2\u039a\u039d\3\2\2\2"+
"\u039b\u0399\3\2\2\2\u039b\u039c\3\2\2\2\u039c\u039e\3\2\2\2\u039d\u039b"+
"\3\2\2\2\u039e\u039f\7\25\2\2\u039f\u03a1\5\u01f4\u00fb\2\u03a0\u03a2"+
"\5n8\2\u03a1\u03a0\3\2\2\2\u03a1\u03a2\3\2\2\2\u03a2\u03a4\3\2\2\2\u03a3"+
"\u03a5\5r:\2\u03a4\u03a3\3\2\2\2\u03a4\u03a5\3\2\2\2\u03a5\u03a7\3\2\2"+
"\2\u03a6\u03a8\5t;\2\u03a7\u03a6\3\2\2\2\u03a7\u03a8\3\2\2\2\u03a8\u03a9"+
"\3\2\2\2\u03a9\u03aa\5x=\2\u03aak\3\2\2\2\u03ab\u03b4\5\u00fc\177\2\u03ac"+
"\u03b4\7/\2\2\u03ad\u03b4\7.\2\2\u03ae\u03b4\7-\2\2\u03af\u03b4\7\r\2"+
"\2\u03b0\u03b4\7\62\2\2\u03b1\u03b4\7\36\2\2\u03b2\u03b4\7\63\2\2\u03b3"+
"\u03ab\3\2\2\2\u03b3\u03ac\3\2\2\2\u03b3\u03ad\3\2\2\2\u03b3\u03ae\3\2"+
"\2\2\u03b3\u03af\3\2\2\2\u03b3\u03b0\3\2\2\2\u03b3\u03b1\3\2\2\2\u03b3"+
"\u03b2\3\2\2\2\u03b4m\3\2\2\2\u03b5\u03b6\7T\2\2\u03b6\u03b7\5p9\2\u03b7"+
"\u03b8\7S\2\2\u03b8o\3\2\2\2\u03b9\u03be\5\"\22\2\u03ba\u03bb\7M\2\2\u03bb"+
"\u03bd\5\"\22\2\u03bc\u03ba\3\2\2\2\u03bd\u03c0\3\2\2\2\u03be\u03bc\3"+
"\2\2\2\u03be\u03bf\3\2\2\2\u03bfq\3\2\2\2\u03c0\u03be\3\2\2\2\u03c1\u03c2"+
"\7\35\2\2\u03c2\u03c3\5\20\t\2\u03c3s\3\2\2\2\u03c4\u03c5\7$\2\2\u03c5"+
"\u03c6\5v<\2\u03c6u\3\2\2\2\u03c7\u03cc\5\26\f\2\u03c8\u03c9\7M\2\2\u03c9"+
"\u03cb\5\26\f\2\u03ca\u03c8\3\2\2\2\u03cb\u03ce\3\2\2\2\u03cc\u03ca\3"+
"\2\2\2\u03cc\u03cd\3\2\2\2\u03cdw\3\2\2\2\u03ce\u03cc\3\2\2\2\u03cf\u03d3"+
"\7H\2\2\u03d0\u03d2\5z>\2\u03d1\u03d0\3\2\2\2\u03d2\u03d5\3\2\2\2\u03d3"+
"\u03d1\3\2\2\2\u03d3\u03d4\3\2\2\2\u03d4\u03d6\3\2\2\2\u03d5\u03d3\3\2"+
"\2\2\u03d6\u03d7\7I\2\2\u03d7y\3\2\2\2\u03d8\u03dd\5|?\2\u03d9\u03dd\5"+
"\u00c0a\2\u03da\u03dd\5\u00c2b\2\u03db\u03dd\5\u00c4c\2\u03dc\u03d8\3"+
"\2\2\2\u03dc\u03d9\3\2\2\2\u03dc\u03da\3\2\2\2\u03dc\u03db\3\2\2\2\u03dd"+
"{\3\2\2\2\u03de\u03e4\5~@\2\u03df\u03e4\5\u00a2R\2\u03e0\u03e4\5h\65\2"+
"\u03e1\u03e4\5\u00dco\2\u03e2\u03e4\7L\2\2\u03e3\u03de\3\2\2\2\u03e3\u03df"+
"\3\2\2\2\u03e3\u03e0\3\2\2\2\u03e3\u03e1\3\2\2\2\u03e3\u03e2\3\2\2\2\u03e4"+
"}\3\2\2\2\u03e5\u03e7\5\u0080A\2\u03e6\u03e5\3\2\2\2\u03e7\u03ea\3\2\2"+
"\2\u03e8\u03e6\3\2\2\2\u03e8\u03e9\3\2\2\2\u03e9\u03eb\3\2\2\2\u03ea\u03e8"+
"\3\2\2\2\u03eb\u03ec\5\u008aF\2\u03ec\u03ed\5\u0082B\2\u03ed\u03ee\7L"+
"\2\2\u03ee\177\3\2\2\2\u03ef\u03f8\5\u00fc\177\2\u03f0\u03f8\7/\2\2\u03f1"+
"\u03f8\7.\2\2\u03f2\u03f8\7-\2\2\u03f3\u03f8\7\62\2\2\u03f4\u03f8\7\36"+
"\2\2\u03f5\u03f8\7:\2\2\u03f6\u03f8\7=\2\2\u03f7\u03ef\3\2\2\2\u03f7\u03f0"+
"\3\2\2\2\u03f7\u03f1\3\2\2\2\u03f7\u03f2\3\2\2\2\u03f7\u03f3\3\2\2\2\u03f7"+
"\u03f4\3\2\2\2\u03f7\u03f5\3\2\2\2\u03f7\u03f6\3\2\2\2\u03f8\u0081\3\2"+
"\2\2\u03f9\u03fe\5\u0084C\2\u03fa\u03fb\7M\2\2\u03fb\u03fd\5\u0084C\2"+
"\u03fc\u03fa\3\2\2\2\u03fd\u0400\3\2\2\2\u03fe\u03fc\3\2\2\2\u03fe\u03ff"+
"\3\2\2\2\u03ff\u0083\3\2\2\2\u0400\u03fe\3\2\2\2\u0401\u0404\5\u0086D"+
"\2\u0402\u0403\7R\2\2\u0403\u0405\5\u0088E\2\u0404\u0402\3\2\2\2\u0404"+
"\u0405\3\2\2\2\u0405\u0085\3\2\2\2\u0406\u0408\5\u01f4\u00fb\2\u0407\u0409"+
"\5 \21\2\u0408\u0407\3\2\2\2\u0408\u0409\3\2\2\2\u0409\u0087\3\2\2\2\u040a"+
"\u040d\5\u01b8\u00dd\2\u040b\u040d\5\u010e\u0088\2\u040c\u040a\3\2\2\2"+
"\u040c\u040b\3\2\2\2\u040d\u0089\3\2\2\2\u040e\u0411\5\u008cG\2\u040f"+
"\u0411\5\u008eH\2\u0410\u040e\3\2\2\2\u0410\u040f\3\2\2\2\u0411\u008b"+
"\3\2\2\2\u0412\u0415\5\6\4\2\u0413\u0415\7\17\2\2\u0414\u0412\3\2\2\2"+
"\u0414\u0413\3\2\2\2\u0415\u008d\3\2\2\2\u0416\u041a\5\u0090I\2\u0417"+
"\u041a\5\u009eP\2\u0418\u041a\5\u00a0Q\2\u0419\u0416\3\2\2\2\u0419\u0417"+
"\3\2\2\2\u0419\u0418\3\2\2\2\u041a\u008f\3\2\2\2\u041b\u041e\5\u0096L"+
"\2\u041c\u041e\5\u009cO\2\u041d\u041b\3\2\2\2\u041d\u041c\3\2\2\2\u041e"+
"\u0423\3\2\2\2\u041f\u0422\5\u0094K\2\u0420\u0422\5\u009aN\2\u0421\u041f"+
"\3\2\2\2\u0421\u0420\3\2\2\2\u0422\u0425\3\2\2\2\u0423\u0421\3\2\2\2\u0423"+
"\u0424\3\2\2\2\u0424\u0091\3\2\2\2\u0425\u0423\3\2\2\2\u0426\u0428\5\u01f4"+
"\u00fb\2\u0427\u0429\5*\26\2\u0428\u0427\3\2\2\2\u0428\u0429\3\2\2\2\u0429"+
"\u0437\3\2\2\2\u042a\u042b\5\u0090I\2\u042b\u042f\7N\2\2\u042c\u042e\5"+
"\u00fc\177\2\u042d\u042c\3\2\2\2\u042e\u0431\3\2\2\2\u042f\u042d\3\2\2"+
"\2\u042f\u0430\3\2\2\2\u0430\u0432\3\2\2\2\u0431\u042f\3\2\2\2\u0432\u0434"+
"\5\u01f4\u00fb\2\u0433\u0435\5*\26\2\u0434\u0433\3\2\2\2\u0434\u0435\3"+
"\2\2\2\u0435\u0437\3\2\2\2\u0436\u0426\3\2\2\2\u0436\u042a\3\2\2\2\u0437"+
"\u0093\3\2\2\2\u0438\u043c\7N\2\2\u0439\u043b\5\u00fc\177\2\u043a\u0439"+
"\3\2\2\2\u043b\u043e\3\2\2\2\u043c\u043a\3\2\2\2\u043c\u043d\3\2\2\2\u043d"+
"\u043f\3\2\2\2\u043e\u043c\3\2\2\2\u043f\u0441\5\u01f4\u00fb\2\u0440\u0442"+
"\5*\26\2\u0441\u0440\3\2\2\2\u0441\u0442\3\2\2\2\u0442\u0095\3\2\2\2\u0443"+
"\u0445\5\u01f4\u00fb\2\u0444\u0446\5*\26\2\u0445\u0444\3\2\2\2\u0445\u0446"+
"\3\2\2\2\u0446\u0097\3\2\2\2\u0447\u0448\5\u0092J\2\u0448\u0099\3\2\2"+
"\2\u0449\u044a\5\u0094K\2\u044a\u009b\3\2\2\2\u044b\u044c\5\u0096L\2\u044c"+
"\u009d\3\2\2\2\u044d\u044e\5\u01f4\u00fb\2\u044e\u009f\3\2\2\2\u044f\u0450"+
"\5\u008cG\2\u0450\u0451\5 \21\2\u0451\u0459\3\2\2\2\u0452\u0453\5\u0090"+
"I\2\u0453\u0454\5 \21\2\u0454\u0459\3\2\2\2\u0455\u0456\5\u009eP\2\u0456"+
"\u0457\5 \21\2\u0457\u0459\3\2\2\2\u0458\u044f\3\2\2\2\u0458\u0452\3\2"+
"\2\2\u0458\u0455\3\2\2\2\u0459\u00a1\3\2\2\2\u045a\u045c\5\u00a4S\2\u045b"+
"\u045a\3\2\2\2\u045c\u045f\3\2\2\2\u045d\u045b\3\2\2\2\u045d\u045e\3\2"+
"\2\2\u045e\u0460\3\2\2\2\u045f\u045d\3\2\2\2\u0460\u0461\5\u00a6T\2\u0461"+
"\u0462\5\u00be`\2\u0462\u00a3\3\2\2\2\u0463\u046e\5\u00fc\177\2\u0464"+
"\u046e\7/\2\2\u0465\u046e\7.\2\2\u0466\u046e\7-\2\2\u0467\u046e\7\r\2"+
"\2\u0468\u046e\7\62\2\2\u0469\u046e\7\36\2\2\u046a\u046e\7\66\2\2\u046b"+
"\u046e\7*\2\2\u046c\u046e\7\63\2\2\u046d\u0463\3\2\2\2\u046d\u0464\3\2"+
"\2\2\u046d\u0465\3\2\2\2\u046d\u0466\3\2\2\2\u046d\u0467\3\2\2\2\u046d"+
"\u0468\3\2\2\2\u046d\u0469\3\2\2\2\u046d\u046a\3\2\2\2\u046d\u046b\3\2"+
"\2\2\u046d\u046c\3\2\2\2\u046e\u00a5\3\2\2\2\u046f\u0470\5\u00a8U\2\u0470"+
"\u0472\5\u00aaV\2\u0471\u0473\5\u00b8]\2\u0472\u0471\3\2\2\2\u0472\u0473"+
"\3\2\2\2\u0473\u0481\3\2\2\2\u0474\u0478\5n8\2\u0475\u0477\5\u00fc\177"+
"\2\u0476\u0475\3\2\2\2\u0477\u047a\3\2\2\2\u0478\u0476\3\2\2\2\u0478\u0479"+
"\3\2\2\2\u0479\u047b\3\2\2\2\u047a\u0478\3\2\2\2\u047b\u047c\5\u00a8U"+
"\2\u047c\u047e\5\u00aaV\2\u047d\u047f\5\u00b8]\2\u047e\u047d\3\2\2\2\u047e"+
"\u047f\3\2\2\2\u047f\u0481\3\2\2\2\u0480\u046f\3\2\2\2\u0480\u0474\3\2"+
"\2\2\u0481\u00a7\3\2\2\2\u0482\u0485\5\u008aF\2\u0483\u0485\7<\2\2\u0484"+
"\u0482\3\2\2\2\u0484\u0483\3\2\2\2\u0485\u00a9\3\2\2\2\u0486\u0487\5\u01f4"+
"\u00fb\2\u0487\u0489\7F\2\2\u0488\u048a\5\u00acW\2\u0489\u0488\3\2\2\2"+
"\u0489\u048a\3\2\2\2\u048a\u048b\3\2\2\2\u048b\u048d\7G\2\2\u048c\u048e"+
"\5 \21\2\u048d\u048c\3\2\2\2\u048d\u048e\3\2\2\2\u048e\u00ab\3\2\2\2\u048f"+
"\u0490\5\u00aeX\2\u0490\u0491\7M\2\2\u0491\u0492\5\u00b4[\2\u0492\u0496"+
"\3\2\2\2\u0493\u0496\5\u00b4[\2\u0494\u0496\5\u00b6\\\2\u0495\u048f\3"+
"\2\2\2\u0495\u0493\3\2\2\2\u0495\u0494\3\2\2\2\u0496\u00ad\3\2\2\2\u0497"+
"\u049c\5\u00b0Y\2\u0498\u0499\7M\2\2\u0499\u049b\5\u00b0Y\2\u049a\u0498"+
"\3\2\2\2\u049b\u049e\3\2\2\2\u049c\u049a\3\2\2\2\u049c\u049d\3\2\2\2\u049d"+
"\u04a8\3\2\2\2\u049e\u049c\3\2\2\2\u049f\u04a4\5\u00b6\\\2\u04a0\u04a1"+
"\7M\2\2\u04a1\u04a3\5\u00b0Y\2\u04a2\u04a0\3\2\2\2\u04a3\u04a6\3\2\2\2"+
"\u04a4\u04a2\3\2\2\2\u04a4\u04a5\3\2\2\2\u04a5\u04a8\3\2\2\2\u04a6\u04a4"+
"\3\2\2\2\u04a7\u0497\3\2\2\2\u04a7\u049f\3\2\2\2\u04a8\u00af\3\2\2\2\u04a9"+
"\u04ab\5\u00b2Z\2\u04aa\u04a9\3\2\2\2\u04ab\u04ae\3\2\2\2\u04ac\u04aa"+
"\3\2\2\2\u04ac\u04ad\3\2\2\2\u04ad\u04af\3\2\2\2\u04ae\u04ac\3\2\2\2\u04af"+
"\u04b0\5\u008aF\2\u04b0\u04b1\5\u0086D\2\u04b1\u00b1\3\2\2\2\u04b2\u04b5"+
"\5\u00fc\177\2\u04b3\u04b5\7\36\2\2\u04b4\u04b2\3\2\2\2\u04b4\u04b3\3"+
"\2\2\2\u04b5\u00b3\3\2\2\2\u04b6\u04b8\5\u00b2Z\2\u04b7\u04b6\3\2\2\2"+
"\u04b8\u04bb\3\2\2\2\u04b9\u04b7\3\2\2\2\u04b9\u04ba\3\2\2\2\u04ba\u04bc"+
"\3\2\2\2\u04bb\u04b9\3\2\2\2\u04bc\u04c0\5\u008aF\2\u04bd\u04bf\5\u00fc"+
"\177\2\u04be\u04bd\3\2\2\2\u04bf\u04c2\3\2\2\2\u04c0\u04be\3\2\2\2\u04c0"+
"\u04c1\3\2\2\2\u04c1\u04c3\3\2\2\2\u04c2\u04c0\3\2\2\2\u04c3\u04c4\7O"+
"\2\2\u04c4\u04c5\5\u0086D\2\u04c5\u04c8\3\2\2\2\u04c6\u04c8\5\u00b0Y\2"+
"\u04c7\u04b9\3\2\2\2\u04c7\u04c6\3\2\2\2\u04c8\u00b5\3\2\2\2\u04c9\u04cb"+
"\5\u00fc\177\2\u04ca\u04c9\3\2\2\2\u04cb\u04ce\3\2\2\2\u04cc\u04ca\3\2"+
"\2\2\u04cc\u04cd\3\2\2\2\u04cd\u04cf\3\2\2\2\u04ce\u04cc\3\2\2\2\u04cf"+
"\u04d3\5\u008aF\2\u04d0\u04d1\5\u01f4\u00fb\2\u04d1\u04d2\7N\2\2\u04d2"+
"\u04d4\3\2\2\2\u04d3\u04d0\3\2\2\2\u04d3\u04d4\3\2\2\2\u04d4\u04d5\3\2"+
"\2\2\u04d5\u04d6\7\67\2\2\u04d6\u00b7\3\2\2\2\u04d7\u04d8\79\2\2\u04d8"+
"\u04d9\5\u00ba^\2\u04d9\u00b9\3\2\2\2\u04da\u04df\5\u00bc_\2\u04db\u04dc"+
"\7M\2\2\u04dc\u04de\5\u00bc_\2\u04dd\u04db\3\2\2\2\u04de\u04e1\3\2\2\2"+
"\u04df\u04dd\3\2\2\2\u04df\u04e0\3\2\2\2\u04e0\u00bb\3\2\2\2\u04e1\u04df"+
"\3\2\2\2\u04e2\u04e5\5\20\t\2\u04e3\u04e5\5\34\17\2\u04e4\u04e2\3\2\2"+
"\2\u04e4\u04e3\3\2\2\2\u04e5\u00bd\3\2\2\2\u04e6\u04e9\5\u0112\u008a\2"+
"\u04e7\u04e9\7L\2\2\u04e8\u04e6\3\2\2\2\u04e8\u04e7\3\2\2\2\u04e9\u00bf"+
"\3\2\2\2\u04ea\u04eb\5\u0112\u008a\2\u04eb\u00c1\3\2\2\2\u04ec\u04ed\7"+
"\62\2\2\u04ed\u04ee\5\u0112\u008a\2\u04ee\u00c3\3\2\2\2\u04ef\u04f1\5"+
"\u00c6d\2\u04f0\u04ef\3\2\2\2\u04f1\u04f4\3\2\2\2\u04f2\u04f0\3\2\2\2"+
"\u04f2\u04f3\3\2\2\2\u04f3\u04f5\3\2\2\2\u04f4\u04f2\3\2\2\2\u04f5\u04f7"+
"\5\u00c8e\2\u04f6\u04f8\5\u00b8]\2\u04f7\u04f6\3\2\2\2\u04f7\u04f8\3\2"+
"\2\2\u04f8\u04f9\3\2\2\2\u04f9\u04fa\5\u00ccg\2\u04fa\u00c5\3\2\2\2\u04fb"+
"\u0500\5\u00fc\177\2\u04fc\u0500\7/\2\2\u04fd\u0500\7.\2\2\u04fe\u0500"+
"\7-\2\2\u04ff\u04fb\3\2\2\2\u04ff\u04fc\3\2\2\2\u04ff\u04fd\3\2\2\2\u04ff"+
"\u04fe\3\2\2\2\u0500\u00c7\3\2\2\2\u0501\u0503\5n8\2\u0502\u0501\3\2\2"+
"\2\u0502\u0503\3\2\2\2\u0503\u0504\3\2\2\2\u0504\u0505\5\u00caf\2\u0505"+
"\u0507\7F\2\2\u0506\u0508\5\u00acW\2\u0507\u0506\3\2\2\2\u0507\u0508\3"+
"\2\2\2\u0508\u0509\3\2\2\2\u0509\u050a\7G\2\2\u050a\u00c9\3\2\2\2\u050b"+
"\u050c\5\u01f4\u00fb\2\u050c\u00cb\3\2\2\2\u050d\u050f\7H\2\2\u050e\u0510"+
"\5\u00ceh\2\u050f\u050e\3\2\2\2\u050f\u0510\3\2\2\2\u0510\u0512\3\2\2"+
"\2\u0511\u0513\5\u0114\u008b\2\u0512\u0511\3\2\2\2\u0512\u0513\3\2\2\2"+
"\u0513\u0514\3\2\2\2\u0514\u0515\7I\2\2\u0515\u00cd\3\2\2\2\u0516\u0518"+
"\5*\26\2\u0517\u0516\3\2\2\2\u0517\u0518\3\2\2\2\u0518\u0519\3\2\2\2\u0519"+
"\u051a\7\67\2\2\u051a\u051c\7F\2\2\u051b\u051d\5\u01a8\u00d5\2\u051c\u051b"+
"\3\2\2\2\u051c\u051d\3\2\2\2\u051d\u051e\3\2\2\2\u051e\u051f\7G\2\2\u051f"+
"\u0545\7L\2\2\u0520\u0522\5*\26\2\u0521\u0520\3\2\2\2\u0521\u0522\3\2"+
"\2\2\u0522\u0523\3\2\2\2\u0523\u0524\7\64\2\2\u0524\u0526\7F\2\2\u0525"+
"\u0527\5\u01a8\u00d5\2\u0526\u0525\3\2\2\2\u0526\u0527\3\2\2\2\u0527\u0528"+
"\3\2\2\2\u0528\u0529\7G\2\2\u0529\u0545\7L\2\2\u052a\u052b\5<\37\2\u052b"+
"\u052d\7N\2\2\u052c\u052e\5*\26\2\u052d\u052c\3\2\2\2\u052d\u052e\3\2"+
"\2\2\u052e\u052f\3\2\2\2\u052f\u0530\7\64\2\2\u0530\u0532\7F\2\2\u0531"+
"\u0533\5\u01a8\u00d5\2\u0532\u0531\3\2\2\2\u0532\u0533\3\2\2\2\u0533\u0534"+
"\3\2\2\2\u0534\u0535\7G\2\2\u0535\u0536\7L\2\2\u0536\u0545\3\2\2\2\u0537"+
"\u0538\5\u0178\u00bd\2\u0538\u053a\7N\2\2\u0539\u053b\5*\26\2\u053a\u0539"+
"\3\2\2\2\u053a\u053b\3\2\2\2\u053b\u053c\3\2\2\2\u053c\u053d\7\64\2\2"+
"\u053d\u053f\7F\2\2\u053e\u0540\5\u01a8\u00d5\2\u053f\u053e\3\2\2\2\u053f"+
"\u0540\3\2\2\2\u0540\u0541\3\2\2\2\u0541\u0542\7G\2\2\u0542\u0543\7L\2"+
"\2\u0543\u0545\3\2\2\2\u0544\u0517\3\2\2\2\u0544\u0521\3\2\2\2\u0544\u052a"+
"\3\2\2\2\u0544\u0537\3\2\2\2\u0545\u00cf\3\2\2\2\u0546\u0548\5l\67\2\u0547"+
"\u0546\3\2\2\2\u0548\u054b\3\2\2\2\u0549\u0547\3\2\2\2\u0549\u054a\3\2"+
"\2\2\u054a\u054c\3\2\2\2\u054b\u0549\3\2\2\2\u054c\u054d\7\34\2\2\u054d"+
"\u054f\5\u01f4\u00fb\2\u054e\u0550\5t;\2\u054f\u054e\3\2\2\2\u054f\u0550"+
"\3\2\2\2\u0550\u0551\3\2\2\2\u0551\u0552\5\u00d2j\2\u0552\u00d1\3\2\2"+
"\2\u0553\u0555\7H\2\2\u0554\u0556\5\u00d4k\2\u0555\u0554\3\2\2\2\u0555"+
"\u0556\3\2\2\2\u0556\u0558\3\2\2\2\u0557\u0559\7M\2\2\u0558\u0557\3\2"+
"\2\2\u0558\u0559\3\2\2\2\u0559\u055b\3\2\2\2\u055a\u055c\5\u00dan\2\u055b"+
"\u055a\3\2\2\2\u055b\u055c\3\2\2\2\u055c\u055d\3\2\2\2\u055d\u055e\7I"+
"\2\2\u055e\u00d3\3\2\2\2\u055f\u0564\5\u00d6l\2\u0560\u0561\7M\2\2\u0561"+
"\u0563\5\u00d6l\2\u0562\u0560\3\2\2\2\u0563\u0566\3\2\2\2\u0564\u0562"+
"\3\2\2\2\u0564\u0565\3\2\2\2\u0565\u00d5\3\2\2\2\u0566\u0564\3\2\2\2\u0567"+
"\u0569\5\u00d8m\2\u0568\u0567\3\2\2\2\u0569\u056c\3\2\2\2\u056a\u0568"+
"\3\2\2\2\u056a\u056b\3\2\2\2\u056b\u056d\3\2\2\2\u056c\u056a\3\2\2\2\u056d"+
"\u0573\5\u01f4\u00fb\2\u056e\u0570\7F\2\2\u056f\u0571\5\u01a8\u00d5\2"+
"\u0570\u056f\3\2\2\2\u0570\u0571\3\2\2\2\u0571\u0572\3\2\2\2\u0572\u0574"+
"\7G\2\2\u0573\u056e\3\2\2\2\u0573\u0574\3\2\2\2\u0574\u0576\3\2\2\2\u0575"+
"\u0577\5x=\2\u0576\u0575\3\2\2\2\u0576\u0577\3\2\2\2\u0577\u00d7\3\2\2"+
"\2\u0578\u0579\5\u00fc\177\2\u0579\u00d9\3\2\2\2\u057a\u057e\7L\2\2\u057b"+
"\u057d\5z>\2\u057c\u057b\3\2\2\2\u057d\u0580\3\2\2\2\u057e\u057c\3\2\2"+
"\2\u057e\u057f\3\2\2\2\u057f\u00db\3\2\2\2\u0580\u057e\3\2\2\2\u0581\u0584"+
"\5\u00dep\2\u0582\u0584\5\u00f0y\2\u0583\u0581\3\2\2\2\u0583\u0582\3\2"+
"\2\2\u0584\u00dd\3\2\2\2\u0585\u0587\5\u00e0q\2\u0586\u0585\3\2\2\2\u0587"+
"\u058a\3\2\2\2\u0588\u0586\3\2\2\2\u0588\u0589\3\2\2\2\u0589\u058b\3\2"+
"\2\2\u058a\u0588\3\2\2\2\u058b\u058c\7(\2\2\u058c\u058e\5\u01f4\u00fb"+
"\2\u058d\u058f\5n8\2\u058e\u058d\3\2\2\2\u058e\u058f\3\2\2\2\u058f\u0591"+
"\3\2\2\2\u0590\u0592\5\u00e2r\2\u0591\u0590\3\2\2\2\u0591\u0592\3\2\2"+
"\2\u0592\u0593\3\2\2\2\u0593\u0594\5\u00e4s\2\u0594\u00df\3\2\2\2\u0595"+
"\u059d\5\u00fc\177\2\u0596\u059d\7/\2\2\u0597\u059d\7.\2\2\u0598\u059d"+
"\7-\2\2\u0599\u059d\7\r\2\2\u059a\u059d\7\62\2\2\u059b\u059d\7\63\2\2"+
"\u059c\u0595\3\2\2\2\u059c\u0596\3\2\2\2\u059c\u0597\3\2\2\2\u059c\u0598"+
"\3\2\2\2\u059c\u0599\3\2\2\2\u059c\u059a\3\2\2\2\u059c\u059b\3\2\2\2\u059d"+
"\u00e1\3\2\2\2\u059e\u059f\7\35\2\2\u059f\u05a0\5v<\2\u05a0\u00e3\3\2"+
"\2\2\u05a1\u05a5\7H\2\2\u05a2\u05a4\5\u00e6t\2\u05a3\u05a2\3\2\2\2\u05a4"+
"\u05a7\3\2\2\2\u05a5\u05a3\3\2\2\2\u05a5\u05a6\3\2\2\2\u05a6\u05a8\3\2"+
"\2\2\u05a7\u05a5\3\2\2\2\u05a8\u05a9\7I\2\2\u05a9\u00e5\3\2\2\2\u05aa"+
"\u05b0\5\u00e8u\2\u05ab\u05b0\5\u00ecw\2\u05ac\u05b0\5h\65\2\u05ad\u05b0"+
"\5\u00dco\2\u05ae\u05b0\7L\2\2\u05af\u05aa\3\2\2\2\u05af\u05ab\3\2\2\2"+
"\u05af\u05ac\3\2\2\2\u05af\u05ad\3\2\2\2\u05af\u05ae\3\2\2\2\u05b0\u00e7"+
"\3\2\2\2\u05b1\u05b3\5\u00eav\2\u05b2\u05b1\3\2\2\2\u05b3\u05b6\3\2\2"+
"\2\u05b4\u05b2\3\2\2\2\u05b4\u05b5\3\2\2\2\u05b5\u05b7\3\2\2\2\u05b6\u05b4"+
"\3\2\2\2\u05b7\u05b8\5\u008aF\2\u05b8\u05b9\5\u0082B\2\u05b9\u05ba\7L"+
"\2\2\u05ba\u00e9\3\2\2\2\u05bb\u05c0\5\u00fc\177\2\u05bc\u05c0\7/\2\2"+
"\u05bd\u05c0\7\62\2\2\u05be\u05c0\7\36\2\2\u05bf\u05bb\3\2\2\2\u05bf\u05bc"+
"\3\2\2\2\u05bf\u05bd\3\2\2\2\u05bf\u05be\3\2\2\2\u05c0\u00eb\3\2\2\2\u05c1"+
"\u05c3\5\u00eex\2\u05c2\u05c1\3\2\2\2\u05c3\u05c6\3\2\2\2\u05c4\u05c2"+
"\3\2\2\2\u05c4\u05c5\3\2\2\2\u05c5\u05c7\3\2\2\2\u05c6\u05c4\3\2\2\2\u05c7"+
"\u05c8\5\u00a6T\2\u05c8\u05c9\5\u00be`\2\u05c9\u00ed\3\2\2\2\u05ca\u05d2"+
"\5\u00fc\177\2\u05cb\u05d2\7/\2\2\u05cc\u05d2\7-\2\2\u05cd\u05d2\7\r\2"+
"\2\u05ce\u05d2\7\30\2\2\u05cf\u05d2\7\62\2\2\u05d0\u05d2\7\63\2\2\u05d1"+
"\u05ca\3\2\2\2\u05d1\u05cb\3\2\2\2\u05d1\u05cc\3\2\2\2\u05d1\u05cd\3\2"+
"\2\2\u05d1\u05ce\3\2\2\2\u05d1\u05cf\3\2\2\2\u05d1\u05d0\3\2\2\2\u05d2"+
"\u00ef\3\2\2\2\u05d3\u05d5\5\u00e0q\2\u05d4\u05d3\3\2\2\2\u05d5\u05d8"+
"\3\2\2\2\u05d6\u05d4\3\2\2\2\u05d6\u05d7\3\2\2\2\u05d7\u05d9\3\2\2\2\u05d8"+
"\u05d6\3\2\2\2\u05d9\u05da\7P\2\2\u05da\u05db\7(\2\2\u05db\u05dc\5\u01f4"+
"\u00fb\2\u05dc\u05dd\5\u00f2z\2\u05dd\u00f1\3\2\2\2\u05de\u05e2\7H\2\2"+
"\u05df\u05e1\5\u00f4{\2\u05e0\u05df\3\2\2\2\u05e1\u05e4\3\2\2\2\u05e2"+
"\u05e0\3\2\2\2\u05e2\u05e3\3\2\2\2\u05e3\u05e5\3\2\2\2\u05e4\u05e2\3\2"+
"\2\2\u05e5\u05e6\7I\2\2\u05e6\u00f3\3\2\2\2\u05e7\u05ed\5\u00f6|\2\u05e8"+
"\u05ed\5\u00e8u\2\u05e9\u05ed\5h\65\2\u05ea\u05ed\5\u00dco\2\u05eb\u05ed"+
"\7L\2\2\u05ec\u05e7\3\2\2\2\u05ec\u05e8\3\2\2\2\u05ec\u05e9\3\2\2\2\u05ec"+
"\u05ea\3\2\2\2\u05ec\u05eb\3\2\2\2\u05ed\u00f5\3\2\2\2\u05ee\u05f0\5\u00f8"+
"}\2\u05ef\u05ee\3\2\2\2\u05f0\u05f3\3\2\2\2\u05f1\u05ef\3\2\2\2\u05f1"+
"\u05f2\3\2\2\2\u05f2\u05f4\3\2\2\2\u05f3\u05f1\3\2\2\2\u05f4\u05f5\5\u008a"+
"F\2\u05f5\u05f6\5\u01f4\u00fb\2\u05f6\u05f7\7F\2\2\u05f7\u05f9\7G\2\2"+
"\u05f8\u05fa\5 \21\2\u05f9\u05f8\3\2\2\2\u05f9\u05fa\3\2\2\2\u05fa\u05fc"+
"\3\2\2\2\u05fb\u05fd\5\u00fa~\2\u05fc\u05fb\3\2\2\2\u05fc\u05fd\3\2\2"+
"\2\u05fd\u05fe\3\2\2\2\u05fe\u05ff\7L\2\2\u05ff\u00f7\3\2\2\2\u0600\u0604"+
"\5\u00fc\177\2\u0601\u0604\7/\2\2\u0602\u0604\7\r\2\2\u0603\u0600\3\2"+
"\2\2\u0603\u0601\3\2\2\2\u0603\u0602\3\2\2\2\u0604\u00f9\3\2\2\2\u0605"+
"\u0606\7\30\2\2\u0606\u0607\5\u0104\u0083\2\u0607\u00fb\3\2\2\2\u0608"+
"\u060c\5\u00fe\u0080\2\u0609\u060c\5\u010a\u0086\2\u060a\u060c\5\u010c"+
"\u0087\2\u060b\u0608\3\2\2\2\u060b\u0609\3\2\2\2\u060b\u060a\3\2\2\2\u060c"+
"\u00fd\3\2\2\2\u060d\u060e\7P\2\2\u060e\u060f\58\35\2\u060f\u0611\7F\2"+
"\2\u0610\u0612\5\u0100\u0081\2\u0611\u0610\3\2\2\2\u0611\u0612\3\2\2\2"+
"\u0612\u0613\3\2\2\2\u0613\u0614\7G\2\2\u0614\u00ff\3\2\2\2\u0615\u061a"+
"\5\u0102\u0082\2\u0616\u0617\7M\2\2\u0617\u0619\5\u0102\u0082\2\u0618"+
"\u0616\3\2\2\2\u0619\u061c\3\2\2\2\u061a\u0618\3\2\2\2\u061a\u061b\3\2"+
"\2\2\u061b\u0101\3\2\2\2\u061c\u061a\3\2\2\2\u061d\u061e\5\u01f4\u00fb"+
"\2\u061e\u061f\7R\2\2\u061f\u0620\5\u0104\u0083\2\u0620\u0103\3\2\2\2"+
"\u0621\u0625\5\u01ca\u00e6\2\u0622\u0625\5\u0106\u0084\2\u0623\u0625\5"+
"\u00fc\177\2\u0624\u0621\3\2\2\2\u0624\u0622\3\2\2\2\u0624\u0623\3\2\2"+
"\2\u0625\u0105\3\2\2\2\u0626\u0628\7H\2\2\u0627\u0629\5\u0108\u0085\2"+
"\u0628\u0627\3\2\2\2\u0628\u0629\3\2\2\2\u0629\u062b\3\2\2\2\u062a\u062c"+
"\7M\2\2\u062b\u062a\3\2\2\2\u062b\u062c\3\2\2\2\u062c\u062d\3\2\2\2\u062d"+
"\u062e\7I\2\2\u062e\u0107\3\2\2\2\u062f\u0634\5\u0104\u0083\2\u0630\u0631"+
"\7M\2\2\u0631\u0633\5\u0104\u0083\2\u0632\u0630\3\2\2\2\u0633\u0636\3"+
"\2\2\2\u0634\u0632\3\2\2\2\u0634\u0635\3\2\2\2\u0635\u0109\3\2\2\2\u0636"+
"\u0634\3\2\2\2\u0637\u0638\7P\2\2\u0638\u0639\58\35\2\u0639\u010b\3\2"+
"\2\2\u063a\u063b\7P\2\2\u063b\u063c\58\35\2\u063c\u063d\7F\2\2\u063d\u063e"+
"\5\u0104\u0083\2\u063e\u063f\7G\2\2\u063f\u010d\3\2\2\2\u0640\u0642\7"+
"H\2\2\u0641\u0643\5\u0110\u0089\2\u0642\u0641\3\2\2\2\u0642\u0643\3\2"+
"\2\2\u0643\u0645\3\2\2\2\u0644\u0646\7M\2\2\u0645\u0644\3\2\2\2\u0645"+
"\u0646\3\2\2\2\u0646\u0647\3\2\2\2\u0647\u0648\7I\2\2\u0648\u010f\3\2"+
"\2\2\u0649\u064e\5\u0088E\2\u064a\u064b\7M\2\2\u064b\u064d\5\u0088E\2"+
"\u064c\u064a\3\2\2\2\u064d\u0650\3\2\2\2\u064e\u064c\3\2\2\2\u064e\u064f"+
"\3\2\2\2\u064f\u0111\3\2\2\2\u0650\u064e\3\2\2\2\u0651\u0653\7H\2\2\u0652"+
"\u0654\5\u0114\u008b\2\u0653\u0652\3\2\2\2\u0653\u0654\3\2\2\2\u0654\u0655"+
"\3\2\2\2\u0655\u0656\7I\2\2\u0656\u0113\3\2\2\2\u0657\u0659\5\u0116\u008c"+
"\2\u0658\u0657\3\2\2\2\u0659\u065a\3\2\2\2\u065a\u0658\3\2\2\2\u065a\u065b"+
"\3\2\2\2\u065b\u0115\3\2\2\2\u065c\u0660\5\u0118\u008d\2\u065d\u0660\5"+
"h\65\2\u065e\u0660\5\u011c\u008f\2\u065f\u065c\3\2\2\2\u065f\u065d\3\2"+
"\2\2\u065f\u065e\3\2\2\2\u0660\u0117\3\2\2\2\u0661\u0662\5\u011a\u008e"+
"\2\u0662\u0663\7L\2\2\u0663\u0119\3\2\2\2\u0664\u0666\5\u00b2Z\2\u0665"+
"\u0664\3\2\2\2\u0666\u0669\3\2\2\2\u0667\u0665\3\2\2\2\u0667\u0668\3\2"+
"\2\2\u0668\u066a\3\2\2\2\u0669\u0667\3\2\2\2\u066a\u066b\5\u008aF\2\u066b"+
"\u066c\5\u0082B\2\u066c\u011b\3\2\2\2\u066d\u0674\5\u0120\u0091\2\u066e"+
"\u0674\5\u0124\u0093\2\u066f\u0674\5\u012c\u0097\2\u0670\u0674\5\u012e"+
"\u0098\2\u0671\u0674\5\u0140\u00a1\2\u0672\u0674\5\u0146\u00a4\2\u0673"+
"\u066d\3\2\2\2\u0673\u066e\3\2\2\2\u0673\u066f\3\2\2\2\u0673\u0670\3\2"+
"\2\2\u0673\u0671\3\2\2\2\u0673\u0672\3\2\2\2\u0674\u011d\3\2\2\2\u0675"+
"\u067b\5\u0120\u0091\2\u0676\u067b\5\u0126\u0094\2\u0677\u067b\5\u0130"+
"\u0099\2\u0678\u067b\5\u0142\u00a2\2\u0679\u067b\5\u0148\u00a5\2\u067a"+
"\u0675\3\2\2\2\u067a\u0676\3\2\2\2\u067a\u0677\3\2\2\2\u067a\u0678\3\2"+
"\2\2\u067a\u0679\3\2\2\2\u067b\u011f\3\2\2\2\u067c\u0689\5\u0112\u008a"+
"\2\u067d\u0689\5\u0122\u0092\2\u067e\u0689\5\u0128\u0095\2\u067f\u0689"+
"\5\u0132\u009a\2\u0680\u0689\5\u0134\u009b\2\u0681\u0689\5\u0144\u00a3"+
"\2\u0682\u0689\5\u0158\u00ad\2\u0683\u0689\5\u015a\u00ae\2\u0684\u0689"+
"\5\u015c\u00af\2\u0685\u0689\5\u0160\u00b1\2\u0686\u0689\5\u015e\u00b0"+
"\2\u0687\u0689\5\u0162\u00b2\2\u0688\u067c\3\2\2\2\u0688\u067d\3\2\2\2"+
"\u0688\u067e\3\2\2\2\u0688\u067f\3\2\2\2\u0688\u0680\3\2\2\2\u0688\u0681"+
"\3\2\2\2\u0688\u0682\3\2\2\2\u0688\u0683\3\2\2\2\u0688\u0684\3\2\2\2\u0688"+
"\u0685\3\2\2\2\u0688\u0686\3\2\2\2\u0688\u0687\3\2\2\2\u0689\u0121\3\2"+
"\2\2\u068a\u068b\7L\2\2\u068b\u0123\3\2\2\2\u068c\u068d\5\u01f4\u00fb"+
"\2\u068d\u068e\7X\2\2\u068e\u068f\5\u011c\u008f\2\u068f\u0125\3\2\2\2"+
"\u0690\u0691\5\u01f4\u00fb\2\u0691\u0692\7X\2\2\u0692\u0693\5\u011e\u0090"+
"\2\u0693\u0127\3\2\2\2\u0694\u0695\5\u012a\u0096\2\u0695\u0696\7L\2\2"+
"\u0696\u0129\3\2\2\2\u0697\u069f\5\u01c4\u00e3\2\u0698\u069f\5\u01e2\u00f2"+
"\2\u0699\u069f\5\u01e4\u00f3\2\u069a\u069f\5\u01ea\u00f6\2\u069b\u069f"+
"\5\u01ee\u00f8\2\u069c\u069f\5\u01a2\u00d2\2\u069d\u069f\5\u018e\u00c8"+
"\2\u069e\u0697\3\2\2\2\u069e\u0698\3\2\2\2\u069e\u0699\3\2\2\2\u069e\u069a"+
"\3\2\2\2\u069e\u069b\3\2\2\2\u069e\u069c\3\2\2\2\u069e\u069d\3\2\2\2\u069f"+
"\u012b\3\2\2\2\u06a0\u06a1\7\"\2\2\u06a1\u06a2\7F\2\2\u06a2\u06a3\5\u01b8"+
"\u00dd\2\u06a3\u06a4\7G\2\2\u06a4\u06a5\5\u011c\u008f\2\u06a5\u012d\3"+
"\2\2\2\u06a6\u06a7\7\"\2\2\u06a7\u06a8\7F\2\2\u06a8\u06a9\5\u01b8\u00dd"+
"\2\u06a9\u06aa\7G\2\2\u06aa\u06ab\5\u011e\u0090\2\u06ab\u06ac\7\33\2\2"+
"\u06ac\u06ad\5\u011c\u008f\2\u06ad\u012f\3\2\2\2\u06ae\u06af\7\"\2\2\u06af"+
"\u06b0\7F\2\2\u06b0\u06b1\5\u01b8\u00dd\2\u06b1\u06b2\7G\2\2\u06b2\u06b3"+
"\5\u011e\u0090\2\u06b3\u06b4\7\33\2\2\u06b4\u06b5\5\u011e\u0090\2\u06b5"+
"\u0131\3\2\2\2\u06b6\u06b7\7\16\2\2\u06b7\u06b8\5\u01b8\u00dd\2\u06b8"+
"\u06b9\7L\2\2\u06b9\u06c1\3\2\2\2\u06ba\u06bb\7\16\2\2\u06bb\u06bc\5\u01b8"+
"\u00dd\2\u06bc\u06bd\7X\2\2\u06bd\u06be\5\u01b8\u00dd\2\u06be\u06bf\7"+
"L\2\2\u06bf\u06c1\3\2\2\2\u06c0\u06b6\3\2\2\2\u06c0\u06ba\3\2\2\2\u06c1"+
"\u0133\3\2\2\2\u06c2\u06c3\7\65\2\2\u06c3\u06c4\7F\2\2\u06c4\u06c5\5\u01b8"+
"\u00dd\2\u06c5\u06c6\7G\2\2\u06c6\u06c7\5\u0136\u009c\2\u06c7\u0135\3"+
"\2\2\2\u06c8\u06cc\7H\2\2\u06c9\u06cb\5\u0138\u009d\2\u06ca\u06c9\3\2"+
"\2\2\u06cb\u06ce\3\2\2\2\u06cc\u06ca\3\2\2\2\u06cc\u06cd\3\2\2\2\u06cd"+
"\u06d2\3\2\2\2\u06ce\u06cc\3\2\2\2\u06cf\u06d1\5\u013c\u009f\2\u06d0\u06cf"+
"\3\2\2\2\u06d1\u06d4\3\2\2\2\u06d2\u06d0\3\2\2\2\u06d2\u06d3\3\2\2\2\u06d3"+
"\u06d5\3\2\2\2\u06d4\u06d2\3\2\2\2\u06d5\u06d6\7I\2\2\u06d6\u0137\3\2"+
"\2\2\u06d7\u06d8\5\u013a\u009e\2\u06d8\u06d9\5\u0114\u008b\2\u06d9\u0139"+
"\3\2\2\2\u06da\u06dc\5\u013c\u009f\2\u06db\u06da\3\2\2\2\u06dc\u06dd\3"+
"\2\2\2\u06dd\u06db\3\2\2\2\u06dd\u06de\3\2\2\2\u06de\u013b\3\2\2\2\u06df"+
"\u06e0\7\22\2\2\u06e0\u06e1\5\u01b6\u00dc\2\u06e1\u06e2\7X\2\2\u06e2\u06ea"+
"\3\2\2\2\u06e3\u06e4\7\22\2\2\u06e4\u06e5\5\u013e\u00a0\2\u06e5\u06e6"+
"\7X\2\2\u06e6\u06ea\3\2\2\2\u06e7\u06e8\7\30\2\2\u06e8\u06ea\7X\2\2\u06e9"+
"\u06df\3\2\2\2\u06e9\u06e3\3\2\2\2\u06e9\u06e7\3\2\2\2\u06ea\u013d\3\2"+
"\2\2\u06eb\u06ec\5\u01f4\u00fb\2\u06ec\u013f\3\2\2\2\u06ed\u06ee\7>\2"+
"\2\u06ee\u06ef\7F\2\2\u06ef\u06f0\5\u01b8\u00dd\2\u06f0\u06f1\7G\2\2\u06f1"+
"\u06f2\5\u011c\u008f\2\u06f2\u0141\3\2\2\2\u06f3\u06f4\7>\2\2\u06f4\u06f5"+
"\7F\2\2\u06f5\u06f6\5\u01b8\u00dd\2\u06f6\u06f7\7G\2\2\u06f7\u06f8\5\u011e"+
"\u0090\2\u06f8\u0143\3\2\2\2\u06f9\u06fa\7\31\2\2\u06fa\u06fb\5\u011c"+
"\u008f\2\u06fb\u06fc\7>\2\2\u06fc\u06fd\7F\2\2\u06fd\u06fe\5\u01b8\u00dd"+
"\2\u06fe\u06ff\7G\2\2\u06ff\u0700\7L\2\2\u0700\u0145\3\2\2\2\u0701\u0704"+
"\5\u014a\u00a6\2\u0702\u0704\5\u0154\u00ab\2\u0703\u0701\3\2\2\2\u0703"+
"\u0702\3\2\2\2\u0704\u0147\3\2\2\2\u0705\u0708\5\u014c\u00a7\2\u0706\u0708"+
"\5\u0156\u00ac\2\u0707\u0705\3\2\2\2\u0707\u0706\3\2\2\2\u0708\u0149\3"+
"\2\2\2\u0709\u070a\7!\2\2\u070a\u070c\7F\2\2\u070b\u070d\5\u014e\u00a8"+
"\2\u070c\u070b\3\2\2\2\u070c\u070d\3\2\2\2\u070d\u070e\3\2\2\2\u070e\u0710"+
"\7L\2\2\u070f\u0711\5\u01b8\u00dd\2\u0710\u070f\3\2\2\2\u0710\u0711\3"+
"\2\2\2\u0711\u0712\3\2\2\2\u0712\u0714\7L\2\2\u0713\u0715\5\u0150\u00a9"+
"\2\u0714\u0713\3\2\2\2\u0714\u0715\3\2\2\2\u0715\u0716\3\2\2\2\u0716\u0717"+
"\7G\2\2\u0717\u0718\5\u011c\u008f\2\u0718\u014b\3\2\2\2\u0719\u071a\7"+
"!\2\2\u071a\u071c\7F\2\2\u071b\u071d\5\u014e\u00a8\2\u071c\u071b\3\2\2"+
"\2\u071c\u071d\3\2\2\2\u071d\u071e\3\2\2\2\u071e\u0720\7L\2\2\u071f\u0721"+
"\5\u01b8\u00dd\2\u0720\u071f\3\2\2\2\u0720\u0721\3\2\2\2\u0721\u0722\3"+
"\2\2\2\u0722\u0724\7L\2\2\u0723\u0725\5\u0150\u00a9\2\u0724\u0723\3\2"+
"\2\2\u0724\u0725\3\2\2\2\u0725\u0726\3\2\2\2\u0726\u0727\7G\2\2\u0727"+
"\u0728\5\u011e\u0090\2\u0728\u014d\3\2\2\2\u0729\u072c\5\u0152\u00aa\2"+
"\u072a\u072c\5\u011a\u008e\2\u072b\u0729\3\2\2\2\u072b\u072a\3\2\2\2\u072c"+
"\u014f\3\2\2\2\u072d\u072e\5\u0152\u00aa\2\u072e\u0151\3\2\2\2\u072f\u0734"+
"\5\u012a\u0096\2\u0730\u0731\7M\2\2\u0731\u0733\5\u012a\u0096\2\u0732"+
"\u0730\3\2\2\2\u0733\u0736\3\2\2\2\u0734\u0732\3\2\2\2\u0734\u0735\3\2"+
"\2\2\u0735\u0153\3\2\2\2\u0736\u0734\3\2\2\2\u0737\u0738\7!\2\2\u0738"+
"\u073c\7F\2\2\u0739\u073b\5\u00b2Z\2\u073a\u0739\3\2\2\2\u073b\u073e\3"+
"\2\2\2\u073c\u073a\3\2\2\2\u073c\u073d\3\2\2\2\u073d\u073f\3\2\2\2\u073e"+
"\u073c\3\2\2\2\u073f\u0740\5\u008aF\2\u0740\u0741\5\u0086D\2\u0741\u0742"+
"\7X\2\2\u0742\u0743\5\u01b8\u00dd\2\u0743\u0744\7G\2\2\u0744\u0745\5\u011c"+
"\u008f\2\u0745\u0155\3\2\2\2\u0746\u0747\7!\2\2\u0747\u074b\7F\2\2\u0748"+
"\u074a\5\u00b2Z\2\u0749\u0748\3\2\2\2\u074a\u074d\3\2\2\2\u074b\u0749"+
"\3\2\2\2\u074b\u074c\3\2\2\2\u074c\u074e\3\2\2\2\u074d\u074b\3\2\2\2\u074e"+
"\u074f\5\u008aF\2\u074f\u0750\5\u0086D\2\u0750\u0751\7X\2\2\u0751\u0752"+
"\5\u01b8\u00dd\2\u0752\u0753\7G\2\2\u0753\u0754\5\u011e\u0090\2\u0754"+
"\u0157\3\2\2\2\u0755\u0757\7\20\2\2\u0756\u0758\5\u01f4\u00fb\2\u0757"+
"\u0756\3\2\2\2\u0757\u0758\3\2\2\2\u0758\u0759\3\2\2\2\u0759\u075a\7L"+
"\2\2\u075a\u0159\3\2\2\2\u075b\u075d\7\27\2\2\u075c\u075e\5\u01f4\u00fb"+
"\2\u075d\u075c\3\2\2\2\u075d\u075e\3\2\2\2\u075e\u075f\3\2\2\2\u075f\u0760"+
"\7L\2\2\u0760\u015b\3\2\2\2\u0761\u0763\7\60\2\2\u0762\u0764\5\u01b8\u00dd"+
"\2\u0763\u0762\3\2\2\2\u0763\u0764\3\2\2\2\u0764\u0765\3\2\2\2\u0765\u0766"+
"\7L\2\2\u0766\u015d\3\2\2\2\u0767\u0768\78\2\2\u0768\u0769\5\u01b8\u00dd"+
"\2\u0769\u076a\7L\2\2\u076a\u015f\3\2\2\2\u076b\u076c\7\66\2\2\u076c\u076d"+
"\7F\2\2\u076d\u076e\5\u01b8\u00dd\2\u076e\u076f\7G\2\2\u076f\u0770\5\u0112"+
"\u008a\2\u0770\u0161\3\2\2\2\u0771\u0772\7;\2\2\u0772\u0773\5\u0112\u008a"+
"\2\u0773\u0774\5\u0164\u00b3\2\u0774\u077e\3\2\2\2\u0775\u0776\7;\2\2"+
"\u0776\u0778\5\u0112\u008a\2\u0777\u0779\5\u0164\u00b3\2\u0778\u0777\3"+
"\2\2\2\u0778\u0779\3\2\2\2\u0779\u077a\3\2\2\2\u077a\u077b\5\u016c\u00b7"+
"\2\u077b\u077e\3\2\2\2\u077c\u077e\5\u016e\u00b8\2\u077d\u0771\3\2\2\2"+
"\u077d\u0775\3\2\2\2\u077d\u077c\3\2\2\2\u077e\u0163\3\2\2\2\u077f\u0781"+
"\5\u0166\u00b4\2\u0780\u077f\3\2\2\2\u0781\u0782\3\2\2\2\u0782\u0780\3"+
"\2\2\2\u0782\u0783\3\2\2\2\u0783\u0165\3\2\2\2\u0784\u0785\7\23\2\2\u0785"+
"\u0786\7F\2\2\u0786\u0787\5\u0168\u00b5\2\u0787\u0788\7G\2\2\u0788\u0789"+
"\5\u0112\u008a\2\u0789\u0167\3\2\2\2\u078a\u078c\5\u00b2Z\2\u078b\u078a"+
"\3\2\2\2\u078c\u078f\3\2\2\2\u078d\u078b\3\2\2\2\u078d\u078e\3\2\2\2\u078e"+
"\u0790\3\2\2\2\u078f\u078d\3\2\2\2\u0790\u0791\5\u016a\u00b6\2\u0791\u0792"+
"\5\u0086D\2\u0792\u0169\3\2\2\2\u0793\u0798\5\u0092J\2\u0794\u0795\7g"+
"\2\2\u0795\u0797\5\20\t\2\u0796\u0794\3\2\2\2\u0797\u079a\3\2\2\2\u0798"+
"\u0796\3\2\2\2\u0798\u0799\3\2\2\2\u0799\u016b\3\2\2\2\u079a\u0798\3\2"+
"\2\2\u079b\u079c\7\37\2\2\u079c\u079d\5\u0112\u008a\2\u079d\u016d\3\2"+
"\2\2\u079e\u079f\7;\2\2\u079f\u07a0\5\u0170\u00b9\2\u07a0\u07a2\5\u0112"+
"\u008a\2\u07a1\u07a3\5\u0164\u00b3\2\u07a2\u07a1\3\2\2\2\u07a2\u07a3\3"+
"\2\2\2\u07a3\u07a5\3\2\2\2\u07a4\u07a6\5\u016c\u00b7\2\u07a5\u07a4\3\2"+
"\2\2\u07a5\u07a6\3\2\2\2\u07a6\u016f\3\2\2\2\u07a7\u07a8\7F\2\2\u07a8"+
"\u07aa\5\u0172\u00ba\2\u07a9\u07ab\7L\2\2\u07aa\u07a9\3\2\2\2\u07aa\u07ab"+
"\3\2\2\2\u07ab\u07ac\3\2\2\2\u07ac\u07ad\7G\2\2\u07ad\u0171\3\2\2\2\u07ae"+
"\u07b3\5\u0174\u00bb\2\u07af\u07b0\7L\2\2\u07b0\u07b2\5\u0174\u00bb\2"+
"\u07b1\u07af\3\2\2\2\u07b2\u07b5\3\2\2\2\u07b3\u07b1\3\2\2\2\u07b3\u07b4"+
"\3\2\2\2\u07b4\u0173\3\2\2\2\u07b5\u07b3\3\2\2\2\u07b6\u07b8\5\u00b2Z"+
"\2\u07b7\u07b6\3\2\2\2\u07b8\u07bb\3\2\2\2\u07b9\u07b7\3\2\2\2\u07b9\u07ba"+
"\3\2\2\2\u07ba\u07bc\3\2\2\2\u07bb\u07b9\3\2\2\2\u07bc\u07bd\5\u008aF"+
"\2\u07bd\u07be\5\u0086D\2\u07be\u07bf\7R\2\2\u07bf\u07c0\5\u01b8\u00dd"+
"\2\u07c0\u07c3\3\2\2\2\u07c1\u07c3\5\u0176\u00bc\2\u07c2\u07b9\3\2\2\2"+
"\u07c2\u07c1\3\2\2\2\u07c3\u0175\3\2\2\2\u07c4\u07c7\5<\37\2\u07c5\u07c7"+
"\5\u0196\u00cc\2\u07c6\u07c4\3\2\2\2\u07c6\u07c5\3\2\2\2\u07c7\u0177\3"+
"\2\2\2\u07c8\u07cb\5\u0186\u00c4\2\u07c9\u07cb\5\u01b0\u00d9\2\u07ca\u07c8"+
"\3\2\2\2\u07ca\u07c9\3\2\2\2\u07cb\u07cf\3\2\2\2\u07cc\u07ce\5\u0180\u00c1"+
"\2\u07cd\u07cc\3\2\2\2\u07ce\u07d1\3\2\2\2\u07cf\u07cd\3\2\2\2\u07cf\u07d0"+
"\3\2\2\2\u07d0\u0179\3\2\2\2\u07d1\u07cf\3\2\2\2\u07d2\u07e3\5\2\2\2\u07d3"+
"\u07e3\5\u018c\u00c7\2\u07d4\u07e3\7\67\2\2\u07d5\u07d6\58\35\2\u07d6"+
"\u07d7\7N\2\2\u07d7\u07d8\7\67\2\2\u07d8\u07e3\3\2\2\2\u07d9\u07da\7F"+
"\2\2\u07da\u07db\5\u01b8\u00dd\2\u07db\u07dc\7G\2\2\u07dc\u07e3\3\2\2"+
"\2\u07dd\u07e3\5\u018e\u00c8\2\u07de\u07e3\5\u0196\u00cc\2\u07df\u07e3"+
"\5\u019c\u00cf\2\u07e0\u07e3\5\u01a2\u00d2\2\u07e1\u07e3\5\u01aa\u00d6"+
"\2\u07e2\u07d2\3\2\2\2\u07e2\u07d3\3\2\2\2\u07e2\u07d4\3\2\2\2\u07e2\u07d5"+
"\3\2\2\2\u07e2\u07d9\3\2\2\2\u07e2\u07dd\3\2\2\2\u07e2\u07de\3\2\2\2\u07e2"+
"\u07df\3\2\2\2\u07e2\u07e0\3\2\2\2\u07e2\u07e1\3\2\2\2\u07e3\u017b\3\2"+
"\2\2\u07e4\u07e5\3\2\2\2\u07e5\u017d\3\2\2\2\u07e6\u0803\5\2\2\2\u07e7"+
"\u07ec\58\35\2\u07e8\u07e9\7J\2\2\u07e9\u07eb\7K\2\2\u07ea\u07e8\3\2\2"+
"\2\u07eb\u07ee\3\2\2\2\u07ec\u07ea\3\2\2\2\u07ec\u07ed\3\2\2\2\u07ed\u07ef"+
"\3\2\2\2\u07ee\u07ec\3\2\2\2\u07ef\u07f0\7N\2\2\u07f0\u07f1\7\25\2\2\u07f1"+
"\u0803\3\2\2\2\u07f2\u07f3\7<\2\2\u07f3\u07f4\7N\2\2\u07f4\u0803\7\25"+
"\2\2\u07f5\u0803\7\67\2\2\u07f6\u07f7\58\35\2\u07f7\u07f8\7N\2\2\u07f8"+
"\u07f9\7\67\2\2\u07f9\u0803\3\2\2\2\u07fa\u07fb\7F\2\2\u07fb\u07fc\5\u01b8"+
"\u00dd\2\u07fc\u07fd\7G\2\2\u07fd\u0803\3\2\2\2\u07fe\u0803\5\u018e\u00c8"+
"\2\u07ff\u0803\5\u0196\u00cc\2\u0800\u0803\5\u01a2\u00d2\2\u0801\u0803"+
"\5\u01aa\u00d6\2\u0802\u07e6\3\2\2\2\u0802\u07e7\3\2\2\2\u0802\u07f2\3"+
"\2\2\2\u0802\u07f5\3\2\2\2\u0802\u07f6\3\2\2\2\u0802\u07fa\3\2\2\2\u0802"+
"\u07fe\3\2\2\2\u0802\u07ff\3\2\2\2\u0802\u0800\3\2\2\2\u0802\u0801\3\2"+
"\2\2\u0803\u017f\3\2\2\2\u0804\u080a\5\u0190\u00c9\2\u0805\u080a\5\u0198"+
"\u00cd\2\u0806\u080a\5\u019e\u00d0\2\u0807\u080a\5\u01a4\u00d3\2\u0808"+
"\u080a\5\u01ac\u00d7\2\u0809\u0804\3\2\2\2\u0809\u0805\3\2\2\2\u0809\u0806"+
"\3\2\2\2\u0809\u0807\3\2\2\2\u0809\u0808\3\2\2\2\u080a\u0181\3\2\2\2\u080b"+
"\u080c\3\2\2\2\u080c\u0183\3\2\2\2\u080d\u0812\5\u0190\u00c9\2\u080e\u0812"+
"\5\u0198\u00cd\2\u080f\u0812\5\u01a4\u00d3\2\u0810\u0812\5\u01ac\u00d7"+
"\2\u0811\u080d\3\2\2\2\u0811\u080e\3\2\2\2\u0811\u080f\3\2\2\2\u0811\u0810"+
"\3\2\2\2\u0812\u0185\3\2\2\2\u0813\u083c\5\2\2\2\u0814\u0819\58\35\2\u0815"+
"\u0816\7J\2\2\u0816\u0818\7K\2\2\u0817\u0815\3\2\2\2\u0818\u081b\3\2\2"+
"\2\u0819\u0817\3\2\2\2\u0819\u081a\3\2\2\2\u081a\u081c\3\2\2\2\u081b\u0819"+
"\3\2\2\2\u081c\u081d\7N\2\2\u081d\u081e\7\25\2\2\u081e\u083c\3\2\2\2\u081f"+
"\u0824\5\u008cG\2\u0820\u0821\7J\2\2\u0821\u0823\7K\2\2\u0822\u0820\3"+
"\2\2\2\u0823\u0826\3\2\2\2\u0824\u0822\3\2\2\2\u0824\u0825\3\2\2\2\u0825"+
"\u0827\3\2\2\2\u0826\u0824\3\2\2\2\u0827\u0828\7N\2\2\u0828\u0829\7\25"+
"\2\2\u0829\u083c\3\2\2\2\u082a\u082b\7<\2\2\u082b\u082c\7N\2\2\u082c\u083c"+
"\7\25\2\2\u082d\u083c\7\67\2\2\u082e\u082f\58\35\2\u082f\u0830\7N\2\2"+
"\u0830\u0831\7\67\2\2\u0831\u083c\3\2\2\2\u0832\u0833\7F\2\2\u0833\u0834"+
"\5\u01b8\u00dd\2\u0834\u0835\7G\2\2\u0835\u083c\3\2\2\2\u0836\u083c\5"+
"\u0192\u00ca\2\u0837\u083c\5\u019a\u00ce\2\u0838\u083c\5\u01a0\u00d1\2"+
"\u0839\u083c\5\u01a6\u00d4\2\u083a\u083c\5\u01ae\u00d8\2\u083b\u0813\3"+
"\2\2\2\u083b\u0814\3\2\2\2\u083b\u081f\3\2\2\2\u083b\u082a\3\2\2\2\u083b"+
"\u082d\3\2\2\2\u083b\u082e\3\2\2\2\u083b\u0832\3\2\2\2\u083b\u0836\3\2"+
"\2\2\u083b\u0837\3\2\2\2\u083b\u0838\3\2\2\2\u083b\u0839\3\2\2\2\u083b"+
"\u083a\3\2\2\2\u083c\u0187\3\2\2\2\u083d\u083e\3\2\2\2\u083e\u0189\3\2"+
"\2\2\u083f\u0867\5\2\2\2\u0840\u0845\58\35\2\u0841\u0842\7J\2\2\u0842"+
"\u0844\7K\2\2\u0843\u0841\3\2\2\2\u0844\u0847\3\2\2\2\u0845\u0843\3\2"+
"\2\2\u0845\u0846\3\2\2\2\u0846\u0848\3\2\2\2\u0847\u0845\3\2\2\2\u0848"+
"\u0849\7N\2\2\u0849\u084a\7\25\2\2\u084a\u0867\3\2\2\2\u084b\u0850\5\u008c"+
"G\2\u084c\u084d\7J\2\2\u084d\u084f\7K\2\2\u084e\u084c\3\2\2\2\u084f\u0852"+
"\3\2\2\2\u0850\u084e\3\2\2\2\u0850\u0851\3\2\2\2\u0851\u0853\3\2\2\2\u0852"+
"\u0850\3\2\2\2\u0853\u0854\7N\2\2\u0854\u0855\7\25\2\2\u0855\u0867\3\2"+
"\2\2\u0856\u0857\7<\2\2\u0857\u0858\7N\2\2\u0858\u0867\7\25\2\2\u0859"+
"\u0867\7\67\2\2\u085a\u085b\58\35\2\u085b\u085c\7N\2\2\u085c\u085d\7\67"+
"\2\2\u085d\u0867\3\2\2\2\u085e\u085f\7F\2\2\u085f\u0860\5\u01b8\u00dd"+
"\2\u0860\u0861\7G\2\2\u0861\u0867\3\2\2\2\u0862\u0867\5\u0192\u00ca\2"+
"\u0863\u0867\5\u019a\u00ce\2\u0864\u0867\5\u01a6\u00d4\2\u0865\u0867\5"+
"\u01ae\u00d8\2\u0866\u083f\3\2\2\2\u0866\u0840\3\2\2\2\u0866\u084b\3\2"+
"\2\2\u0866\u0856\3\2\2\2\u0866\u0859\3\2\2\2\u0866\u085a\3\2\2\2\u0866"+
"\u085e\3\2\2\2\u0866\u0862\3\2\2\2\u0866\u0863\3\2\2\2\u0866\u0864\3\2"+
"\2\2\u0866\u0865\3\2\2\2\u0867\u018b\3\2\2\2\u0868\u086c\58\35\2\u0869"+
"\u086c\5\6\4\2\u086a\u086c\7\17\2\2\u086b\u0868\3\2\2\2\u086b\u0869\3"+
"\2\2\2\u086b\u086a\3\2\2\2\u086c\u0871\3\2\2\2\u086d\u086e\7J\2\2\u086e"+
"\u0870\7K\2\2\u086f\u086d\3\2\2\2\u0870\u0873\3\2\2\2\u0871\u086f\3\2"+
"\2\2\u0871\u0872\3\2\2\2\u0872\u0874\3\2\2\2\u0873\u0871\3\2\2\2\u0874"+
"\u0875\7N\2\2\u0875\u087a\7\25\2\2\u0876\u0877\7<\2\2\u0877\u0878\7N\2"+
"\2\u0878\u087a\7\25\2\2\u0879\u086b\3\2\2\2\u0879\u0876\3\2\2\2\u087a"+
"\u018d\3\2\2\2\u087b\u087d\7+\2\2\u087c\u087e\5*\26\2\u087d\u087c\3\2"+
"\2\2\u087d\u087e\3\2\2\2\u087e\u0882\3\2\2\2\u087f\u0881\5\u00fc\177\2"+
"\u0880\u087f\3\2\2\2\u0881\u0884\3\2\2\2\u0882\u0880\3\2\2\2\u0882\u0883"+
"\3\2\2\2\u0883\u0885\3\2\2\2\u0884\u0882\3\2\2\2\u0885\u0890\5\u01f4\u00fb"+
"\2\u0886\u088a\7N\2\2\u0887\u0889\5\u00fc\177\2\u0888\u0887\3\2\2\2\u0889"+
"\u088c\3\2\2\2\u088a\u0888\3\2\2\2\u088a\u088b\3\2\2\2\u088b\u088d\3\2"+
"\2\2\u088c\u088a\3\2\2\2\u088d\u088f\5\u01f4\u00fb\2\u088e\u0886\3\2\2"+
"\2\u088f\u0892\3\2\2\2\u0890\u088e\3\2\2\2\u0890\u0891\3\2\2\2\u0891\u0894"+
"\3\2\2\2\u0892\u0890\3\2\2\2\u0893\u0895\5\u0194\u00cb\2\u0894\u0893\3"+
"\2\2\2\u0894\u0895\3\2\2\2\u0895\u0896\3\2\2\2\u0896\u0898\7F\2\2\u0897"+
"\u0899\5\u01a8\u00d5\2\u0898\u0897\3\2\2\2\u0898\u0899\3\2\2\2\u0899\u089a"+
"\3\2\2\2\u089a\u089c\7G\2\2\u089b\u089d\5x=\2\u089c\u089b\3\2\2\2\u089c"+
"\u089d\3\2\2\2\u089d\u08cf\3\2\2\2\u089e\u089f\5<\37\2\u089f\u08a0\7N"+
"\2\2\u08a0\u08a2\7+\2\2\u08a1\u08a3\5*\26\2\u08a2\u08a1\3\2\2\2\u08a2"+
"\u08a3\3\2\2\2\u08a3\u08a7\3\2\2\2\u08a4\u08a6\5\u00fc\177\2\u08a5\u08a4"+
"\3\2\2\2\u08a6\u08a9\3\2\2\2\u08a7\u08a5\3\2\2\2\u08a7\u08a8\3\2\2\2\u08a8"+
"\u08aa\3\2\2\2\u08a9\u08a7\3\2\2\2\u08aa\u08ac\5\u01f4\u00fb\2\u08ab\u08ad"+
"\5\u0194\u00cb\2\u08ac\u08ab\3\2\2\2\u08ac\u08ad\3\2\2\2\u08ad\u08ae\3"+
"\2\2\2\u08ae\u08b0\7F\2\2\u08af\u08b1\5\u01a8\u00d5\2\u08b0\u08af\3\2"+
"\2\2\u08b0\u08b1\3\2\2\2\u08b1\u08b2\3\2\2\2\u08b2\u08b4\7G\2\2\u08b3"+
"\u08b5\5x=\2\u08b4\u08b3\3\2\2\2\u08b4\u08b5\3\2\2\2\u08b5\u08cf\3\2\2"+
"\2\u08b6\u08b7\5\u0178\u00bd\2\u08b7\u08b8\7N\2\2\u08b8\u08ba\7+\2\2\u08b9"+
"\u08bb\5*\26\2\u08ba\u08b9\3\2\2\2\u08ba\u08bb\3\2\2\2\u08bb\u08bf\3\2"+
"\2\2\u08bc\u08be\5\u00fc\177\2\u08bd\u08bc\3\2\2\2\u08be\u08c1\3\2\2\2"+
"\u08bf\u08bd\3\2\2\2\u08bf\u08c0\3\2\2\2\u08c0\u08c2\3\2\2\2\u08c1\u08bf"+
"\3\2\2\2\u08c2\u08c4\5\u01f4\u00fb\2\u08c3\u08c5\5\u0194\u00cb\2\u08c4"+
"\u08c3\3\2\2\2\u08c4\u08c5\3\2\2\2\u08c5\u08c6\3\2\2\2\u08c6\u08c8\7F"+
"\2\2\u08c7\u08c9\5\u01a8\u00d5\2\u08c8\u08c7\3\2\2\2\u08c8\u08c9\3\2\2"+
"\2\u08c9\u08ca\3\2\2\2\u08ca\u08cc\7G\2\2\u08cb\u08cd\5x=\2\u08cc\u08cb"+
"\3\2\2\2\u08cc\u08cd\3\2\2\2\u08cd\u08cf\3\2\2\2\u08ce\u087b\3\2\2\2\u08ce"+
"\u089e\3\2\2\2\u08ce\u08b6\3\2\2\2\u08cf\u018f\3\2\2\2\u08d0\u08d1\7N"+
"\2\2\u08d1\u08d3\7+\2\2\u08d2\u08d4\5*\26\2\u08d3\u08d2\3\2\2\2\u08d3"+
"\u08d4\3\2\2\2\u08d4\u08d8\3\2\2\2\u08d5\u08d7\5\u00fc\177\2\u08d6\u08d5"+
"\3\2\2\2\u08d7\u08da\3\2\2\2\u08d8\u08d6\3\2\2\2\u08d8\u08d9\3\2\2\2\u08d9"+
"\u08db\3\2\2\2\u08da\u08d8\3\2\2\2\u08db\u08dd\5\u01f4\u00fb\2\u08dc\u08de"+
"\5\u0194\u00cb\2\u08dd\u08dc\3\2\2\2\u08dd\u08de\3\2\2\2\u08de\u08df\3"+
"\2\2\2\u08df\u08e1\7F\2\2\u08e0\u08e2\5\u01a8\u00d5\2\u08e1\u08e0\3\2"+
"\2\2\u08e1\u08e2\3\2\2\2\u08e2\u08e3\3\2\2\2\u08e3\u08e5\7G\2\2\u08e4"+
"\u08e6\5x=\2\u08e5\u08e4\3\2\2\2\u08e5\u08e6\3\2\2\2\u08e6\u0191\3\2\2"+
"\2\u08e7\u08e9\7+\2\2\u08e8\u08ea\5*\26\2\u08e9\u08e8\3\2\2\2\u08e9\u08ea"+
"\3\2\2\2\u08ea\u08ee\3\2\2\2\u08eb\u08ed\5\u00fc\177\2\u08ec\u08eb\3\2"+
"\2\2\u08ed\u08f0\3\2\2\2\u08ee\u08ec\3\2\2\2\u08ee\u08ef\3\2\2\2\u08ef"+
"\u08f1\3\2\2\2\u08f0\u08ee\3\2\2\2\u08f1\u08fc\5\u01f4\u00fb\2\u08f2\u08f6"+
"\7N\2\2\u08f3\u08f5\5\u00fc\177\2\u08f4\u08f3\3\2\2\2\u08f5\u08f8\3\2"+
"\2\2\u08f6\u08f4\3\2\2\2\u08f6\u08f7\3\2\2\2\u08f7\u08f9\3\2\2\2\u08f8"+
"\u08f6\3\2\2\2\u08f9\u08fb\5\u01f4\u00fb\2\u08fa\u08f2\3\2\2\2\u08fb\u08fe"+
"\3\2\2\2\u08fc\u08fa\3\2\2\2\u08fc\u08fd\3\2\2\2\u08fd\u0900\3\2\2\2\u08fe"+
"\u08fc\3\2\2\2\u08ff\u0901\5\u0194\u00cb\2\u0900\u08ff\3\2\2\2\u0900\u0901"+
"\3\2\2\2\u0901\u0902\3\2\2\2\u0902\u0904\7F\2\2\u0903\u0905\5\u01a8\u00d5"+
"\2\u0904\u0903\3\2\2\2\u0904\u0905\3\2\2\2\u0905\u0906\3\2\2\2\u0906\u0908"+
"\7G\2\2\u0907\u0909\5x=\2\u0908\u0907\3\2\2\2\u0908\u0909\3\2\2\2\u0909"+
"\u0923\3\2\2\2\u090a\u090b\5<\37\2\u090b\u090c\7N\2\2\u090c\u090e\7+\2"+
"\2\u090d\u090f\5*\26\2\u090e\u090d\3\2\2\2\u090e\u090f\3\2\2\2\u090f\u0913"+
"\3\2\2\2\u0910\u0912\5\u00fc\177\2\u0911\u0910\3\2\2\2\u0912\u0915\3\2"+
"\2\2\u0913\u0911\3\2\2\2\u0913\u0914\3\2\2\2\u0914\u0916\3\2\2\2\u0915"+
"\u0913\3\2\2\2\u0916\u0918\5\u01f4\u00fb\2\u0917\u0919\5\u0194\u00cb\2"+
"\u0918\u0917\3\2\2\2\u0918\u0919\3\2\2\2\u0919\u091a\3\2\2\2\u091a\u091c"+
"\7F\2\2\u091b\u091d\5\u01a8\u00d5\2\u091c\u091b\3\2\2\2\u091c\u091d\3"+
"\2\2\2\u091d\u091e\3\2\2\2\u091e\u0920\7G\2\2\u091f\u0921\5x=\2\u0920"+
"\u091f\3\2\2\2\u0920\u0921\3\2\2\2\u0921\u0923\3\2\2\2\u0922\u08e7\3\2"+
"\2\2\u0922\u090a\3\2\2\2\u0923\u0193\3\2\2\2\u0924\u0928\5*\26\2\u0925"+
"\u0926\7T\2\2\u0926\u0928\7S\2\2\u0927\u0924\3\2\2\2\u0927\u0925\3\2\2"+
"\2\u0928\u0195\3\2\2\2\u0929\u092a\5\u0178\u00bd\2\u092a\u092b\7N\2\2"+
"\u092b\u092c\5\u01f4\u00fb\2\u092c\u0937\3\2\2\2\u092d\u092e\7\64\2\2"+
"\u092e\u092f\7N\2\2\u092f\u0937\5\u01f4\u00fb\2\u0930\u0931\58\35\2\u0931"+
"\u0932\7N\2\2\u0932\u0933\7\64\2\2\u0933\u0934\7N\2\2\u0934\u0935\5\u01f4"+
"\u00fb\2\u0935\u0937\3\2\2\2\u0936\u0929\3\2\2\2\u0936\u092d\3\2\2\2\u0936"+
"\u0930\3\2\2\2\u0937\u0197\3\2\2\2\u0938\u0939\7N\2\2\u0939\u093a\5\u01f4"+
"\u00fb\2\u093a\u0199\3\2\2\2\u093b\u093c\7\64\2\2\u093c\u093d\7N\2\2\u093d"+
"\u0945\5\u01f4\u00fb\2\u093e\u093f\58\35\2\u093f\u0940\7N\2\2\u0940\u0941"+
"\7\64\2\2\u0941\u0942\7N\2\2\u0942\u0943\5\u01f4\u00fb\2\u0943\u0945\3"+
"\2\2\2\u0944\u093b\3\2\2\2\u0944\u093e\3\2\2\2\u0945\u019b\3\2\2\2\u0946"+
"\u0947\5<\37\2\u0947\u0948\7J\2\2\u0948\u0949\5\u01b8\u00dd\2\u0949\u094a"+
"\7K\2\2\u094a\u0951";
private static final String _serializedATNSegment1 =
"\3\2\2\2\u094b\u094c\5\u017e\u00c0\2\u094c\u094d\7J\2\2\u094d\u094e\5"+
"\u01b8\u00dd\2\u094e\u094f\7K\2\2\u094f\u0951\3\2\2\2\u0950\u0946\3\2"+
"\2\2\u0950\u094b\3\2\2\2\u0951\u0959\3\2\2\2\u0952\u0953\5\u017c\u00bf"+
"\2\u0953\u0954\7J\2\2\u0954\u0955\5\u01b8\u00dd\2\u0955\u0956\7K\2\2\u0956"+
"\u0958\3\2\2\2\u0957\u0952\3\2\2\2\u0958\u095b\3\2\2\2\u0959\u0957\3\2"+
"\2\2\u0959\u095a\3\2\2\2\u095a\u019d\3\2\2\2\u095b\u0959\3\2\2\2\u095c"+
"\u095d\5\u0184\u00c3\2\u095d\u095e\7J\2\2\u095e\u095f\5\u01b8\u00dd\2"+
"\u095f\u0960\7K\2\2\u0960\u0968\3\2\2\2\u0961\u0962\5\u0182\u00c2\2\u0962"+
"\u0963\7J\2\2\u0963\u0964\5\u01b8\u00dd\2\u0964\u0965\7K\2\2\u0965\u0967"+
"\3\2\2\2\u0966\u0961\3\2\2\2\u0967\u096a\3\2\2\2\u0968\u0966\3\2\2\2\u0968"+
"\u0969\3\2\2\2\u0969\u019f\3\2\2\2\u096a\u0968\3\2\2\2\u096b\u096c\5<"+
"\37\2\u096c\u096d\7J\2\2\u096d\u096e\5\u01b8\u00dd\2\u096e\u096f\7K\2"+
"\2\u096f\u0976\3\2\2\2\u0970\u0971\5\u018a\u00c6\2\u0971\u0972\7J\2\2"+
"\u0972\u0973\5\u01b8\u00dd\2\u0973\u0974\7K\2\2\u0974\u0976\3\2\2\2\u0975"+
"\u096b\3\2\2\2\u0975\u0970\3\2\2\2\u0976\u097e\3\2\2\2\u0977\u0978\5\u0188"+
"\u00c5\2\u0978\u0979\7J\2\2\u0979\u097a\5\u01b8\u00dd\2\u097a\u097b\7"+
"K\2\2\u097b\u097d\3\2\2\2\u097c\u0977\3\2\2\2\u097d\u0980\3\2\2\2\u097e"+
"\u097c\3\2\2\2\u097e\u097f\3\2\2\2\u097f\u01a1\3\2\2\2\u0980\u097e\3\2"+
"\2\2\u0981\u0982\5> \2\u0982\u0984\7F\2\2\u0983\u0985\5\u01a8\u00d5\2"+
"\u0984\u0983\3\2\2\2\u0984\u0985\3\2\2\2\u0985\u0986\3\2\2\2\u0986\u0987"+
"\7G\2\2\u0987\u09c7\3\2\2\2\u0988\u0989\58\35\2\u0989\u098b\7N\2\2\u098a"+
"\u098c\5*\26\2\u098b\u098a\3\2\2\2\u098b\u098c\3\2\2\2\u098c\u098d\3\2"+
"\2\2\u098d\u098e\5\u01f4\u00fb\2\u098e\u0990\7F\2\2\u098f\u0991\5\u01a8"+
"\u00d5\2\u0990\u098f\3\2\2\2\u0990\u0991\3\2\2\2\u0991\u0992\3\2\2\2\u0992"+
"\u0993\7G\2\2\u0993\u09c7\3\2\2\2\u0994\u0995\5<\37\2\u0995\u0997\7N\2"+
"\2\u0996\u0998\5*\26\2\u0997\u0996\3\2\2\2\u0997\u0998\3\2\2\2\u0998\u0999"+
"\3\2\2\2\u0999\u099a\5\u01f4\u00fb\2\u099a\u099c\7F\2\2\u099b\u099d\5"+
"\u01a8\u00d5\2\u099c\u099b\3\2\2\2\u099c\u099d\3\2\2\2\u099d\u099e\3\2"+
"\2\2\u099e\u099f\7G\2\2\u099f\u09c7\3\2\2\2\u09a0\u09a1\5\u0178\u00bd"+
"\2\u09a1\u09a3\7N\2\2\u09a2\u09a4\5*\26\2\u09a3\u09a2\3\2\2\2\u09a3\u09a4"+
"\3\2\2\2\u09a4\u09a5\3\2\2\2\u09a5\u09a6\5\u01f4\u00fb\2\u09a6\u09a8\7"+
"F\2\2\u09a7\u09a9\5\u01a8\u00d5\2\u09a8\u09a7\3\2\2\2\u09a8\u09a9\3\2"+
"\2\2\u09a9\u09aa\3\2\2\2\u09aa\u09ab\7G\2\2\u09ab\u09c7\3\2\2\2\u09ac"+
"\u09ad\7\64\2\2\u09ad\u09af\7N\2\2\u09ae\u09b0\5*\26\2\u09af\u09ae\3\2"+
"\2\2\u09af\u09b0\3\2\2\2\u09b0\u09b1\3\2\2\2\u09b1\u09b2\5\u01f4\u00fb"+
"\2\u09b2\u09b4\7F\2\2\u09b3\u09b5\5\u01a8\u00d5\2\u09b4\u09b3\3\2\2\2"+
"\u09b4\u09b5\3\2\2\2\u09b5\u09b6\3\2\2\2\u09b6\u09b7\7G\2\2\u09b7\u09c7"+
"\3\2\2\2\u09b8\u09b9\58\35\2\u09b9\u09ba\7N\2\2\u09ba\u09bb\7\64\2\2\u09bb"+
"\u09bd\7N\2\2\u09bc\u09be\5*\26\2\u09bd\u09bc\3\2\2\2\u09bd\u09be\3\2"+
"\2\2\u09be\u09bf\3\2\2\2\u09bf\u09c0\5\u01f4\u00fb\2\u09c0\u09c2\7F\2"+
"\2\u09c1\u09c3\5\u01a8\u00d5\2\u09c2\u09c1\3\2\2\2\u09c2\u09c3\3\2\2\2"+
"\u09c3\u09c4\3\2\2\2\u09c4\u09c5\7G\2\2\u09c5\u09c7\3\2\2\2\u09c6\u0981"+
"\3\2\2\2\u09c6\u0988\3\2\2\2\u09c6\u0994\3\2\2\2\u09c6\u09a0\3\2\2\2\u09c6"+
"\u09ac\3\2\2\2\u09c6\u09b8\3\2\2\2\u09c7\u01a3\3\2\2\2\u09c8\u09ca\7N"+
"\2\2\u09c9\u09cb\5*\26\2\u09ca\u09c9\3\2\2\2\u09ca\u09cb\3\2\2\2\u09cb"+
"\u09cc\3\2\2\2\u09cc\u09cd\5\u01f4\u00fb\2\u09cd\u09cf\7F\2\2\u09ce\u09d0"+
"\5\u01a8\u00d5\2\u09cf\u09ce\3\2\2\2\u09cf\u09d0\3\2\2\2\u09d0\u09d1\3"+
"\2\2\2\u09d1\u09d2\7G\2\2\u09d2\u01a5\3\2\2\2\u09d3\u09d4\5> \2\u09d4"+
"\u09d6\7F\2\2\u09d5\u09d7\5\u01a8\u00d5\2\u09d6\u09d5\3\2\2\2\u09d6\u09d7"+
"\3\2\2\2\u09d7\u09d8\3\2\2\2\u09d8\u09d9\7G\2\2\u09d9\u0a0d\3\2\2\2\u09da"+
"\u09db\58\35\2\u09db\u09dd\7N\2\2\u09dc\u09de\5*\26\2\u09dd\u09dc\3\2"+
"\2\2\u09dd\u09de\3\2\2\2\u09de\u09df\3\2\2\2\u09df\u09e0\5\u01f4\u00fb"+
"\2\u09e0\u09e2\7F\2\2\u09e1\u09e3\5\u01a8\u00d5\2\u09e2\u09e1\3\2\2\2"+
"\u09e2\u09e3\3\2\2\2\u09e3\u09e4\3\2\2\2\u09e4\u09e5\7G\2\2\u09e5\u0a0d"+
"\3\2\2\2\u09e6\u09e7\5<\37\2\u09e7\u09e9\7N\2\2\u09e8\u09ea\5*\26\2\u09e9"+
"\u09e8\3\2\2\2\u09e9\u09ea\3\2\2\2\u09ea\u09eb\3\2\2\2\u09eb\u09ec\5\u01f4"+
"\u00fb\2\u09ec\u09ee\7F\2\2\u09ed\u09ef\5\u01a8\u00d5\2\u09ee\u09ed\3"+
"\2\2\2\u09ee\u09ef\3\2\2\2\u09ef\u09f0\3\2\2\2\u09f0\u09f1\7G\2\2\u09f1"+
"\u0a0d\3\2\2\2\u09f2\u09f3\7\64\2\2\u09f3\u09f5\7N\2\2\u09f4\u09f6\5*"+
"\26\2\u09f5\u09f4\3\2\2\2\u09f5\u09f6\3\2\2\2\u09f6\u09f7\3\2\2\2\u09f7"+
"\u09f8\5\u01f4\u00fb\2\u09f8\u09fa\7F\2\2\u09f9\u09fb\5\u01a8\u00d5\2"+
"\u09fa\u09f9\3\2\2\2\u09fa\u09fb\3\2\2\2\u09fb\u09fc\3\2\2\2\u09fc\u09fd"+
"\7G\2\2\u09fd\u0a0d\3\2\2\2\u09fe\u09ff\58\35\2\u09ff\u0a00\7N\2\2\u0a00"+
"\u0a01\7\64\2\2\u0a01\u0a03\7N\2\2\u0a02\u0a04\5*\26\2\u0a03\u0a02\3\2"+
"\2\2\u0a03\u0a04\3\2\2\2\u0a04\u0a05\3\2\2\2\u0a05\u0a06\5\u01f4\u00fb"+
"\2\u0a06\u0a08\7F\2\2\u0a07\u0a09\5\u01a8\u00d5\2\u0a08\u0a07\3\2\2\2"+
"\u0a08\u0a09\3\2\2\2\u0a09\u0a0a\3\2\2\2\u0a0a\u0a0b\7G\2\2\u0a0b\u0a0d"+
"\3\2\2\2\u0a0c\u09d3\3\2\2\2\u0a0c\u09da\3\2\2\2\u0a0c\u09e6\3\2\2\2\u0a0c"+
"\u09f2\3\2\2\2\u0a0c\u09fe\3\2\2\2\u0a0d\u01a7\3\2\2\2\u0a0e\u0a13\5\u01b8"+
"\u00dd\2\u0a0f\u0a10\7M\2\2\u0a10\u0a12\5\u01b8\u00dd\2\u0a11\u0a0f\3"+
"\2\2\2\u0a12\u0a15\3\2\2\2\u0a13\u0a11\3\2\2\2\u0a13\u0a14\3\2\2\2\u0a14"+
"\u01a9\3\2\2\2\u0a15\u0a13\3\2\2\2\u0a16\u0a17\5<\37\2\u0a17\u0a19\7Q"+
"\2\2\u0a18\u0a1a\5*\26\2\u0a19\u0a18\3\2\2\2\u0a19\u0a1a\3\2\2\2\u0a1a"+
"\u0a1b\3\2\2\2\u0a1b\u0a1c\5\u01f4\u00fb\2\u0a1c\u0a46\3\2\2\2\u0a1d\u0a1e"+
"\5\f\7\2\u0a1e\u0a20\7Q\2\2\u0a1f\u0a21\5*\26\2\u0a20\u0a1f\3\2\2\2\u0a20"+
"\u0a21\3\2\2\2\u0a21\u0a22\3\2\2\2\u0a22\u0a23\5\u01f4\u00fb\2\u0a23\u0a46"+
"\3\2\2\2\u0a24\u0a25\5\u0178\u00bd\2\u0a25\u0a27\7Q\2\2\u0a26\u0a28\5"+
"*\26\2\u0a27\u0a26\3\2\2\2\u0a27\u0a28\3\2\2\2\u0a28\u0a29\3\2\2\2\u0a29"+
"\u0a2a\5\u01f4\u00fb\2\u0a2a\u0a46\3\2\2\2\u0a2b\u0a2c\7\64\2\2\u0a2c"+
"\u0a2e\7Q\2\2\u0a2d\u0a2f\5*\26\2\u0a2e\u0a2d\3\2\2\2\u0a2e\u0a2f\3\2"+
"\2\2\u0a2f\u0a30\3\2\2\2\u0a30\u0a46\5\u01f4\u00fb\2\u0a31\u0a32\58\35"+
"\2\u0a32\u0a33\7N\2\2\u0a33\u0a34\7\64\2\2\u0a34\u0a36\7Q\2\2\u0a35\u0a37"+
"\5*\26\2\u0a36\u0a35\3\2\2\2\u0a36\u0a37\3\2\2\2\u0a37\u0a38\3\2\2\2\u0a38"+
"\u0a39\5\u01f4\u00fb\2\u0a39\u0a46\3\2\2\2\u0a3a\u0a3b\5\20\t\2\u0a3b"+
"\u0a3d\7Q\2\2\u0a3c\u0a3e\5*\26\2\u0a3d\u0a3c\3\2\2\2\u0a3d\u0a3e\3\2"+
"\2\2\u0a3e\u0a3f\3\2\2\2\u0a3f\u0a40\7+\2\2\u0a40\u0a46\3\2\2\2\u0a41"+
"\u0a42\5\36\20\2\u0a42\u0a43\7Q\2\2\u0a43\u0a44\7+\2\2\u0a44\u0a46\3\2"+
"\2\2\u0a45\u0a16\3\2\2\2\u0a45\u0a1d\3\2\2\2\u0a45\u0a24\3\2\2\2\u0a45"+
"\u0a2b\3\2\2\2\u0a45\u0a31\3\2\2\2\u0a45\u0a3a\3\2\2\2\u0a45\u0a41\3\2"+
"\2\2\u0a46\u01ab\3\2\2\2\u0a47\u0a49\7Q\2\2\u0a48\u0a4a\5*\26\2\u0a49"+
"\u0a48\3\2\2\2\u0a49\u0a4a\3\2\2\2\u0a4a\u0a4b\3\2\2\2\u0a4b\u0a4c\5\u01f4"+
"\u00fb\2\u0a4c\u01ad\3\2\2\2\u0a4d\u0a4e\5<\37\2\u0a4e\u0a50\7Q\2\2\u0a4f"+
"\u0a51\5*\26\2\u0a50\u0a4f\3\2\2\2\u0a50\u0a51\3\2\2\2\u0a51\u0a52\3\2"+
"\2\2\u0a52\u0a53\5\u01f4\u00fb\2\u0a53\u0a76\3\2\2\2\u0a54\u0a55\5\f\7"+
"\2\u0a55\u0a57\7Q\2\2\u0a56\u0a58\5*\26\2\u0a57\u0a56\3\2\2\2\u0a57\u0a58"+
"\3\2\2\2\u0a58\u0a59\3\2\2\2\u0a59\u0a5a\5\u01f4\u00fb\2\u0a5a\u0a76\3"+
"\2\2\2\u0a5b\u0a5c\7\64\2\2\u0a5c\u0a5e\7Q\2\2\u0a5d\u0a5f\5*\26\2\u0a5e"+
"\u0a5d\3\2\2\2\u0a5e\u0a5f\3\2\2\2\u0a5f\u0a60\3\2\2\2\u0a60\u0a76\5\u01f4"+
"\u00fb\2\u0a61\u0a62\58\35\2\u0a62\u0a63\7N\2\2\u0a63\u0a64\7\64\2\2\u0a64"+
"\u0a66\7Q\2\2\u0a65\u0a67\5*\26\2\u0a66\u0a65\3\2\2\2\u0a66\u0a67\3\2"+
"\2\2\u0a67\u0a68\3\2\2\2\u0a68\u0a69\5\u01f4\u00fb\2\u0a69\u0a76\3\2\2"+
"\2\u0a6a\u0a6b\5\20\t\2\u0a6b\u0a6d\7Q\2\2\u0a6c\u0a6e\5*\26\2\u0a6d\u0a6c"+
"\3\2\2\2\u0a6d\u0a6e\3\2\2\2\u0a6e\u0a6f\3\2\2\2\u0a6f\u0a70\7+\2\2\u0a70"+
"\u0a76\3\2\2\2\u0a71\u0a72\5\36\20\2\u0a72\u0a73\7Q\2\2\u0a73\u0a74\7"+
"+\2\2\u0a74\u0a76\3\2\2\2\u0a75\u0a4d\3\2\2\2\u0a75\u0a54\3\2\2\2\u0a75"+
"\u0a5b\3\2\2\2\u0a75\u0a61\3\2\2\2\u0a75\u0a6a\3\2\2\2\u0a75\u0a71\3\2"+
"\2\2\u0a76\u01af\3\2\2\2\u0a77\u0a78\7+\2\2\u0a78\u0a79\5\4\3\2\u0a79"+
"\u0a7b\5\u01b2\u00da\2\u0a7a\u0a7c\5 \21\2\u0a7b\u0a7a\3\2\2\2\u0a7b\u0a7c"+
"\3\2\2\2\u0a7c\u0a8e\3\2\2\2\u0a7d\u0a7e\7+\2\2\u0a7e\u0a7f\5\16\b\2\u0a7f"+
"\u0a81\5\u01b2\u00da\2\u0a80\u0a82\5 \21\2\u0a81\u0a80\3\2\2\2\u0a81\u0a82"+
"\3\2\2\2\u0a82\u0a8e\3\2\2\2\u0a83\u0a84\7+\2\2\u0a84\u0a85\5\4\3\2\u0a85"+
"\u0a86\5 \21\2\u0a86\u0a87\5\u010e\u0088\2\u0a87\u0a8e\3\2\2\2\u0a88\u0a89"+
"\7+\2\2\u0a89\u0a8a\5\16\b\2\u0a8a\u0a8b\5 \21\2\u0a8b\u0a8c\5\u010e\u0088"+
"\2\u0a8c\u0a8e\3\2\2\2\u0a8d\u0a77\3\2\2\2\u0a8d\u0a7d\3\2\2\2\u0a8d\u0a83"+
"\3\2\2\2\u0a8d\u0a88\3\2\2\2\u0a8e\u01b1\3\2\2\2\u0a8f\u0a91\5\u01b4\u00db"+
"\2\u0a90\u0a8f\3\2\2\2\u0a91\u0a92\3\2\2\2\u0a92\u0a90\3\2\2\2\u0a92\u0a93"+
"\3\2\2\2\u0a93\u01b3\3\2\2\2\u0a94\u0a96\5\u00fc\177\2\u0a95\u0a94\3\2"+
"\2\2\u0a96\u0a99\3\2\2\2\u0a97\u0a95\3\2\2\2\u0a97\u0a98\3\2\2\2\u0a98"+
"\u0a9a\3\2\2\2\u0a99\u0a97\3\2\2\2\u0a9a\u0a9b\7J\2\2\u0a9b\u0a9c\5\u01b8"+
"\u00dd\2\u0a9c\u0a9d\7K\2\2\u0a9d\u01b5\3\2\2\2\u0a9e\u0a9f\5\u01b8\u00dd"+
"\2\u0a9f\u01b7\3\2\2\2\u0aa0\u0aa3\5\u01ba\u00de\2\u0aa1\u0aa3\5\u01c2"+
"\u00e2\2\u0aa2\u0aa0\3\2\2\2\u0aa2\u0aa1\3\2\2\2\u0aa3\u01b9\3\2\2\2\u0aa4"+
"\u0aa5\5\u01bc\u00df\2\u0aa5\u0aa6\7Y\2\2\u0aa6\u0aa7\5\u01c0\u00e1\2"+
"\u0aa7\u01bb\3\2\2\2\u0aa8\u0ab3\5\u01f4\u00fb\2\u0aa9\u0aab\7F\2\2\u0aaa"+
"\u0aac\5\u00acW\2\u0aab\u0aaa\3\2\2\2\u0aab\u0aac\3\2\2\2\u0aac\u0aad"+
"\3\2\2\2\u0aad\u0ab3\7G\2\2\u0aae\u0aaf\7F\2\2\u0aaf\u0ab0\5\u01be\u00e0"+
"\2\u0ab0\u0ab1\7G\2\2\u0ab1\u0ab3\3\2\2\2\u0ab2\u0aa8\3\2\2\2\u0ab2\u0aa9"+
"\3\2\2\2\u0ab2\u0aae\3\2\2\2\u0ab3\u01bd\3\2\2\2\u0ab4\u0ab9\5\u01f4\u00fb"+
"\2\u0ab5\u0ab6\7M\2\2\u0ab6\u0ab8\5\u01f4\u00fb\2\u0ab7\u0ab5\3\2\2\2"+
"\u0ab8\u0abb\3\2\2\2\u0ab9\u0ab7\3\2\2\2\u0ab9\u0aba\3\2\2\2\u0aba\u01bf"+
"\3\2\2\2\u0abb\u0ab9\3\2\2\2\u0abc\u0abf\5\u01b8\u00dd\2\u0abd\u0abf\5"+
"\u0112\u008a\2\u0abe\u0abc\3\2\2\2\u0abe\u0abd\3\2\2\2\u0abf\u01c1\3\2"+
"\2\2\u0ac0\u0ac3\5\u01ca\u00e6\2\u0ac1\u0ac3\5\u01c4\u00e3\2\u0ac2\u0ac0"+
"\3\2\2\2\u0ac2\u0ac1\3\2\2\2\u0ac3\u01c3\3\2\2\2\u0ac4\u0ac5\5\u01c6\u00e4"+
"\2\u0ac5\u0ac6\5\u01c8\u00e5\2\u0ac6\u0ac7\5\u01b8\u00dd\2\u0ac7\u01c5"+
"\3\2\2\2\u0ac8\u0acc\5<\37\2\u0ac9\u0acc\5\u0196\u00cc\2\u0aca\u0acc\5"+
"\u019c\u00cf\2\u0acb\u0ac8\3\2\2\2\u0acb\u0ac9\3\2\2\2\u0acb\u0aca\3\2"+
"\2\2\u0acc\u01c7\3\2\2\2\u0acd\u0ace\t\6\2\2\u0ace\u01c9\3\2\2\2\u0acf"+
"\u0ad9\5\u01cc\u00e7\2\u0ad0\u0ad1\5\u01cc\u00e7\2\u0ad1\u0ad2\7W\2\2"+
"\u0ad2\u0ad3\5\u01b8\u00dd\2\u0ad3\u0ad6\7X\2\2\u0ad4\u0ad7\5\u01ca\u00e6"+
"\2\u0ad5\u0ad7\5\u01ba\u00de\2\u0ad6\u0ad4\3\2\2\2\u0ad6\u0ad5\3\2\2\2"+
"\u0ad7\u0ad9\3\2\2\2\u0ad8\u0acf\3\2\2\2\u0ad8\u0ad0\3\2\2\2\u0ad9\u01cb"+
"\3\2\2\2\u0ada\u0adb\b\u00e7\1\2\u0adb\u0adc\5\u01ce\u00e8\2\u0adc\u0ae2"+
"\3\2\2\2\u0add\u0ade\f\3\2\2\u0ade\u0adf\7_\2\2\u0adf\u0ae1\5\u01ce\u00e8"+
"\2\u0ae0\u0add\3\2\2\2\u0ae1\u0ae4\3\2\2\2\u0ae2\u0ae0\3\2\2\2\u0ae2\u0ae3"+
"\3\2\2\2\u0ae3\u01cd\3\2\2\2\u0ae4\u0ae2\3\2\2\2\u0ae5\u0ae6\b\u00e8\1"+
"\2\u0ae6\u0ae7\5\u01d0\u00e9\2\u0ae7\u0aed\3\2\2\2\u0ae8\u0ae9\f\3\2\2"+
"\u0ae9\u0aea\7^\2\2\u0aea\u0aec\5\u01d0\u00e9\2\u0aeb\u0ae8\3\2\2\2\u0aec"+
"\u0aef\3\2\2\2\u0aed\u0aeb\3\2\2\2\u0aed\u0aee\3\2\2\2\u0aee\u01cf\3\2"+
"\2\2\u0aef\u0aed\3\2\2\2\u0af0\u0af1\b\u00e9\1\2\u0af1\u0af2\5\u01d2\u00ea"+
"\2\u0af2\u0af8\3\2\2\2\u0af3\u0af4\f\3\2\2\u0af4\u0af5\7g\2\2\u0af5\u0af7"+
"\5\u01d2\u00ea\2\u0af6\u0af3\3\2\2\2\u0af7\u0afa\3\2\2\2\u0af8\u0af6\3"+
"\2\2\2\u0af8\u0af9\3\2\2\2\u0af9\u01d1\3\2\2\2\u0afa\u0af8\3\2\2\2\u0afb"+
"\u0afc\b\u00ea\1\2\u0afc\u0afd\5\u01d4\u00eb\2\u0afd\u0b03\3\2\2\2\u0afe"+
"\u0aff\f\3\2\2\u0aff\u0b00\7h\2\2\u0b00\u0b02\5\u01d4\u00eb\2\u0b01\u0afe"+
"\3\2\2\2\u0b02\u0b05\3\2\2\2\u0b03\u0b01\3\2\2\2\u0b03\u0b04\3\2\2\2\u0b04"+
"\u01d3\3\2\2\2\u0b05\u0b03\3\2\2\2\u0b06\u0b07\b\u00eb\1\2\u0b07\u0b08"+
"\5\u01d6\u00ec\2\u0b08\u0b0e\3\2\2\2\u0b09\u0b0a\f\3\2\2\u0b0a\u0b0b\7"+
"f\2\2\u0b0b\u0b0d\5\u01d6\u00ec\2\u0b0c\u0b09\3\2\2\2\u0b0d\u0b10\3\2"+
"\2\2\u0b0e\u0b0c\3\2\2\2\u0b0e\u0b0f\3\2\2\2\u0b0f\u01d5\3\2\2\2\u0b10"+
"\u0b0e\3\2\2\2\u0b11\u0b12\b\u00ec\1\2\u0b12\u0b13\5\u01d8\u00ed\2\u0b13"+
"\u0b1c\3\2\2\2\u0b14\u0b15\f\4\2\2\u0b15\u0b16\7Z\2\2\u0b16\u0b1b\5\u01d8"+
"\u00ed\2\u0b17\u0b18\f\3\2\2\u0b18\u0b19\7]\2\2\u0b19\u0b1b\5\u01d8\u00ed"+
"\2\u0b1a\u0b14\3\2\2\2\u0b1a\u0b17\3\2\2\2\u0b1b\u0b1e\3\2\2\2\u0b1c\u0b1a"+
"\3\2\2\2\u0b1c\u0b1d\3\2\2\2\u0b1d\u01d7\3\2\2\2\u0b1e\u0b1c\3\2\2\2\u0b1f"+
"\u0b20\b\u00ed\1\2\u0b20\u0b21\5\u01da\u00ee\2\u0b21\u0b33\3\2\2\2\u0b22"+
"\u0b23\f\7\2\2\u0b23\u0b24\7T\2\2\u0b24\u0b32\5\u01da\u00ee\2\u0b25\u0b26"+
"\f\6\2\2\u0b26\u0b27\7S\2\2\u0b27\u0b32\5\u01da\u00ee\2\u0b28\u0b29\f"+
"\5\2\2\u0b29\u0b2a\7[\2\2\u0b2a\u0b32\5\u01da\u00ee\2\u0b2b\u0b2c\f\4"+
"\2\2\u0b2c\u0b2d\7\\\2\2\u0b2d\u0b32\5\u01da\u00ee\2\u0b2e\u0b2f\f\3\2"+
"\2\u0b2f\u0b30\7&\2\2\u0b30\u0b32\5\f\7\2\u0b31\u0b22\3\2\2\2\u0b31\u0b25"+
"\3\2\2\2\u0b31\u0b28\3\2\2\2\u0b31\u0b2b\3\2\2\2\u0b31\u0b2e\3\2\2\2\u0b32"+
"\u0b35\3\2\2\2\u0b33\u0b31\3\2\2\2\u0b33\u0b34\3\2\2\2\u0b34\u01d9\3\2"+
"\2\2\u0b35\u0b33\3\2\2\2\u0b36\u0b37\b\u00ee\1\2\u0b37\u0b38\5\u01dc\u00ef"+
"\2\u0b38\u0b48\3\2\2\2\u0b39\u0b3a\f\5\2\2\u0b3a\u0b3b\7T\2\2\u0b3b\u0b3c"+
"\7T\2\2\u0b3c\u0b47\5\u01dc\u00ef\2\u0b3d\u0b3e\f\4\2\2\u0b3e\u0b3f\7"+
"S\2\2\u0b3f\u0b40\7S\2\2\u0b40\u0b47\5\u01dc\u00ef\2\u0b41\u0b42\f\3\2"+
"\2\u0b42\u0b43\7S\2\2\u0b43\u0b44\7S\2\2\u0b44\u0b45\7S\2\2\u0b45\u0b47"+
"\5\u01dc\u00ef\2\u0b46\u0b39\3\2\2\2\u0b46\u0b3d\3\2\2\2\u0b46\u0b41\3"+
"\2\2\2\u0b47\u0b4a\3\2\2\2\u0b48\u0b46\3\2\2\2\u0b48\u0b49\3\2\2\2\u0b49"+
"\u01db\3\2\2\2\u0b4a\u0b48\3\2\2\2\u0b4b\u0b4c\b\u00ef\1\2\u0b4c\u0b4d"+
"\5\u01de\u00f0\2\u0b4d\u0b56\3\2\2\2\u0b4e\u0b4f\f\4\2\2\u0b4f\u0b50\7"+
"b\2\2\u0b50\u0b55\5\u01de\u00f0\2\u0b51\u0b52\f\3\2\2\u0b52\u0b53\7c\2"+
"\2\u0b53\u0b55\5\u01de\u00f0\2\u0b54\u0b4e\3\2\2\2\u0b54\u0b51\3\2\2\2"+
"\u0b55\u0b58\3\2\2\2\u0b56\u0b54\3\2\2\2\u0b56\u0b57\3\2\2\2\u0b57\u01dd"+
"\3\2\2\2\u0b58\u0b56\3\2\2\2\u0b59\u0b5a\b\u00f0\1\2\u0b5a\u0b5b\5\u01e0"+
"\u00f1\2\u0b5b\u0b67\3\2\2\2\u0b5c\u0b5d\f\5\2\2\u0b5d\u0b5e\7d\2\2\u0b5e"+
"\u0b66\5\u01e0\u00f1\2\u0b5f\u0b60\f\4\2\2\u0b60\u0b61\7e\2\2\u0b61\u0b66"+
"\5\u01e0\u00f1\2\u0b62\u0b63\f\3\2\2\u0b63\u0b64\7i\2\2\u0b64\u0b66\5"+
"\u01e0\u00f1\2\u0b65\u0b5c\3\2\2\2\u0b65\u0b5f\3\2\2\2\u0b65\u0b62\3\2"+
"\2\2\u0b66\u0b69\3\2\2\2\u0b67\u0b65\3\2\2\2\u0b67\u0b68\3\2\2\2\u0b68"+
"\u01df\3\2\2\2\u0b69\u0b67\3\2\2\2\u0b6a\u0b72\5\u01e2\u00f2\2\u0b6b\u0b72"+
"\5\u01e4\u00f3\2\u0b6c\u0b6d\7b\2\2\u0b6d\u0b72\5\u01e0\u00f1\2\u0b6e"+
"\u0b6f\7c\2\2\u0b6f\u0b72\5\u01e0\u00f1\2\u0b70\u0b72\5\u01e6\u00f4\2"+
"\u0b71\u0b6a\3\2\2\2\u0b71\u0b6b\3\2\2\2\u0b71\u0b6c\3\2\2\2\u0b71\u0b6e"+
"\3\2\2\2\u0b71\u0b70\3\2\2\2\u0b72\u01e1\3\2\2\2\u0b73\u0b74\7`\2\2\u0b74"+
"\u0b75\5\u01e0\u00f1\2\u0b75\u01e3\3\2\2\2\u0b76\u0b77\7a\2\2\u0b77\u0b78"+
"\5\u01e0\u00f1\2\u0b78\u01e5\3\2\2\2\u0b79\u0b80\5\u01e8\u00f5\2\u0b7a"+
"\u0b7b\7V\2\2\u0b7b\u0b80\5\u01e0\u00f1\2\u0b7c\u0b7d\7U\2\2\u0b7d\u0b80"+
"\5\u01e0\u00f1\2\u0b7e\u0b80\5\u01f2\u00fa\2\u0b7f\u0b79\3\2\2\2\u0b7f"+
"\u0b7a\3\2\2\2\u0b7f\u0b7c\3\2\2\2\u0b7f\u0b7e\3\2\2\2\u0b80\u01e7\3\2"+
"\2\2\u0b81\u0b84\5\u0178\u00bd\2\u0b82\u0b84\5<\37\2\u0b83\u0b81\3\2\2"+
"\2\u0b83\u0b82\3\2\2\2\u0b84\u0b89\3\2\2\2\u0b85\u0b88\5\u01ec\u00f7\2"+
"\u0b86\u0b88\5\u01f0\u00f9\2\u0b87\u0b85\3\2\2\2\u0b87\u0b86\3\2\2\2\u0b88"+
"\u0b8b\3\2\2\2\u0b89\u0b87\3\2\2\2\u0b89\u0b8a\3\2\2\2\u0b8a\u01e9\3\2"+
"\2\2\u0b8b\u0b89\3\2\2\2\u0b8c\u0b8d\5\u01e8\u00f5\2\u0b8d\u0b8e\7`\2"+
"\2\u0b8e\u01eb\3\2\2\2\u0b8f\u0b90\7`\2\2\u0b90\u01ed\3\2\2\2\u0b91\u0b92"+
"\5\u01e8\u00f5\2\u0b92\u0b93\7a\2\2\u0b93\u01ef\3\2\2\2\u0b94\u0b95\7"+
"a\2\2\u0b95\u01f1\3\2\2\2\u0b96\u0b97\7F\2\2\u0b97\u0b98\5\4\3\2\u0b98"+
"\u0b99\7G\2\2\u0b99\u0b9a\5\u01e0\u00f1\2\u0b9a\u0bb2\3\2\2\2\u0b9b\u0b9c"+
"\7F\2\2\u0b9c\u0ba0\5\f\7\2\u0b9d\u0b9f\5(\25\2\u0b9e\u0b9d\3\2\2\2\u0b9f"+
"\u0ba2\3\2\2\2\u0ba0\u0b9e\3\2\2\2\u0ba0\u0ba1\3\2\2\2\u0ba1\u0ba3\3\2"+
"\2\2\u0ba2\u0ba0\3\2\2\2\u0ba3\u0ba4\7G\2\2\u0ba4\u0ba5\5\u01e6\u00f4"+
"\2\u0ba5\u0bb2\3\2\2\2\u0ba6\u0ba7\7F\2\2\u0ba7\u0bab\5\f\7\2\u0ba8\u0baa"+
"\5(\25\2\u0ba9\u0ba8\3\2\2\2\u0baa\u0bad\3\2\2\2\u0bab\u0ba9\3\2\2\2\u0bab"+
"\u0bac\3\2\2\2\u0bac\u0bae\3\2\2\2\u0bad\u0bab\3\2\2\2\u0bae\u0baf\7G"+
"\2\2\u0baf\u0bb0\5\u01ba\u00de\2\u0bb0\u0bb2\3\2\2\2\u0bb1\u0b96\3\2\2"+
"\2\u0bb1\u0b9b\3\2\2\2\u0bb1\u0ba6\3\2\2\2\u0bb2\u01f3\3\2\2\2\u0bb3\u0bb4"+
"\t\7\2\2\u0bb4\u01f5\3\2\2\2\u0156\u01fb\u0202\u0206\u020a\u0213\u0217"+
"\u021b\u021d\u0223\u0228\u022f\u0234\u0236\u023c\u0241\u0246\u024b\u0256"+
"\u0264\u0269\u0271\u0278\u027e\u0283\u028e\u0291\u029f\u02a4\u02a9\u02ae"+
"\u02b4\u02be\u02c9\u02d1\u02db\u02e3\u02ef\u02f4\u02f7\u02fc\u0302\u030a"+
"\u0312\u031f\u033c\u0341\u0345\u034d\u0357\u035d\u036b\u036e\u037a\u037d"+
"\u038d\u0396\u039b\u03a1\u03a4\u03a7\u03b3\u03be\u03cc\u03d3\u03dc\u03e3"+
"\u03e8\u03f7\u03fe\u0404\u0408\u040c\u0410\u0414\u0419\u041d\u0421\u0423"+
"\u0428\u042f\u0434\u0436\u043c\u0441\u0445\u0458\u045d\u046d\u0472\u0478"+
"\u047e\u0480\u0484\u0489\u048d\u0495\u049c\u04a4\u04a7\u04ac\u04b4\u04b9"+
"\u04c0\u04c7\u04cc\u04d3\u04df\u04e4\u04e8\u04f2\u04f7\u04ff\u0502\u0507"+
"\u050f\u0512\u0517\u051c\u0521\u0526\u052d\u0532\u053a\u053f\u0544\u0549"+
"\u054f\u0555\u0558\u055b\u0564\u056a\u0570\u0573\u0576\u057e\u0583\u0588"+
"\u058e\u0591\u059c\u05a5\u05af\u05b4\u05bf\u05c4\u05d1\u05d6\u05e2\u05ec"+
"\u05f1\u05f9\u05fc\u0603\u060b\u0611\u061a\u0624\u0628\u062b\u0634\u0642"+
"\u0645\u064e\u0653\u065a\u065f\u0667\u0673\u067a\u0688\u069e\u06c0\u06cc"+
"\u06d2\u06dd\u06e9\u0703\u0707\u070c\u0710\u0714\u071c\u0720\u0724\u072b"+
"\u0734\u073c\u074b\u0757\u075d\u0763\u0778\u077d\u0782\u078d\u0798\u07a2"+
"\u07a5\u07aa\u07b3\u07b9\u07c2\u07c6\u07ca\u07cf\u07e2\u07ec\u0802\u0809"+
"\u0811\u0819\u0824\u083b\u0845\u0850\u0866\u086b\u0871\u0879\u087d\u0882"+
"\u088a\u0890\u0894\u0898\u089c\u08a2\u08a7\u08ac\u08b0\u08b4\u08ba\u08bf"+
"\u08c4\u08c8\u08cc\u08ce\u08d3\u08d8\u08dd\u08e1\u08e5\u08e9\u08ee\u08f6"+
"\u08fc\u0900\u0904\u0908\u090e\u0913\u0918\u091c\u0920\u0922\u0927\u0936"+
"\u0944\u0950\u0959\u0968\u0975\u097e\u0984\u098b\u0990\u0997\u099c\u09a3"+
"\u09a8\u09af\u09b4\u09bd\u09c2\u09c6\u09ca\u09cf\u09d6\u09dd\u09e2\u09e9"+
"\u09ee\u09f5\u09fa\u0a03\u0a08\u0a0c\u0a13\u0a19\u0a20\u0a27\u0a2e\u0a36"+
"\u0a3d\u0a45\u0a49\u0a50\u0a57\u0a5e\u0a66\u0a6d\u0a75\u0a7b\u0a81\u0a8d"+
"\u0a92\u0a97\u0aa2\u0aab\u0ab2\u0ab9\u0abe\u0ac2\u0acb\u0ad6\u0ad8\u0ae2"+
"\u0aed\u0af8\u0b03\u0b0e\u0b1a\u0b1c\u0b31\u0b33\u0b46\u0b48\u0b54\u0b56"+
"\u0b65\u0b67\u0b71\u0b7f\u0b83\u0b87\u0b89\u0ba0\u0bab\u0bb1";
public static final String _serializedATN = Utils.join(
new String[] {
_serializedATNSegment0,
_serializedATNSegment1
},
""
);
public static final ATN _ATN =
new ATNDeserializer().deserialize(_serializedATN.toCharArray());
static {
_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
}
}
}