// Generated from d:\shane\java-syntax-locator\packages\java\src\parser\JavaParser.g4 by ANTLR 4.9.2 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"}) public class JavaParser extends Parser { static { RuntimeMetaData.checkVersion("4.9.2", RuntimeMetaData.VERSION); } protected static final DFA[] _decisionToDFA; protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache(); public static final int ABSTRACT=1, ASSERT=2, BOOLEAN=3, BREAK=4, BYTE=5, CASE=6, CATCH=7, CHAR=8, CLASS=9, CONST=10, CONTINUE=11, DEFAULT=12, DO=13, DOUBLE=14, ELSE=15, ENUM=16, EXTENDS=17, FINAL=18, FINALLY=19, FLOAT=20, FOR=21, IF=22, GOTO=23, IMPLEMENTS=24, IMPORT=25, INSTANCEOF=26, INT=27, INTERFACE=28, LONG=29, NATIVE=30, NEW=31, PACKAGE=32, PRIVATE=33, PROTECTED=34, PUBLIC=35, RETURN=36, SHORT=37, STATIC=38, STRICTFP=39, SUPER=40, SWITCH=41, SYNCHRONIZED=42, THIS=43, THROW=44, THROWS=45, TRANSIENT=46, TRY=47, VOID=48, VOLATILE=49, WHILE=50, MODULE=51, OPEN=52, REQUIRES=53, EXPORTS=54, OPENS=55, TO=56, USES=57, PROVIDES=58, WITH=59, TRANSITIVE=60, VAR=61, YIELD=62, RECORD=63, SEALED=64, PERMITS=65, NON_SEALED=66, DECIMAL_LITERAL=67, HEX_LITERAL=68, OCT_LITERAL=69, BINARY_LITERAL=70, FLOAT_LITERAL=71, HEX_FLOAT_LITERAL=72, BOOL_LITERAL=73, CHAR_LITERAL=74, STRING_LITERAL=75, TEXT_BLOCK=76, NULL_LITERAL=77, LPAREN=78, RPAREN=79, LBRACE=80, RBRACE=81, LBRACK=82, RBRACK=83, SEMI=84, COMMA=85, DOT=86, ASSIGN=87, GT=88, LT=89, BANG=90, TILDE=91, QUESTION=92, COLON=93, EQUAL=94, LE=95, GE=96, NOTEQUAL=97, AND=98, OR=99, INC=100, DEC=101, ADD=102, SUB=103, MUL=104, DIV=105, BITAND=106, BITOR=107, CARET=108, MOD=109, ADD_ASSIGN=110, SUB_ASSIGN=111, MUL_ASSIGN=112, DIV_ASSIGN=113, AND_ASSIGN=114, OR_ASSIGN=115, XOR_ASSIGN=116, MOD_ASSIGN=117, LSHIFT_ASSIGN=118, RSHIFT_ASSIGN=119, URSHIFT_ASSIGN=120, ARROW=121, COLONCOLON=122, AT=123, ELLIPSIS=124, WS=125, COMMENT=126, LINE_COMMENT=127, IDENTIFIER=128; public static final int RULE_compilationUnit = 0, RULE_packageDeclaration = 1, RULE_importDeclaration = 2, RULE_typeDeclaration = 3, RULE_modifier = 4, RULE_classOrInterfaceModifier = 5, RULE_variableModifier = 6, RULE_classDeclaration = 7, RULE_typeParameters = 8, RULE_typeParameter = 9, RULE_typeBound = 10, RULE_enumDeclaration = 11, RULE_enumConstants = 12, RULE_enumConstant = 13, RULE_enumBodyDeclarations = 14, RULE_interfaceDeclaration = 15, RULE_classBody = 16, RULE_interfaceBody = 17, RULE_classBodyDeclaration = 18, RULE_memberDeclaration = 19, RULE_methodDeclaration = 20, RULE_methodBody = 21, RULE_typeTypeOrVoid = 22, RULE_genericMethodDeclaration = 23, RULE_genericConstructorDeclaration = 24, RULE_constructorDeclaration = 25, RULE_compactConstructorDeclaration = 26, RULE_fieldDeclaration = 27, RULE_interfaceBodyDeclaration = 28, RULE_interfaceMemberDeclaration = 29, RULE_constDeclaration = 30, RULE_constantDeclarator = 31, RULE_interfaceMethodDeclaration = 32, RULE_interfaceMethodModifier = 33, RULE_genericInterfaceMethodDeclaration = 34, RULE_interfaceCommonBodyDeclaration = 35, RULE_variableDeclarators = 36, RULE_variableDeclarator = 37, RULE_variableDeclaratorId = 38, RULE_variableInitializer = 39, RULE_arrayInitializer = 40, RULE_classOrInterfaceType = 41, RULE_typeArgument = 42, RULE_qualifiedNameList = 43, RULE_formalParameters = 44, RULE_receiverParameter = 45, RULE_formalParameterList = 46, RULE_formalParameter = 47, RULE_lastFormalParameter = 48, RULE_lambdaLVTIList = 49, RULE_lambdaLVTIParameter = 50, RULE_qualifiedName = 51, RULE_literal = 52, RULE_integerLiteral = 53, RULE_floatLiteral = 54, RULE_altAnnotationQualifiedName = 55, RULE_annotation = 56, RULE_elementValuePairs = 57, RULE_elementValuePair = 58, RULE_elementValue = 59, RULE_elementValueArrayInitializer = 60, RULE_annotationTypeDeclaration = 61, RULE_annotationTypeBody = 62, RULE_annotationTypeElementDeclaration = 63, RULE_annotationTypeElementRest = 64, RULE_annotationMethodOrConstantRest = 65, RULE_annotationMethodRest = 66, RULE_annotationConstantRest = 67, RULE_defaultValue = 68, RULE_moduleDeclaration = 69, RULE_moduleBody = 70, RULE_moduleDirective = 71, RULE_requiresModifier = 72, RULE_recordDeclaration = 73, RULE_recordHeader = 74, RULE_recordComponentList = 75, RULE_recordComponent = 76, RULE_recordBody = 77, RULE_block = 78, RULE_blockStatement = 79, RULE_localVariableDeclaration = 80, RULE_identifier = 81, RULE_typeIdentifier = 82, RULE_localTypeDeclaration = 83, RULE_statement = 84, RULE_catchClause = 85, RULE_catchType = 86, RULE_finallyBlock = 87, RULE_resourceSpecification = 88, RULE_resources = 89, RULE_resource = 90, RULE_switchBlockStatementGroup = 91, RULE_switchLabel = 92, RULE_forControl = 93, RULE_forInit = 94, RULE_enhancedForControl = 95, RULE_parExpression = 96, RULE_expressionList = 97, RULE_methodCall = 98, RULE_expression = 99, RULE_pattern = 100, RULE_lambdaExpression = 101, RULE_lambdaParameters = 102, RULE_lambdaBody = 103, RULE_primary = 104, RULE_switchExpression = 105, RULE_switchLabeledRule = 106, RULE_guardedPattern = 107, RULE_switchRuleOutcome = 108, RULE_classType = 109, RULE_creator = 110, RULE_createdName = 111, RULE_innerCreator = 112, RULE_arrayCreatorRest = 113, RULE_classCreatorRest = 114, RULE_explicitGenericInvocation = 115, RULE_typeArgumentsOrDiamond = 116, RULE_nonWildcardTypeArgumentsOrDiamond = 117, RULE_nonWildcardTypeArguments = 118, RULE_typeList = 119, RULE_typeType = 120, RULE_primitiveType = 121, RULE_typeArguments = 122, RULE_superSuffix = 123, RULE_explicitGenericInvocationSuffix = 124, RULE_arguments = 125; private static String[] makeRuleNames() { return new String[] { "compilationUnit", "packageDeclaration", "importDeclaration", "typeDeclaration", "modifier", "classOrInterfaceModifier", "variableModifier", "classDeclaration", "typeParameters", "typeParameter", "typeBound", "enumDeclaration", "enumConstants", "enumConstant", "enumBodyDeclarations", "interfaceDeclaration", "classBody", "interfaceBody", "classBodyDeclaration", "memberDeclaration", "methodDeclaration", "methodBody", "typeTypeOrVoid", "genericMethodDeclaration", "genericConstructorDeclaration", "constructorDeclaration", "compactConstructorDeclaration", "fieldDeclaration", "interfaceBodyDeclaration", "interfaceMemberDeclaration", "constDeclaration", "constantDeclarator", "interfaceMethodDeclaration", "interfaceMethodModifier", "genericInterfaceMethodDeclaration", "interfaceCommonBodyDeclaration", "variableDeclarators", "variableDeclarator", "variableDeclaratorId", "variableInitializer", "arrayInitializer", "classOrInterfaceType", "typeArgument", "qualifiedNameList", "formalParameters", "receiverParameter", "formalParameterList", "formalParameter", "lastFormalParameter", "lambdaLVTIList", "lambdaLVTIParameter", "qualifiedName", "literal", "integerLiteral", "floatLiteral", "altAnnotationQualifiedName", "annotation", "elementValuePairs", "elementValuePair", "elementValue", "elementValueArrayInitializer", "annotationTypeDeclaration", "annotationTypeBody", "annotationTypeElementDeclaration", "annotationTypeElementRest", "annotationMethodOrConstantRest", "annotationMethodRest", "annotationConstantRest", "defaultValue", "moduleDeclaration", "moduleBody", "moduleDirective", "requiresModifier", "recordDeclaration", "recordHeader", "recordComponentList", "recordComponent", "recordBody", "block", "blockStatement", "localVariableDeclaration", "identifier", "typeIdentifier", "localTypeDeclaration", "statement", "catchClause", "catchType", "finallyBlock", "resourceSpecification", "resources", "resource", "switchBlockStatementGroup", "switchLabel", "forControl", "forInit", "enhancedForControl", "parExpression", "expressionList", "methodCall", "expression", "pattern", "lambdaExpression", "lambdaParameters", "lambdaBody", "primary", "switchExpression", "switchLabeledRule", "guardedPattern", "switchRuleOutcome", "classType", "creator", "createdName", "innerCreator", "arrayCreatorRest", "classCreatorRest", "explicitGenericInvocation", "typeArgumentsOrDiamond", "nonWildcardTypeArgumentsOrDiamond", "nonWildcardTypeArguments", "typeList", "typeType", "primitiveType", "typeArguments", "superSuffix", "explicitGenericInvocationSuffix", "arguments" }; } public static final String[] ruleNames = makeRuleNames(); private static String[] makeLiteralNames() { return new String[] { 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'", "'module'", "'open'", "'requires'", "'exports'", "'opens'", "'to'", "'uses'", "'provides'", "'with'", "'transitive'", "'var'", "'yield'", "'record'", "'sealed'", "'permits'", "'non-sealed'", null, null, null, null, null, null, null, null, null, null, "'null'", "'('", "')'", "'{'", "'}'", "'['", "']'", "';'", "','", "'.'", "'='", "'>'", "'<'", "'!'", "'~'", "'?'", "':'", "'=='", "'<='", "'>='", "'!='", "'&&'", "'||'", "'++'", "'--'", "'+'", "'-'", "'*'", "'/'", "'&'", "'|'", "'^'", "'%'", "'+='", "'-='", "'*='", "'/='", "'&='", "'|='", "'^='", "'%='", "'<<='", "'>>='", "'>>>='", "'->'", "'::'", "'@'", "'...'" }; } private static final String[] _LITERAL_NAMES = makeLiteralNames(); private static String[] makeSymbolicNames() { return new String[] { 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", "MODULE", "OPEN", "REQUIRES", "EXPORTS", "OPENS", "TO", "USES", "PROVIDES", "WITH", "TRANSITIVE", "VAR", "YIELD", "RECORD", "SEALED", "PERMITS", "NON_SEALED", "DECIMAL_LITERAL", "HEX_LITERAL", "OCT_LITERAL", "BINARY_LITERAL", "FLOAT_LITERAL", "HEX_FLOAT_LITERAL", "BOOL_LITERAL", "CHAR_LITERAL", "STRING_LITERAL", "TEXT_BLOCK", "NULL_LITERAL", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", "SEMI", "COMMA", "DOT", "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTION", "COLON", "EQUAL", "LE", "GE", "NOTEQUAL", "AND", "OR", "INC", "DEC", "ADD", "SUB", "MUL", "DIV", "BITAND", "BITOR", "CARET", "MOD", "ADD_ASSIGN", "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", "MOD_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN", "URSHIFT_ASSIGN", "ARROW", "COLONCOLON", "AT", "ELLIPSIS", "WS", "COMMENT", "LINE_COMMENT", "IDENTIFIER" }; } private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); 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] = ""; } } } @Override @Deprecated public String[] getTokenNames() { return tokenNames; } @Override public Vocabulary getVocabulary() { return VOCABULARY; } @Override public String getGrammarFileName() { return "JavaParser.g4"; } @Override public String[] getRuleNames() { return ruleNames; } @Override public String getSerializedATN() { return _serializedATN; } @Override public ATN getATN() { return _ATN; } public JavaParser(TokenStream input) { super(input); _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); } public static class CompilationUnitContext extends ParserRuleContext { public PackageDeclarationContext packageDeclaration() { return getRuleContext(PackageDeclarationContext.class,0); } public List importDeclaration() { return getRuleContexts(ImportDeclarationContext.class); } public ImportDeclarationContext importDeclaration(int i) { return getRuleContext(ImportDeclarationContext.class,i); } public List SEMI() { return getTokens(JavaParser.SEMI); } public TerminalNode SEMI(int i) { return getToken(JavaParser.SEMI, i); } public List typeDeclaration() { return getRuleContexts(TypeDeclarationContext.class); } public TypeDeclarationContext typeDeclaration(int i) { return getRuleContext(TypeDeclarationContext.class,i); } public ModuleDeclarationContext moduleDeclaration() { return getRuleContext(ModuleDeclarationContext.class,0); } public TerminalNode EOF() { return getToken(JavaParser.EOF, 0); } public CompilationUnitContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_compilationUnit; } } public final CompilationUnitContext compilationUnit() throws RecognitionException { CompilationUnitContext _localctx = new CompilationUnitContext(_ctx, getState()); enterRule(_localctx, 0, RULE_compilationUnit); int _la; try { int _alt; setState(272); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { setState(253); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) { case 1: { setState(252); packageDeclaration(); } break; } setState(259); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,2,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { setState(257); _errHandler.sync(this); switch (_input.LA(1)) { case IMPORT: { setState(255); importDeclaration(); } break; case SEMI: { setState(256); match(SEMI); } break; default: throw new NoViableAltException(this); } } } setState(261); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,2,_ctx); } setState(266); _errHandler.sync(this); _la = _input.LA(1); while (((((_la - 1)) & ~0x3f) == 0 && ((1L << (_la - 1)) & ((1L << (ABSTRACT - 1)) | (1L << (CLASS - 1)) | (1L << (ENUM - 1)) | (1L << (FINAL - 1)) | (1L << (INTERFACE - 1)) | (1L << (PRIVATE - 1)) | (1L << (PROTECTED - 1)) | (1L << (PUBLIC - 1)) | (1L << (STATIC - 1)) | (1L << (STRICTFP - 1)) | (1L << (MODULE - 1)) | (1L << (OPEN - 1)) | (1L << (REQUIRES - 1)) | (1L << (EXPORTS - 1)) | (1L << (OPENS - 1)) | (1L << (TO - 1)) | (1L << (USES - 1)) | (1L << (PROVIDES - 1)) | (1L << (WITH - 1)) | (1L << (TRANSITIVE - 1)) | (1L << (VAR - 1)) | (1L << (YIELD - 1)) | (1L << (RECORD - 1)) | (1L << (SEALED - 1)))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (PERMITS - 65)) | (1L << (NON_SEALED - 65)) | (1L << (SEMI - 65)) | (1L << (AT - 65)) | (1L << (IDENTIFIER - 65)))) != 0)) { { setState(264); _errHandler.sync(this); switch (_input.LA(1)) { case ABSTRACT: case CLASS: case ENUM: case FINAL: case INTERFACE: case PRIVATE: case PROTECTED: case PUBLIC: case STATIC: case STRICTFP: case MODULE: case OPEN: case REQUIRES: case EXPORTS: case OPENS: case TO: case USES: case PROVIDES: case WITH: case TRANSITIVE: case VAR: case YIELD: case RECORD: case SEALED: case PERMITS: case NON_SEALED: case AT: case IDENTIFIER: { setState(262); typeDeclaration(); } break; case SEMI: { setState(263); match(SEMI); } break; default: throw new NoViableAltException(this); } } setState(268); _errHandler.sync(this); _la = _input.LA(1); } } break; case 2: enterOuterAlt(_localctx, 2); { setState(269); moduleDeclaration(); setState(270); match(EOF); } break; } } 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 TerminalNode PACKAGE() { return getToken(JavaParser.PACKAGE, 0); } public QualifiedNameContext qualifiedName() { return getRuleContext(QualifiedNameContext.class,0); } public TerminalNode SEMI() { return getToken(JavaParser.SEMI, 0); } public List annotation() { return getRuleContexts(AnnotationContext.class); } public AnnotationContext annotation(int i) { return getRuleContext(AnnotationContext.class,i); } public PackageDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_packageDeclaration; } } public final PackageDeclarationContext packageDeclaration() throws RecognitionException { PackageDeclarationContext _localctx = new PackageDeclarationContext(_ctx, getState()); enterRule(_localctx, 2, RULE_packageDeclaration); int _la; try { enterOuterAlt(_localctx, 1); { setState(277); _errHandler.sync(this); _la = _input.LA(1); while (((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & ((1L << (MODULE - 51)) | (1L << (OPEN - 51)) | (1L << (REQUIRES - 51)) | (1L << (EXPORTS - 51)) | (1L << (OPENS - 51)) | (1L << (TO - 51)) | (1L << (USES - 51)) | (1L << (PROVIDES - 51)) | (1L << (WITH - 51)) | (1L << (TRANSITIVE - 51)) | (1L << (VAR - 51)) | (1L << (YIELD - 51)) | (1L << (RECORD - 51)) | (1L << (SEALED - 51)) | (1L << (PERMITS - 51)))) != 0) || _la==AT || _la==IDENTIFIER) { { { setState(274); annotation(); } } setState(279); _errHandler.sync(this); _la = _input.LA(1); } setState(280); match(PACKAGE); setState(281); qualifiedName(); setState(282); match(SEMI); } } 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 TerminalNode IMPORT() { return getToken(JavaParser.IMPORT, 0); } public QualifiedNameContext qualifiedName() { return getRuleContext(QualifiedNameContext.class,0); } public TerminalNode SEMI() { return getToken(JavaParser.SEMI, 0); } public TerminalNode STATIC() { return getToken(JavaParser.STATIC, 0); } public TerminalNode DOT() { return getToken(JavaParser.DOT, 0); } public TerminalNode MUL() { return getToken(JavaParser.MUL, 0); } public ImportDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_importDeclaration; } } public final ImportDeclarationContext importDeclaration() throws RecognitionException { ImportDeclarationContext _localctx = new ImportDeclarationContext(_ctx, getState()); enterRule(_localctx, 4, RULE_importDeclaration); int _la; try { enterOuterAlt(_localctx, 1); { setState(284); match(IMPORT); setState(286); _errHandler.sync(this); _la = _input.LA(1); if (_la==STATIC) { { setState(285); match(STATIC); } } setState(288); qualifiedName(); setState(291); _errHandler.sync(this); _la = _input.LA(1); if (_la==DOT) { { setState(289); match(DOT); setState(290); match(MUL); } } setState(293); 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 EnumDeclarationContext enumDeclaration() { return getRuleContext(EnumDeclarationContext.class,0); } public InterfaceDeclarationContext interfaceDeclaration() { return getRuleContext(InterfaceDeclarationContext.class,0); } public AnnotationTypeDeclarationContext annotationTypeDeclaration() { return getRuleContext(AnnotationTypeDeclarationContext.class,0); } public RecordDeclarationContext recordDeclaration() { return getRuleContext(RecordDeclarationContext.class,0); } public List classOrInterfaceModifier() { return getRuleContexts(ClassOrInterfaceModifierContext.class); } public ClassOrInterfaceModifierContext classOrInterfaceModifier(int i) { return getRuleContext(ClassOrInterfaceModifierContext.class,i); } public TypeDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_typeDeclaration; } } public final TypeDeclarationContext typeDeclaration() throws RecognitionException { TypeDeclarationContext _localctx = new TypeDeclarationContext(_ctx, getState()); enterRule(_localctx, 6, RULE_typeDeclaration); try { int _alt; enterOuterAlt(_localctx, 1); { setState(298); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,9,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(295); classOrInterfaceModifier(); } } } setState(300); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,9,_ctx); } setState(306); _errHandler.sync(this); switch (_input.LA(1)) { case CLASS: { setState(301); classDeclaration(); } break; case ENUM: { setState(302); enumDeclaration(); } break; case INTERFACE: { setState(303); interfaceDeclaration(); } break; case AT: { setState(304); annotationTypeDeclaration(); } break; case RECORD: { setState(305); recordDeclaration(); } 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 ModifierContext extends ParserRuleContext { public ClassOrInterfaceModifierContext classOrInterfaceModifier() { return getRuleContext(ClassOrInterfaceModifierContext.class,0); } public TerminalNode NATIVE() { return getToken(JavaParser.NATIVE, 0); } public TerminalNode SYNCHRONIZED() { return getToken(JavaParser.SYNCHRONIZED, 0); } public TerminalNode TRANSIENT() { return getToken(JavaParser.TRANSIENT, 0); } public TerminalNode VOLATILE() { return getToken(JavaParser.VOLATILE, 0); } public ModifierContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_modifier; } } public final ModifierContext modifier() throws RecognitionException { ModifierContext _localctx = new ModifierContext(_ctx, getState()); enterRule(_localctx, 8, RULE_modifier); try { setState(313); _errHandler.sync(this); switch (_input.LA(1)) { case ABSTRACT: case FINAL: case PRIVATE: case PROTECTED: case PUBLIC: case STATIC: case STRICTFP: case MODULE: case OPEN: case REQUIRES: case EXPORTS: case OPENS: case TO: case USES: case PROVIDES: case WITH: case TRANSITIVE: case VAR: case YIELD: case RECORD: case SEALED: case PERMITS: case NON_SEALED: case AT: case IDENTIFIER: enterOuterAlt(_localctx, 1); { setState(308); classOrInterfaceModifier(); } break; case NATIVE: enterOuterAlt(_localctx, 2); { setState(309); match(NATIVE); } break; case SYNCHRONIZED: enterOuterAlt(_localctx, 3); { setState(310); match(SYNCHRONIZED); } break; case TRANSIENT: enterOuterAlt(_localctx, 4); { setState(311); match(TRANSIENT); } break; case VOLATILE: enterOuterAlt(_localctx, 5); { setState(312); 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 ClassOrInterfaceModifierContext extends ParserRuleContext { public AnnotationContext annotation() { return getRuleContext(AnnotationContext.class,0); } public TerminalNode PUBLIC() { return getToken(JavaParser.PUBLIC, 0); } public TerminalNode PROTECTED() { return getToken(JavaParser.PROTECTED, 0); } public TerminalNode PRIVATE() { return getToken(JavaParser.PRIVATE, 0); } public TerminalNode STATIC() { return getToken(JavaParser.STATIC, 0); } public TerminalNode ABSTRACT() { return getToken(JavaParser.ABSTRACT, 0); } public TerminalNode FINAL() { return getToken(JavaParser.FINAL, 0); } public TerminalNode STRICTFP() { return getToken(JavaParser.STRICTFP, 0); } public TerminalNode SEALED() { return getToken(JavaParser.SEALED, 0); } public TerminalNode NON_SEALED() { return getToken(JavaParser.NON_SEALED, 0); } public ClassOrInterfaceModifierContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_classOrInterfaceModifier; } } public final ClassOrInterfaceModifierContext classOrInterfaceModifier() throws RecognitionException { ClassOrInterfaceModifierContext _localctx = new ClassOrInterfaceModifierContext(_ctx, getState()); enterRule(_localctx, 10, RULE_classOrInterfaceModifier); try { setState(325); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { setState(315); annotation(); } break; case 2: enterOuterAlt(_localctx, 2); { setState(316); match(PUBLIC); } break; case 3: enterOuterAlt(_localctx, 3); { setState(317); match(PROTECTED); } break; case 4: enterOuterAlt(_localctx, 4); { setState(318); match(PRIVATE); } break; case 5: enterOuterAlt(_localctx, 5); { setState(319); match(STATIC); } break; case 6: enterOuterAlt(_localctx, 6); { setState(320); match(ABSTRACT); } break; case 7: enterOuterAlt(_localctx, 7); { setState(321); match(FINAL); } break; case 8: enterOuterAlt(_localctx, 8); { setState(322); match(STRICTFP); } break; case 9: enterOuterAlt(_localctx, 9); { setState(323); match(SEALED); } break; case 10: enterOuterAlt(_localctx, 10); { setState(324); match(NON_SEALED); } break; } } 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 TerminalNode FINAL() { return getToken(JavaParser.FINAL, 0); } public AnnotationContext annotation() { return getRuleContext(AnnotationContext.class,0); } public VariableModifierContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_variableModifier; } } public final VariableModifierContext variableModifier() throws RecognitionException { VariableModifierContext _localctx = new VariableModifierContext(_ctx, getState()); enterRule(_localctx, 12, RULE_variableModifier); try { setState(329); _errHandler.sync(this); switch (_input.LA(1)) { case FINAL: enterOuterAlt(_localctx, 1); { setState(327); match(FINAL); } break; case MODULE: case OPEN: case REQUIRES: case EXPORTS: case OPENS: case TO: case USES: case PROVIDES: case WITH: case TRANSITIVE: case VAR: case YIELD: case RECORD: case SEALED: case PERMITS: case AT: case IDENTIFIER: enterOuterAlt(_localctx, 2); { setState(328); annotation(); } 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 ClassDeclarationContext extends ParserRuleContext { public TerminalNode CLASS() { return getToken(JavaParser.CLASS, 0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public ClassBodyContext classBody() { return getRuleContext(ClassBodyContext.class,0); } public TypeParametersContext typeParameters() { return getRuleContext(TypeParametersContext.class,0); } public TerminalNode EXTENDS() { return getToken(JavaParser.EXTENDS, 0); } public TypeTypeContext typeType() { return getRuleContext(TypeTypeContext.class,0); } public TerminalNode IMPLEMENTS() { return getToken(JavaParser.IMPLEMENTS, 0); } public List typeList() { return getRuleContexts(TypeListContext.class); } public TypeListContext typeList(int i) { return getRuleContext(TypeListContext.class,i); } public TerminalNode PERMITS() { return getToken(JavaParser.PERMITS, 0); } public ClassDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_classDeclaration; } } public final ClassDeclarationContext classDeclaration() throws RecognitionException { ClassDeclarationContext _localctx = new ClassDeclarationContext(_ctx, getState()); enterRule(_localctx, 14, RULE_classDeclaration); int _la; try { enterOuterAlt(_localctx, 1); { setState(331); match(CLASS); setState(332); identifier(); setState(334); _errHandler.sync(this); _la = _input.LA(1); if (_la==LT) { { setState(333); typeParameters(); } } setState(338); _errHandler.sync(this); _la = _input.LA(1); if (_la==EXTENDS) { { setState(336); match(EXTENDS); setState(337); typeType(); } } setState(342); _errHandler.sync(this); _la = _input.LA(1); if (_la==IMPLEMENTS) { { setState(340); match(IMPLEMENTS); setState(341); typeList(); } } setState(346); _errHandler.sync(this); _la = _input.LA(1); if (_la==PERMITS) { { setState(344); match(PERMITS); setState(345); typeList(); } } setState(348); classBody(); } } 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 TerminalNode LT() { return getToken(JavaParser.LT, 0); } public List typeParameter() { return getRuleContexts(TypeParameterContext.class); } public TypeParameterContext typeParameter(int i) { return getRuleContext(TypeParameterContext.class,i); } public TerminalNode GT() { return getToken(JavaParser.GT, 0); } public List COMMA() { return getTokens(JavaParser.COMMA); } public TerminalNode COMMA(int i) { return getToken(JavaParser.COMMA, i); } public TypeParametersContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_typeParameters; } } public final TypeParametersContext typeParameters() throws RecognitionException { TypeParametersContext _localctx = new TypeParametersContext(_ctx, getState()); enterRule(_localctx, 16, RULE_typeParameters); int _la; try { enterOuterAlt(_localctx, 1); { setState(350); match(LT); setState(351); typeParameter(); setState(356); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { setState(352); match(COMMA); setState(353); typeParameter(); } } setState(358); _errHandler.sync(this); _la = _input.LA(1); } setState(359); match(GT); } } 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 annotation() { return getRuleContexts(AnnotationContext.class); } public AnnotationContext annotation(int i) { return getRuleContext(AnnotationContext.class,i); } public TerminalNode EXTENDS() { return getToken(JavaParser.EXTENDS, 0); } public TypeBoundContext typeBound() { return getRuleContext(TypeBoundContext.class,0); } public TypeParameterContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_typeParameter; } } public final TypeParameterContext typeParameter() throws RecognitionException { TypeParameterContext _localctx = new TypeParameterContext(_ctx, getState()); enterRule(_localctx, 18, RULE_typeParameter); int _la; try { int _alt; enterOuterAlt(_localctx, 1); { setState(364); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,19,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(361); annotation(); } } } setState(366); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,19,_ctx); } setState(367); identifier(); setState(376); _errHandler.sync(this); _la = _input.LA(1); if (_la==EXTENDS) { { setState(368); match(EXTENDS); setState(372); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,20,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(369); annotation(); } } } setState(374); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,20,_ctx); } setState(375); typeBound(); } } } } 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 List typeType() { return getRuleContexts(TypeTypeContext.class); } public TypeTypeContext typeType(int i) { return getRuleContext(TypeTypeContext.class,i); } public List BITAND() { return getTokens(JavaParser.BITAND); } public TerminalNode BITAND(int i) { return getToken(JavaParser.BITAND, i); } public TypeBoundContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_typeBound; } } public final TypeBoundContext typeBound() throws RecognitionException { TypeBoundContext _localctx = new TypeBoundContext(_ctx, getState()); enterRule(_localctx, 20, RULE_typeBound); int _la; try { enterOuterAlt(_localctx, 1); { setState(378); typeType(); setState(383); _errHandler.sync(this); _la = _input.LA(1); while (_la==BITAND) { { { setState(379); match(BITAND); setState(380); typeType(); } } setState(385); _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 EnumDeclarationContext extends ParserRuleContext { public TerminalNode ENUM() { return getToken(JavaParser.ENUM, 0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public TerminalNode LBRACE() { return getToken(JavaParser.LBRACE, 0); } public TerminalNode RBRACE() { return getToken(JavaParser.RBRACE, 0); } public TerminalNode IMPLEMENTS() { return getToken(JavaParser.IMPLEMENTS, 0); } public TypeListContext typeList() { return getRuleContext(TypeListContext.class,0); } public EnumConstantsContext enumConstants() { return getRuleContext(EnumConstantsContext.class,0); } public TerminalNode COMMA() { return getToken(JavaParser.COMMA, 0); } public EnumBodyDeclarationsContext enumBodyDeclarations() { return getRuleContext(EnumBodyDeclarationsContext.class,0); } public EnumDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_enumDeclaration; } } public final EnumDeclarationContext enumDeclaration() throws RecognitionException { EnumDeclarationContext _localctx = new EnumDeclarationContext(_ctx, getState()); enterRule(_localctx, 22, RULE_enumDeclaration); int _la; try { enterOuterAlt(_localctx, 1); { setState(386); match(ENUM); setState(387); identifier(); setState(390); _errHandler.sync(this); _la = _input.LA(1); if (_la==IMPLEMENTS) { { setState(388); match(IMPLEMENTS); setState(389); typeList(); } } setState(392); match(LBRACE); setState(394); _errHandler.sync(this); _la = _input.LA(1); if (((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & ((1L << (MODULE - 51)) | (1L << (OPEN - 51)) | (1L << (REQUIRES - 51)) | (1L << (EXPORTS - 51)) | (1L << (OPENS - 51)) | (1L << (TO - 51)) | (1L << (USES - 51)) | (1L << (PROVIDES - 51)) | (1L << (WITH - 51)) | (1L << (TRANSITIVE - 51)) | (1L << (VAR - 51)) | (1L << (YIELD - 51)) | (1L << (RECORD - 51)) | (1L << (SEALED - 51)) | (1L << (PERMITS - 51)))) != 0) || _la==AT || _la==IDENTIFIER) { { setState(393); enumConstants(); } } setState(397); _errHandler.sync(this); _la = _input.LA(1); if (_la==COMMA) { { setState(396); match(COMMA); } } setState(400); _errHandler.sync(this); _la = _input.LA(1); if (_la==SEMI) { { setState(399); enumBodyDeclarations(); } } setState(402); match(RBRACE); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class EnumConstantsContext extends ParserRuleContext { public List enumConstant() { return getRuleContexts(EnumConstantContext.class); } public EnumConstantContext enumConstant(int i) { return getRuleContext(EnumConstantContext.class,i); } public List COMMA() { return getTokens(JavaParser.COMMA); } public TerminalNode COMMA(int i) { return getToken(JavaParser.COMMA, i); } public EnumConstantsContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_enumConstants; } } public final EnumConstantsContext enumConstants() throws RecognitionException { EnumConstantsContext _localctx = new EnumConstantsContext(_ctx, getState()); enterRule(_localctx, 24, RULE_enumConstants); try { int _alt; enterOuterAlt(_localctx, 1); { setState(404); enumConstant(); setState(409); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,27,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(405); match(COMMA); setState(406); enumConstant(); } } } setState(411); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,27,_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 annotation() { return getRuleContexts(AnnotationContext.class); } public AnnotationContext annotation(int i) { return getRuleContext(AnnotationContext.class,i); } public ArgumentsContext arguments() { return getRuleContext(ArgumentsContext.class,0); } public ClassBodyContext classBody() { return getRuleContext(ClassBodyContext.class,0); } public EnumConstantContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_enumConstant; } } public final EnumConstantContext enumConstant() throws RecognitionException { EnumConstantContext _localctx = new EnumConstantContext(_ctx, getState()); enterRule(_localctx, 26, RULE_enumConstant); int _la; try { int _alt; enterOuterAlt(_localctx, 1); { setState(415); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,28,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(412); annotation(); } } } setState(417); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,28,_ctx); } setState(418); identifier(); setState(420); _errHandler.sync(this); _la = _input.LA(1); if (_la==LPAREN) { { setState(419); arguments(); } } setState(423); _errHandler.sync(this); _la = _input.LA(1); if (_la==LBRACE) { { setState(422); classBody(); } } } } 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 TerminalNode SEMI() { return getToken(JavaParser.SEMI, 0); } public List 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; } } public final EnumBodyDeclarationsContext enumBodyDeclarations() throws RecognitionException { EnumBodyDeclarationsContext _localctx = new EnumBodyDeclarationsContext(_ctx, getState()); enterRule(_localctx, 28, RULE_enumBodyDeclarations); int _la; try { enterOuterAlt(_localctx, 1); { setState(425); match(SEMI); setState(429); _errHandler.sync(this); _la = _input.LA(1); while (((((_la - 1)) & ~0x3f) == 0 && ((1L << (_la - 1)) & ((1L << (ABSTRACT - 1)) | (1L << (BOOLEAN - 1)) | (1L << (BYTE - 1)) | (1L << (CHAR - 1)) | (1L << (CLASS - 1)) | (1L << (DOUBLE - 1)) | (1L << (ENUM - 1)) | (1L << (FINAL - 1)) | (1L << (FLOAT - 1)) | (1L << (INT - 1)) | (1L << (INTERFACE - 1)) | (1L << (LONG - 1)) | (1L << (NATIVE - 1)) | (1L << (PRIVATE - 1)) | (1L << (PROTECTED - 1)) | (1L << (PUBLIC - 1)) | (1L << (SHORT - 1)) | (1L << (STATIC - 1)) | (1L << (STRICTFP - 1)) | (1L << (SYNCHRONIZED - 1)) | (1L << (TRANSIENT - 1)) | (1L << (VOID - 1)) | (1L << (VOLATILE - 1)) | (1L << (MODULE - 1)) | (1L << (OPEN - 1)) | (1L << (REQUIRES - 1)) | (1L << (EXPORTS - 1)) | (1L << (OPENS - 1)) | (1L << (TO - 1)) | (1L << (USES - 1)) | (1L << (PROVIDES - 1)) | (1L << (WITH - 1)) | (1L << (TRANSITIVE - 1)) | (1L << (VAR - 1)) | (1L << (YIELD - 1)) | (1L << (RECORD - 1)) | (1L << (SEALED - 1)))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (PERMITS - 65)) | (1L << (NON_SEALED - 65)) | (1L << (LBRACE - 65)) | (1L << (SEMI - 65)) | (1L << (LT - 65)) | (1L << (AT - 65)) | (1L << (IDENTIFIER - 65)))) != 0)) { { { setState(426); classBodyDeclaration(); } } setState(431); _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 TerminalNode INTERFACE() { return getToken(JavaParser.INTERFACE, 0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public InterfaceBodyContext interfaceBody() { return getRuleContext(InterfaceBodyContext.class,0); } public TypeParametersContext typeParameters() { return getRuleContext(TypeParametersContext.class,0); } public TerminalNode EXTENDS() { return getToken(JavaParser.EXTENDS, 0); } public List typeList() { return getRuleContexts(TypeListContext.class); } public TypeListContext typeList(int i) { return getRuleContext(TypeListContext.class,i); } public TerminalNode PERMITS() { return getToken(JavaParser.PERMITS, 0); } public InterfaceDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_interfaceDeclaration; } } public final InterfaceDeclarationContext interfaceDeclaration() throws RecognitionException { InterfaceDeclarationContext _localctx = new InterfaceDeclarationContext(_ctx, getState()); enterRule(_localctx, 30, RULE_interfaceDeclaration); int _la; try { enterOuterAlt(_localctx, 1); { setState(432); match(INTERFACE); setState(433); identifier(); setState(435); _errHandler.sync(this); _la = _input.LA(1); if (_la==LT) { { setState(434); typeParameters(); } } setState(439); _errHandler.sync(this); _la = _input.LA(1); if (_la==EXTENDS) { { setState(437); match(EXTENDS); setState(438); typeList(); } } setState(443); _errHandler.sync(this); _la = _input.LA(1); if (_la==PERMITS) { { setState(441); match(PERMITS); setState(442); typeList(); } } setState(445); interfaceBody(); } } 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 TerminalNode LBRACE() { return getToken(JavaParser.LBRACE, 0); } public TerminalNode RBRACE() { return getToken(JavaParser.RBRACE, 0); } public List 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; } } public final ClassBodyContext classBody() throws RecognitionException { ClassBodyContext _localctx = new ClassBodyContext(_ctx, getState()); enterRule(_localctx, 32, RULE_classBody); int _la; try { enterOuterAlt(_localctx, 1); { setState(447); match(LBRACE); setState(451); _errHandler.sync(this); _la = _input.LA(1); while (((((_la - 1)) & ~0x3f) == 0 && ((1L << (_la - 1)) & ((1L << (ABSTRACT - 1)) | (1L << (BOOLEAN - 1)) | (1L << (BYTE - 1)) | (1L << (CHAR - 1)) | (1L << (CLASS - 1)) | (1L << (DOUBLE - 1)) | (1L << (ENUM - 1)) | (1L << (FINAL - 1)) | (1L << (FLOAT - 1)) | (1L << (INT - 1)) | (1L << (INTERFACE - 1)) | (1L << (LONG - 1)) | (1L << (NATIVE - 1)) | (1L << (PRIVATE - 1)) | (1L << (PROTECTED - 1)) | (1L << (PUBLIC - 1)) | (1L << (SHORT - 1)) | (1L << (STATIC - 1)) | (1L << (STRICTFP - 1)) | (1L << (SYNCHRONIZED - 1)) | (1L << (TRANSIENT - 1)) | (1L << (VOID - 1)) | (1L << (VOLATILE - 1)) | (1L << (MODULE - 1)) | (1L << (OPEN - 1)) | (1L << (REQUIRES - 1)) | (1L << (EXPORTS - 1)) | (1L << (OPENS - 1)) | (1L << (TO - 1)) | (1L << (USES - 1)) | (1L << (PROVIDES - 1)) | (1L << (WITH - 1)) | (1L << (TRANSITIVE - 1)) | (1L << (VAR - 1)) | (1L << (YIELD - 1)) | (1L << (RECORD - 1)) | (1L << (SEALED - 1)))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (PERMITS - 65)) | (1L << (NON_SEALED - 65)) | (1L << (LBRACE - 65)) | (1L << (SEMI - 65)) | (1L << (LT - 65)) | (1L << (AT - 65)) | (1L << (IDENTIFIER - 65)))) != 0)) { { { setState(448); classBodyDeclaration(); } } setState(453); _errHandler.sync(this); _la = _input.LA(1); } setState(454); match(RBRACE); } } 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 TerminalNode LBRACE() { return getToken(JavaParser.LBRACE, 0); } public TerminalNode RBRACE() { return getToken(JavaParser.RBRACE, 0); } public List interfaceBodyDeclaration() { return getRuleContexts(InterfaceBodyDeclarationContext.class); } public InterfaceBodyDeclarationContext interfaceBodyDeclaration(int i) { return getRuleContext(InterfaceBodyDeclarationContext.class,i); } public InterfaceBodyContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_interfaceBody; } } public final InterfaceBodyContext interfaceBody() throws RecognitionException { InterfaceBodyContext _localctx = new InterfaceBodyContext(_ctx, getState()); enterRule(_localctx, 34, RULE_interfaceBody); int _la; try { enterOuterAlt(_localctx, 1); { setState(456); match(LBRACE); setState(460); _errHandler.sync(this); _la = _input.LA(1); while (((((_la - 1)) & ~0x3f) == 0 && ((1L << (_la - 1)) & ((1L << (ABSTRACT - 1)) | (1L << (BOOLEAN - 1)) | (1L << (BYTE - 1)) | (1L << (CHAR - 1)) | (1L << (CLASS - 1)) | (1L << (DEFAULT - 1)) | (1L << (DOUBLE - 1)) | (1L << (ENUM - 1)) | (1L << (FINAL - 1)) | (1L << (FLOAT - 1)) | (1L << (INT - 1)) | (1L << (INTERFACE - 1)) | (1L << (LONG - 1)) | (1L << (NATIVE - 1)) | (1L << (PRIVATE - 1)) | (1L << (PROTECTED - 1)) | (1L << (PUBLIC - 1)) | (1L << (SHORT - 1)) | (1L << (STATIC - 1)) | (1L << (STRICTFP - 1)) | (1L << (SYNCHRONIZED - 1)) | (1L << (TRANSIENT - 1)) | (1L << (VOID - 1)) | (1L << (VOLATILE - 1)) | (1L << (MODULE - 1)) | (1L << (OPEN - 1)) | (1L << (REQUIRES - 1)) | (1L << (EXPORTS - 1)) | (1L << (OPENS - 1)) | (1L << (TO - 1)) | (1L << (USES - 1)) | (1L << (PROVIDES - 1)) | (1L << (WITH - 1)) | (1L << (TRANSITIVE - 1)) | (1L << (VAR - 1)) | (1L << (YIELD - 1)) | (1L << (RECORD - 1)) | (1L << (SEALED - 1)))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (PERMITS - 65)) | (1L << (NON_SEALED - 65)) | (1L << (SEMI - 65)) | (1L << (LT - 65)) | (1L << (AT - 65)) | (1L << (IDENTIFIER - 65)))) != 0)) { { { setState(457); interfaceBodyDeclaration(); } } setState(462); _errHandler.sync(this); _la = _input.LA(1); } setState(463); 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 TerminalNode SEMI() { return getToken(JavaParser.SEMI, 0); } public BlockContext block() { return getRuleContext(BlockContext.class,0); } public TerminalNode STATIC() { return getToken(JavaParser.STATIC, 0); } public MemberDeclarationContext memberDeclaration() { return getRuleContext(MemberDeclarationContext.class,0); } public List modifier() { return getRuleContexts(ModifierContext.class); } public ModifierContext modifier(int i) { return getRuleContext(ModifierContext.class,i); } public ClassBodyDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_classBodyDeclaration; } } public final ClassBodyDeclarationContext classBodyDeclaration() throws RecognitionException { ClassBodyDeclarationContext _localctx = new ClassBodyDeclarationContext(_ctx, getState()); enterRule(_localctx, 36, RULE_classBodyDeclaration); int _la; try { int _alt; setState(477); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,39,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { setState(465); match(SEMI); } break; case 2: enterOuterAlt(_localctx, 2); { setState(467); _errHandler.sync(this); _la = _input.LA(1); if (_la==STATIC) { { setState(466); match(STATIC); } } setState(469); block(); } break; case 3: enterOuterAlt(_localctx, 3); { setState(473); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,38,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(470); modifier(); } } } setState(475); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,38,_ctx); } setState(476); memberDeclaration(); } break; } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class MemberDeclarationContext extends ParserRuleContext { public RecordDeclarationContext recordDeclaration() { return getRuleContext(RecordDeclarationContext.class,0); } public MethodDeclarationContext methodDeclaration() { return getRuleContext(MethodDeclarationContext.class,0); } public GenericMethodDeclarationContext genericMethodDeclaration() { return getRuleContext(GenericMethodDeclarationContext.class,0); } public FieldDeclarationContext fieldDeclaration() { return getRuleContext(FieldDeclarationContext.class,0); } public ConstructorDeclarationContext constructorDeclaration() { return getRuleContext(ConstructorDeclarationContext.class,0); } public GenericConstructorDeclarationContext genericConstructorDeclaration() { return getRuleContext(GenericConstructorDeclarationContext.class,0); } public InterfaceDeclarationContext interfaceDeclaration() { return getRuleContext(InterfaceDeclarationContext.class,0); } public AnnotationTypeDeclarationContext annotationTypeDeclaration() { return getRuleContext(AnnotationTypeDeclarationContext.class,0); } public ClassDeclarationContext classDeclaration() { return getRuleContext(ClassDeclarationContext.class,0); } public EnumDeclarationContext enumDeclaration() { return getRuleContext(EnumDeclarationContext.class,0); } public MemberDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_memberDeclaration; } } public final MemberDeclarationContext memberDeclaration() throws RecognitionException { MemberDeclarationContext _localctx = new MemberDeclarationContext(_ctx, getState()); enterRule(_localctx, 38, RULE_memberDeclaration); try { setState(489); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { setState(479); recordDeclaration(); } break; case 2: enterOuterAlt(_localctx, 2); { setState(480); methodDeclaration(); } break; case 3: enterOuterAlt(_localctx, 3); { setState(481); genericMethodDeclaration(); } break; case 4: enterOuterAlt(_localctx, 4); { setState(482); fieldDeclaration(); } break; case 5: enterOuterAlt(_localctx, 5); { setState(483); constructorDeclaration(); } break; case 6: enterOuterAlt(_localctx, 6); { setState(484); genericConstructorDeclaration(); } break; case 7: enterOuterAlt(_localctx, 7); { setState(485); interfaceDeclaration(); } break; case 8: enterOuterAlt(_localctx, 8); { setState(486); annotationTypeDeclaration(); } break; case 9: enterOuterAlt(_localctx, 9); { setState(487); classDeclaration(); } break; case 10: enterOuterAlt(_localctx, 10); { setState(488); enumDeclaration(); } 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 TypeTypeOrVoidContext typeTypeOrVoid() { return getRuleContext(TypeTypeOrVoidContext.class,0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public FormalParametersContext formalParameters() { return getRuleContext(FormalParametersContext.class,0); } public MethodBodyContext methodBody() { return getRuleContext(MethodBodyContext.class,0); } public List LBRACK() { return getTokens(JavaParser.LBRACK); } public TerminalNode LBRACK(int i) { return getToken(JavaParser.LBRACK, i); } public List RBRACK() { return getTokens(JavaParser.RBRACK); } public TerminalNode RBRACK(int i) { return getToken(JavaParser.RBRACK, i); } public TerminalNode THROWS() { return getToken(JavaParser.THROWS, 0); } public QualifiedNameListContext qualifiedNameList() { return getRuleContext(QualifiedNameListContext.class,0); } public MethodDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_methodDeclaration; } } public final MethodDeclarationContext methodDeclaration() throws RecognitionException { MethodDeclarationContext _localctx = new MethodDeclarationContext(_ctx, getState()); enterRule(_localctx, 40, RULE_methodDeclaration); int _la; try { enterOuterAlt(_localctx, 1); { setState(491); typeTypeOrVoid(); setState(492); identifier(); setState(493); formalParameters(); setState(498); _errHandler.sync(this); _la = _input.LA(1); while (_la==LBRACK) { { { setState(494); match(LBRACK); setState(495); match(RBRACK); } } setState(500); _errHandler.sync(this); _la = _input.LA(1); } setState(503); _errHandler.sync(this); _la = _input.LA(1); if (_la==THROWS) { { setState(501); match(THROWS); setState(502); qualifiedNameList(); } } setState(505); methodBody(); } } 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 TerminalNode SEMI() { return getToken(JavaParser.SEMI, 0); } public MethodBodyContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_methodBody; } } public final MethodBodyContext methodBody() throws RecognitionException { MethodBodyContext _localctx = new MethodBodyContext(_ctx, getState()); enterRule(_localctx, 42, RULE_methodBody); try { setState(509); _errHandler.sync(this); switch (_input.LA(1)) { case LBRACE: enterOuterAlt(_localctx, 1); { setState(507); block(); } break; case SEMI: enterOuterAlt(_localctx, 2); { setState(508); 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 TypeTypeOrVoidContext extends ParserRuleContext { public TypeTypeContext typeType() { return getRuleContext(TypeTypeContext.class,0); } public TerminalNode VOID() { return getToken(JavaParser.VOID, 0); } public TypeTypeOrVoidContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_typeTypeOrVoid; } } public final TypeTypeOrVoidContext typeTypeOrVoid() throws RecognitionException { TypeTypeOrVoidContext _localctx = new TypeTypeOrVoidContext(_ctx, getState()); enterRule(_localctx, 44, RULE_typeTypeOrVoid); try { setState(513); _errHandler.sync(this); switch (_input.LA(1)) { case BOOLEAN: case BYTE: case CHAR: case DOUBLE: case FLOAT: case INT: case LONG: case SHORT: case MODULE: case OPEN: case REQUIRES: case EXPORTS: case OPENS: case TO: case USES: case PROVIDES: case WITH: case TRANSITIVE: case VAR: case YIELD: case RECORD: case SEALED: case PERMITS: case AT: case IDENTIFIER: enterOuterAlt(_localctx, 1); { setState(511); typeType(); } break; case VOID: enterOuterAlt(_localctx, 2); { setState(512); 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 GenericMethodDeclarationContext extends ParserRuleContext { public TypeParametersContext typeParameters() { return getRuleContext(TypeParametersContext.class,0); } public MethodDeclarationContext methodDeclaration() { return getRuleContext(MethodDeclarationContext.class,0); } public GenericMethodDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_genericMethodDeclaration; } } public final GenericMethodDeclarationContext genericMethodDeclaration() throws RecognitionException { GenericMethodDeclarationContext _localctx = new GenericMethodDeclarationContext(_ctx, getState()); enterRule(_localctx, 46, RULE_genericMethodDeclaration); try { enterOuterAlt(_localctx, 1); { setState(515); typeParameters(); setState(516); methodDeclaration(); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class GenericConstructorDeclarationContext extends ParserRuleContext { public TypeParametersContext typeParameters() { return getRuleContext(TypeParametersContext.class,0); } public ConstructorDeclarationContext constructorDeclaration() { return getRuleContext(ConstructorDeclarationContext.class,0); } public GenericConstructorDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_genericConstructorDeclaration; } } public final GenericConstructorDeclarationContext genericConstructorDeclaration() throws RecognitionException { GenericConstructorDeclarationContext _localctx = new GenericConstructorDeclarationContext(_ctx, getState()); enterRule(_localctx, 48, RULE_genericConstructorDeclaration); try { enterOuterAlt(_localctx, 1); { setState(518); typeParameters(); setState(519); constructorDeclaration(); } } 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 BlockContext constructorBody; public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public FormalParametersContext formalParameters() { return getRuleContext(FormalParametersContext.class,0); } public BlockContext block() { return getRuleContext(BlockContext.class,0); } public TerminalNode THROWS() { return getToken(JavaParser.THROWS, 0); } public QualifiedNameListContext qualifiedNameList() { return getRuleContext(QualifiedNameListContext.class,0); } public ConstructorDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_constructorDeclaration; } } public final ConstructorDeclarationContext constructorDeclaration() throws RecognitionException { ConstructorDeclarationContext _localctx = new ConstructorDeclarationContext(_ctx, getState()); enterRule(_localctx, 50, RULE_constructorDeclaration); int _la; try { enterOuterAlt(_localctx, 1); { setState(521); identifier(); setState(522); formalParameters(); setState(525); _errHandler.sync(this); _la = _input.LA(1); if (_la==THROWS) { { setState(523); match(THROWS); setState(524); qualifiedNameList(); } } setState(527); ((ConstructorDeclarationContext)_localctx).constructorBody = block(); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class CompactConstructorDeclarationContext extends ParserRuleContext { public BlockContext constructorBody; public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public BlockContext block() { return getRuleContext(BlockContext.class,0); } public List modifier() { return getRuleContexts(ModifierContext.class); } public ModifierContext modifier(int i) { return getRuleContext(ModifierContext.class,i); } public CompactConstructorDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_compactConstructorDeclaration; } } public final CompactConstructorDeclarationContext compactConstructorDeclaration() throws RecognitionException { CompactConstructorDeclarationContext _localctx = new CompactConstructorDeclarationContext(_ctx, getState()); enterRule(_localctx, 52, RULE_compactConstructorDeclaration); try { int _alt; enterOuterAlt(_localctx, 1); { setState(532); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,46,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(529); modifier(); } } } setState(534); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,46,_ctx); } setState(535); identifier(); setState(536); ((CompactConstructorDeclarationContext)_localctx).constructorBody = block(); } } 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 TypeTypeContext typeType() { return getRuleContext(TypeTypeContext.class,0); } public VariableDeclaratorsContext variableDeclarators() { return getRuleContext(VariableDeclaratorsContext.class,0); } public TerminalNode SEMI() { return getToken(JavaParser.SEMI, 0); } public FieldDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_fieldDeclaration; } } public final FieldDeclarationContext fieldDeclaration() throws RecognitionException { FieldDeclarationContext _localctx = new FieldDeclarationContext(_ctx, getState()); enterRule(_localctx, 54, RULE_fieldDeclaration); try { enterOuterAlt(_localctx, 1); { setState(538); typeType(); setState(539); variableDeclarators(); setState(540); match(SEMI); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class InterfaceBodyDeclarationContext extends ParserRuleContext { public InterfaceMemberDeclarationContext interfaceMemberDeclaration() { return getRuleContext(InterfaceMemberDeclarationContext.class,0); } public List modifier() { return getRuleContexts(ModifierContext.class); } public ModifierContext modifier(int i) { return getRuleContext(ModifierContext.class,i); } public TerminalNode SEMI() { return getToken(JavaParser.SEMI, 0); } public InterfaceBodyDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_interfaceBodyDeclaration; } } public final InterfaceBodyDeclarationContext interfaceBodyDeclaration() throws RecognitionException { InterfaceBodyDeclarationContext _localctx = new InterfaceBodyDeclarationContext(_ctx, getState()); enterRule(_localctx, 56, RULE_interfaceBodyDeclaration); try { int _alt; setState(550); _errHandler.sync(this); switch (_input.LA(1)) { case ABSTRACT: case BOOLEAN: case BYTE: case CHAR: case CLASS: case DEFAULT: case DOUBLE: case ENUM: case FINAL: case FLOAT: case INT: case INTERFACE: case LONG: case NATIVE: case PRIVATE: case PROTECTED: case PUBLIC: case SHORT: case STATIC: case STRICTFP: case SYNCHRONIZED: case TRANSIENT: case VOID: case VOLATILE: case MODULE: case OPEN: case REQUIRES: case EXPORTS: case OPENS: case TO: case USES: case PROVIDES: case WITH: case TRANSITIVE: case VAR: case YIELD: case RECORD: case SEALED: case PERMITS: case NON_SEALED: case LT: case AT: case IDENTIFIER: enterOuterAlt(_localctx, 1); { setState(545); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,47,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(542); modifier(); } } } setState(547); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,47,_ctx); } setState(548); interfaceMemberDeclaration(); } break; case SEMI: enterOuterAlt(_localctx, 2); { setState(549); 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 InterfaceMemberDeclarationContext extends ParserRuleContext { public RecordDeclarationContext recordDeclaration() { return getRuleContext(RecordDeclarationContext.class,0); } public ConstDeclarationContext constDeclaration() { return getRuleContext(ConstDeclarationContext.class,0); } public InterfaceMethodDeclarationContext interfaceMethodDeclaration() { return getRuleContext(InterfaceMethodDeclarationContext.class,0); } public GenericInterfaceMethodDeclarationContext genericInterfaceMethodDeclaration() { return getRuleContext(GenericInterfaceMethodDeclarationContext.class,0); } public InterfaceDeclarationContext interfaceDeclaration() { return getRuleContext(InterfaceDeclarationContext.class,0); } public AnnotationTypeDeclarationContext annotationTypeDeclaration() { return getRuleContext(AnnotationTypeDeclarationContext.class,0); } public ClassDeclarationContext classDeclaration() { return getRuleContext(ClassDeclarationContext.class,0); } public EnumDeclarationContext enumDeclaration() { return getRuleContext(EnumDeclarationContext.class,0); } public InterfaceMemberDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_interfaceMemberDeclaration; } } public final InterfaceMemberDeclarationContext interfaceMemberDeclaration() throws RecognitionException { InterfaceMemberDeclarationContext _localctx = new InterfaceMemberDeclarationContext(_ctx, getState()); enterRule(_localctx, 58, RULE_interfaceMemberDeclaration); try { setState(560); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,49,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { setState(552); recordDeclaration(); } break; case 2: enterOuterAlt(_localctx, 2); { setState(553); constDeclaration(); } break; case 3: enterOuterAlt(_localctx, 3); { setState(554); interfaceMethodDeclaration(); } break; case 4: enterOuterAlt(_localctx, 4); { setState(555); genericInterfaceMethodDeclaration(); } break; case 5: enterOuterAlt(_localctx, 5); { setState(556); interfaceDeclaration(); } break; case 6: enterOuterAlt(_localctx, 6); { setState(557); annotationTypeDeclaration(); } break; case 7: enterOuterAlt(_localctx, 7); { setState(558); classDeclaration(); } break; case 8: enterOuterAlt(_localctx, 8); { setState(559); enumDeclaration(); } break; } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class ConstDeclarationContext extends ParserRuleContext { public TypeTypeContext typeType() { return getRuleContext(TypeTypeContext.class,0); } public List constantDeclarator() { return getRuleContexts(ConstantDeclaratorContext.class); } public ConstantDeclaratorContext constantDeclarator(int i) { return getRuleContext(ConstantDeclaratorContext.class,i); } public TerminalNode SEMI() { return getToken(JavaParser.SEMI, 0); } public List COMMA() { return getTokens(JavaParser.COMMA); } public TerminalNode COMMA(int i) { return getToken(JavaParser.COMMA, i); } public ConstDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_constDeclaration; } } public final ConstDeclarationContext constDeclaration() throws RecognitionException { ConstDeclarationContext _localctx = new ConstDeclarationContext(_ctx, getState()); enterRule(_localctx, 60, RULE_constDeclaration); int _la; try { enterOuterAlt(_localctx, 1); { setState(562); typeType(); setState(563); constantDeclarator(); setState(568); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { setState(564); match(COMMA); setState(565); constantDeclarator(); } } setState(570); _errHandler.sync(this); _la = _input.LA(1); } setState(571); match(SEMI); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class ConstantDeclaratorContext extends ParserRuleContext { public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public TerminalNode ASSIGN() { return getToken(JavaParser.ASSIGN, 0); } public VariableInitializerContext variableInitializer() { return getRuleContext(VariableInitializerContext.class,0); } public List LBRACK() { return getTokens(JavaParser.LBRACK); } public TerminalNode LBRACK(int i) { return getToken(JavaParser.LBRACK, i); } public List RBRACK() { return getTokens(JavaParser.RBRACK); } public TerminalNode RBRACK(int i) { return getToken(JavaParser.RBRACK, i); } public ConstantDeclaratorContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_constantDeclarator; } } public final ConstantDeclaratorContext constantDeclarator() throws RecognitionException { ConstantDeclaratorContext _localctx = new ConstantDeclaratorContext(_ctx, getState()); enterRule(_localctx, 62, RULE_constantDeclarator); int _la; try { enterOuterAlt(_localctx, 1); { setState(573); identifier(); setState(578); _errHandler.sync(this); _la = _input.LA(1); while (_la==LBRACK) { { { setState(574); match(LBRACK); setState(575); match(RBRACK); } } setState(580); _errHandler.sync(this); _la = _input.LA(1); } setState(581); match(ASSIGN); setState(582); variableInitializer(); } } 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 InterfaceCommonBodyDeclarationContext interfaceCommonBodyDeclaration() { return getRuleContext(InterfaceCommonBodyDeclarationContext.class,0); } public List 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; } } public final InterfaceMethodDeclarationContext interfaceMethodDeclaration() throws RecognitionException { InterfaceMethodDeclarationContext _localctx = new InterfaceMethodDeclarationContext(_ctx, getState()); enterRule(_localctx, 64, RULE_interfaceMethodDeclaration); try { int _alt; enterOuterAlt(_localctx, 1); { setState(587); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,52,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(584); interfaceMethodModifier(); } } } setState(589); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,52,_ctx); } setState(590); interfaceCommonBodyDeclaration(); } } 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 TerminalNode PUBLIC() { return getToken(JavaParser.PUBLIC, 0); } public TerminalNode ABSTRACT() { return getToken(JavaParser.ABSTRACT, 0); } public TerminalNode DEFAULT() { return getToken(JavaParser.DEFAULT, 0); } public TerminalNode STATIC() { return getToken(JavaParser.STATIC, 0); } public TerminalNode STRICTFP() { return getToken(JavaParser.STRICTFP, 0); } public InterfaceMethodModifierContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_interfaceMethodModifier; } } public final InterfaceMethodModifierContext interfaceMethodModifier() throws RecognitionException { InterfaceMethodModifierContext _localctx = new InterfaceMethodModifierContext(_ctx, getState()); enterRule(_localctx, 66, RULE_interfaceMethodModifier); try { setState(598); _errHandler.sync(this); switch (_input.LA(1)) { case MODULE: case OPEN: case REQUIRES: case EXPORTS: case OPENS: case TO: case USES: case PROVIDES: case WITH: case TRANSITIVE: case VAR: case YIELD: case RECORD: case SEALED: case PERMITS: case AT: case IDENTIFIER: enterOuterAlt(_localctx, 1); { setState(592); annotation(); } break; case PUBLIC: enterOuterAlt(_localctx, 2); { setState(593); match(PUBLIC); } break; case ABSTRACT: enterOuterAlt(_localctx, 3); { setState(594); match(ABSTRACT); } break; case DEFAULT: enterOuterAlt(_localctx, 4); { setState(595); match(DEFAULT); } break; case STATIC: enterOuterAlt(_localctx, 5); { setState(596); match(STATIC); } break; case STRICTFP: enterOuterAlt(_localctx, 6); { setState(597); 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 GenericInterfaceMethodDeclarationContext extends ParserRuleContext { public TypeParametersContext typeParameters() { return getRuleContext(TypeParametersContext.class,0); } public InterfaceCommonBodyDeclarationContext interfaceCommonBodyDeclaration() { return getRuleContext(InterfaceCommonBodyDeclarationContext.class,0); } public List interfaceMethodModifier() { return getRuleContexts(InterfaceMethodModifierContext.class); } public InterfaceMethodModifierContext interfaceMethodModifier(int i) { return getRuleContext(InterfaceMethodModifierContext.class,i); } public GenericInterfaceMethodDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_genericInterfaceMethodDeclaration; } } public final GenericInterfaceMethodDeclarationContext genericInterfaceMethodDeclaration() throws RecognitionException { GenericInterfaceMethodDeclarationContext _localctx = new GenericInterfaceMethodDeclarationContext(_ctx, getState()); enterRule(_localctx, 68, RULE_genericInterfaceMethodDeclaration); int _la; try { enterOuterAlt(_localctx, 1); { setState(603); _errHandler.sync(this); _la = _input.LA(1); while (((((_la - 1)) & ~0x3f) == 0 && ((1L << (_la - 1)) & ((1L << (ABSTRACT - 1)) | (1L << (DEFAULT - 1)) | (1L << (PUBLIC - 1)) | (1L << (STATIC - 1)) | (1L << (STRICTFP - 1)) | (1L << (MODULE - 1)) | (1L << (OPEN - 1)) | (1L << (REQUIRES - 1)) | (1L << (EXPORTS - 1)) | (1L << (OPENS - 1)) | (1L << (TO - 1)) | (1L << (USES - 1)) | (1L << (PROVIDES - 1)) | (1L << (WITH - 1)) | (1L << (TRANSITIVE - 1)) | (1L << (VAR - 1)) | (1L << (YIELD - 1)) | (1L << (RECORD - 1)) | (1L << (SEALED - 1)))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (PERMITS - 65)) | (1L << (AT - 65)) | (1L << (IDENTIFIER - 65)))) != 0)) { { { setState(600); interfaceMethodModifier(); } } setState(605); _errHandler.sync(this); _la = _input.LA(1); } setState(606); typeParameters(); setState(607); interfaceCommonBodyDeclaration(); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class InterfaceCommonBodyDeclarationContext extends ParserRuleContext { public TypeTypeOrVoidContext typeTypeOrVoid() { return getRuleContext(TypeTypeOrVoidContext.class,0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public FormalParametersContext formalParameters() { return getRuleContext(FormalParametersContext.class,0); } public MethodBodyContext methodBody() { return getRuleContext(MethodBodyContext.class,0); } public List annotation() { return getRuleContexts(AnnotationContext.class); } public AnnotationContext annotation(int i) { return getRuleContext(AnnotationContext.class,i); } public List LBRACK() { return getTokens(JavaParser.LBRACK); } public TerminalNode LBRACK(int i) { return getToken(JavaParser.LBRACK, i); } public List RBRACK() { return getTokens(JavaParser.RBRACK); } public TerminalNode RBRACK(int i) { return getToken(JavaParser.RBRACK, i); } public TerminalNode THROWS() { return getToken(JavaParser.THROWS, 0); } public QualifiedNameListContext qualifiedNameList() { return getRuleContext(QualifiedNameListContext.class,0); } public InterfaceCommonBodyDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_interfaceCommonBodyDeclaration; } } public final InterfaceCommonBodyDeclarationContext interfaceCommonBodyDeclaration() throws RecognitionException { InterfaceCommonBodyDeclarationContext _localctx = new InterfaceCommonBodyDeclarationContext(_ctx, getState()); enterRule(_localctx, 70, RULE_interfaceCommonBodyDeclaration); int _la; try { int _alt; enterOuterAlt(_localctx, 1); { setState(612); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,55,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(609); annotation(); } } } setState(614); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,55,_ctx); } setState(615); typeTypeOrVoid(); setState(616); identifier(); setState(617); formalParameters(); setState(622); _errHandler.sync(this); _la = _input.LA(1); while (_la==LBRACK) { { { setState(618); match(LBRACK); setState(619); match(RBRACK); } } setState(624); _errHandler.sync(this); _la = _input.LA(1); } setState(627); _errHandler.sync(this); _la = _input.LA(1); if (_la==THROWS) { { setState(625); match(THROWS); setState(626); qualifiedNameList(); } } setState(629); methodBody(); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class VariableDeclaratorsContext extends ParserRuleContext { public List variableDeclarator() { return getRuleContexts(VariableDeclaratorContext.class); } public VariableDeclaratorContext variableDeclarator(int i) { return getRuleContext(VariableDeclaratorContext.class,i); } public List COMMA() { return getTokens(JavaParser.COMMA); } public TerminalNode COMMA(int i) { return getToken(JavaParser.COMMA, i); } public VariableDeclaratorsContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_variableDeclarators; } } public final VariableDeclaratorsContext variableDeclarators() throws RecognitionException { VariableDeclaratorsContext _localctx = new VariableDeclaratorsContext(_ctx, getState()); enterRule(_localctx, 72, RULE_variableDeclarators); int _la; try { enterOuterAlt(_localctx, 1); { setState(631); variableDeclarator(); setState(636); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { setState(632); match(COMMA); setState(633); variableDeclarator(); } } setState(638); _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 TerminalNode ASSIGN() { return getToken(JavaParser.ASSIGN, 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; } } public final VariableDeclaratorContext variableDeclarator() throws RecognitionException { VariableDeclaratorContext _localctx = new VariableDeclaratorContext(_ctx, getState()); enterRule(_localctx, 74, RULE_variableDeclarator); int _la; try { enterOuterAlt(_localctx, 1); { setState(639); variableDeclaratorId(); setState(642); _errHandler.sync(this); _la = _input.LA(1); if (_la==ASSIGN) { { setState(640); match(ASSIGN); setState(641); 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 List LBRACK() { return getTokens(JavaParser.LBRACK); } public TerminalNode LBRACK(int i) { return getToken(JavaParser.LBRACK, i); } public List RBRACK() { return getTokens(JavaParser.RBRACK); } public TerminalNode RBRACK(int i) { return getToken(JavaParser.RBRACK, i); } public VariableDeclaratorIdContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_variableDeclaratorId; } } public final VariableDeclaratorIdContext variableDeclaratorId() throws RecognitionException { VariableDeclaratorIdContext _localctx = new VariableDeclaratorIdContext(_ctx, getState()); enterRule(_localctx, 76, RULE_variableDeclaratorId); int _la; try { enterOuterAlt(_localctx, 1); { setState(644); identifier(); setState(649); _errHandler.sync(this); _la = _input.LA(1); while (_la==LBRACK) { { { setState(645); match(LBRACK); setState(646); match(RBRACK); } } setState(651); _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 VariableInitializerContext extends ParserRuleContext { public ArrayInitializerContext arrayInitializer() { return getRuleContext(ArrayInitializerContext.class,0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } public VariableInitializerContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_variableInitializer; } } public final VariableInitializerContext variableInitializer() throws RecognitionException { VariableInitializerContext _localctx = new VariableInitializerContext(_ctx, getState()); enterRule(_localctx, 78, RULE_variableInitializer); try { setState(654); _errHandler.sync(this); switch (_input.LA(1)) { case LBRACE: enterOuterAlt(_localctx, 1); { setState(652); arrayInitializer(); } break; case BOOLEAN: case BYTE: case CHAR: case DOUBLE: case FLOAT: case INT: case LONG: case NEW: case SHORT: case SUPER: case SWITCH: case THIS: case VOID: case MODULE: case OPEN: case REQUIRES: case EXPORTS: case OPENS: case TO: case USES: case PROVIDES: case WITH: case TRANSITIVE: case VAR: case YIELD: case RECORD: case SEALED: case PERMITS: case DECIMAL_LITERAL: case HEX_LITERAL: case OCT_LITERAL: case BINARY_LITERAL: case FLOAT_LITERAL: case HEX_FLOAT_LITERAL: case BOOL_LITERAL: case CHAR_LITERAL: case STRING_LITERAL: case TEXT_BLOCK: case NULL_LITERAL: case LPAREN: case LT: case BANG: case TILDE: case INC: case DEC: case ADD: case SUB: case AT: case IDENTIFIER: enterOuterAlt(_localctx, 2); { setState(653); expression(0); } 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 ArrayInitializerContext extends ParserRuleContext { public TerminalNode LBRACE() { return getToken(JavaParser.LBRACE, 0); } public TerminalNode RBRACE() { return getToken(JavaParser.RBRACE, 0); } public List variableInitializer() { return getRuleContexts(VariableInitializerContext.class); } public VariableInitializerContext variableInitializer(int i) { return getRuleContext(VariableInitializerContext.class,i); } public List COMMA() { return getTokens(JavaParser.COMMA); } public TerminalNode COMMA(int i) { return getToken(JavaParser.COMMA, i); } public ArrayInitializerContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_arrayInitializer; } } public final ArrayInitializerContext arrayInitializer() throws RecognitionException { ArrayInitializerContext _localctx = new ArrayInitializerContext(_ctx, getState()); enterRule(_localctx, 80, RULE_arrayInitializer); int _la; try { int _alt; enterOuterAlt(_localctx, 1); { setState(656); match(LBRACE); setState(668); _errHandler.sync(this); _la = _input.LA(1); if (((((_la - 3)) & ~0x3f) == 0 && ((1L << (_la - 3)) & ((1L << (BOOLEAN - 3)) | (1L << (BYTE - 3)) | (1L << (CHAR - 3)) | (1L << (DOUBLE - 3)) | (1L << (FLOAT - 3)) | (1L << (INT - 3)) | (1L << (LONG - 3)) | (1L << (NEW - 3)) | (1L << (SHORT - 3)) | (1L << (SUPER - 3)) | (1L << (SWITCH - 3)) | (1L << (THIS - 3)) | (1L << (VOID - 3)) | (1L << (MODULE - 3)) | (1L << (OPEN - 3)) | (1L << (REQUIRES - 3)) | (1L << (EXPORTS - 3)) | (1L << (OPENS - 3)) | (1L << (TO - 3)) | (1L << (USES - 3)) | (1L << (PROVIDES - 3)) | (1L << (WITH - 3)) | (1L << (TRANSITIVE - 3)) | (1L << (VAR - 3)) | (1L << (YIELD - 3)) | (1L << (RECORD - 3)) | (1L << (SEALED - 3)) | (1L << (PERMITS - 3)))) != 0) || ((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & ((1L << (DECIMAL_LITERAL - 67)) | (1L << (HEX_LITERAL - 67)) | (1L << (OCT_LITERAL - 67)) | (1L << (BINARY_LITERAL - 67)) | (1L << (FLOAT_LITERAL - 67)) | (1L << (HEX_FLOAT_LITERAL - 67)) | (1L << (BOOL_LITERAL - 67)) | (1L << (CHAR_LITERAL - 67)) | (1L << (STRING_LITERAL - 67)) | (1L << (TEXT_BLOCK - 67)) | (1L << (NULL_LITERAL - 67)) | (1L << (LPAREN - 67)) | (1L << (LBRACE - 67)) | (1L << (LT - 67)) | (1L << (BANG - 67)) | (1L << (TILDE - 67)) | (1L << (INC - 67)) | (1L << (DEC - 67)) | (1L << (ADD - 67)) | (1L << (SUB - 67)) | (1L << (AT - 67)) | (1L << (IDENTIFIER - 67)))) != 0)) { { setState(657); variableInitializer(); setState(662); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,62,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(658); match(COMMA); setState(659); variableInitializer(); } } } setState(664); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,62,_ctx); } setState(666); _errHandler.sync(this); _la = _input.LA(1); if (_la==COMMA) { { setState(665); match(COMMA); } } } } setState(670); match(RBRACE); } } 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 TypeIdentifierContext typeIdentifier() { return getRuleContext(TypeIdentifierContext.class,0); } public List identifier() { return getRuleContexts(IdentifierContext.class); } public IdentifierContext identifier(int i) { return getRuleContext(IdentifierContext.class,i); } public List DOT() { return getTokens(JavaParser.DOT); } public TerminalNode DOT(int i) { return getToken(JavaParser.DOT, i); } public List typeArguments() { return getRuleContexts(TypeArgumentsContext.class); } public TypeArgumentsContext typeArguments(int i) { return getRuleContext(TypeArgumentsContext.class,i); } public ClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_classOrInterfaceType; } } public final ClassOrInterfaceTypeContext classOrInterfaceType() throws RecognitionException { ClassOrInterfaceTypeContext _localctx = new ClassOrInterfaceTypeContext(_ctx, getState()); enterRule(_localctx, 82, RULE_classOrInterfaceType); int _la; try { int _alt; enterOuterAlt(_localctx, 1); { setState(680); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,66,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(672); identifier(); setState(674); _errHandler.sync(this); _la = _input.LA(1); if (_la==LT) { { setState(673); typeArguments(); } } setState(676); match(DOT); } } } setState(682); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,66,_ctx); } setState(683); typeIdentifier(); setState(685); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,67,_ctx) ) { case 1: { setState(684); typeArguments(); } break; } } } 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 TypeTypeContext typeType() { return getRuleContext(TypeTypeContext.class,0); } public TerminalNode QUESTION() { return getToken(JavaParser.QUESTION, 0); } public List annotation() { return getRuleContexts(AnnotationContext.class); } public AnnotationContext annotation(int i) { return getRuleContext(AnnotationContext.class,i); } public TerminalNode EXTENDS() { return getToken(JavaParser.EXTENDS, 0); } public TerminalNode SUPER() { return getToken(JavaParser.SUPER, 0); } public TypeArgumentContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_typeArgument; } } public final TypeArgumentContext typeArgument() throws RecognitionException { TypeArgumentContext _localctx = new TypeArgumentContext(_ctx, getState()); enterRule(_localctx, 84, RULE_typeArgument); int _la; try { setState(699); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { setState(687); typeType(); } break; case 2: enterOuterAlt(_localctx, 2); { setState(691); _errHandler.sync(this); _la = _input.LA(1); while (((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & ((1L << (MODULE - 51)) | (1L << (OPEN - 51)) | (1L << (REQUIRES - 51)) | (1L << (EXPORTS - 51)) | (1L << (OPENS - 51)) | (1L << (TO - 51)) | (1L << (USES - 51)) | (1L << (PROVIDES - 51)) | (1L << (WITH - 51)) | (1L << (TRANSITIVE - 51)) | (1L << (VAR - 51)) | (1L << (YIELD - 51)) | (1L << (RECORD - 51)) | (1L << (SEALED - 51)) | (1L << (PERMITS - 51)))) != 0) || _la==AT || _la==IDENTIFIER) { { { setState(688); annotation(); } } setState(693); _errHandler.sync(this); _la = _input.LA(1); } setState(694); match(QUESTION); setState(697); _errHandler.sync(this); _la = _input.LA(1); if (_la==EXTENDS || _la==SUPER) { { setState(695); _la = _input.LA(1); if ( !(_la==EXTENDS || _la==SUPER) ) { _errHandler.recoverInline(this); } else { if ( _input.LA(1)==Token.EOF ) matchedEOF = true; _errHandler.reportMatch(this); consume(); } setState(696); typeType(); } } } break; } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class QualifiedNameListContext extends ParserRuleContext { public List qualifiedName() { return getRuleContexts(QualifiedNameContext.class); } public QualifiedNameContext qualifiedName(int i) { return getRuleContext(QualifiedNameContext.class,i); } public List COMMA() { return getTokens(JavaParser.COMMA); } public TerminalNode COMMA(int i) { return getToken(JavaParser.COMMA, i); } public QualifiedNameListContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_qualifiedNameList; } } public final QualifiedNameListContext qualifiedNameList() throws RecognitionException { QualifiedNameListContext _localctx = new QualifiedNameListContext(_ctx, getState()); enterRule(_localctx, 86, RULE_qualifiedNameList); int _la; try { enterOuterAlt(_localctx, 1); { setState(701); qualifiedName(); setState(706); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { setState(702); match(COMMA); setState(703); qualifiedName(); } } setState(708); _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 FormalParametersContext extends ParserRuleContext { public TerminalNode LPAREN() { return getToken(JavaParser.LPAREN, 0); } public TerminalNode RPAREN() { return getToken(JavaParser.RPAREN, 0); } public ReceiverParameterContext receiverParameter() { return getRuleContext(ReceiverParameterContext.class,0); } public TerminalNode COMMA() { return getToken(JavaParser.COMMA, 0); } public FormalParameterListContext formalParameterList() { return getRuleContext(FormalParameterListContext.class,0); } public FormalParametersContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_formalParameters; } } public final FormalParametersContext formalParameters() throws RecognitionException { FormalParametersContext _localctx = new FormalParametersContext(_ctx, getState()); enterRule(_localctx, 88, RULE_formalParameters); int _la; try { enterOuterAlt(_localctx, 1); { setState(709); match(LPAREN); setState(721); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) { case 1: { setState(711); _errHandler.sync(this); _la = _input.LA(1); if (((((_la - 3)) & ~0x3f) == 0 && ((1L << (_la - 3)) & ((1L << (BOOLEAN - 3)) | (1L << (BYTE - 3)) | (1L << (CHAR - 3)) | (1L << (DOUBLE - 3)) | (1L << (FLOAT - 3)) | (1L << (INT - 3)) | (1L << (LONG - 3)) | (1L << (SHORT - 3)) | (1L << (MODULE - 3)) | (1L << (OPEN - 3)) | (1L << (REQUIRES - 3)) | (1L << (EXPORTS - 3)) | (1L << (OPENS - 3)) | (1L << (TO - 3)) | (1L << (USES - 3)) | (1L << (PROVIDES - 3)) | (1L << (WITH - 3)) | (1L << (TRANSITIVE - 3)) | (1L << (VAR - 3)) | (1L << (YIELD - 3)) | (1L << (RECORD - 3)) | (1L << (SEALED - 3)) | (1L << (PERMITS - 3)))) != 0) || _la==AT || _la==IDENTIFIER) { { setState(710); receiverParameter(); } } } break; case 2: { setState(713); receiverParameter(); setState(716); _errHandler.sync(this); _la = _input.LA(1); if (_la==COMMA) { { setState(714); match(COMMA); setState(715); formalParameterList(); } } } break; case 3: { setState(719); _errHandler.sync(this); _la = _input.LA(1); if (((((_la - 3)) & ~0x3f) == 0 && ((1L << (_la - 3)) & ((1L << (BOOLEAN - 3)) | (1L << (BYTE - 3)) | (1L << (CHAR - 3)) | (1L << (DOUBLE - 3)) | (1L << (FINAL - 3)) | (1L << (FLOAT - 3)) | (1L << (INT - 3)) | (1L << (LONG - 3)) | (1L << (SHORT - 3)) | (1L << (MODULE - 3)) | (1L << (OPEN - 3)) | (1L << (REQUIRES - 3)) | (1L << (EXPORTS - 3)) | (1L << (OPENS - 3)) | (1L << (TO - 3)) | (1L << (USES - 3)) | (1L << (PROVIDES - 3)) | (1L << (WITH - 3)) | (1L << (TRANSITIVE - 3)) | (1L << (VAR - 3)) | (1L << (YIELD - 3)) | (1L << (RECORD - 3)) | (1L << (SEALED - 3)) | (1L << (PERMITS - 3)))) != 0) || _la==AT || _la==IDENTIFIER) { { setState(718); formalParameterList(); } } } break; } setState(723); match(RPAREN); } } 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 TypeTypeContext typeType() { return getRuleContext(TypeTypeContext.class,0); } public TerminalNode THIS() { return getToken(JavaParser.THIS, 0); } public List identifier() { return getRuleContexts(IdentifierContext.class); } public IdentifierContext identifier(int i) { return getRuleContext(IdentifierContext.class,i); } public List DOT() { return getTokens(JavaParser.DOT); } public TerminalNode DOT(int i) { return getToken(JavaParser.DOT, i); } public ReceiverParameterContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_receiverParameter; } } public final ReceiverParameterContext receiverParameter() throws RecognitionException { ReceiverParameterContext _localctx = new ReceiverParameterContext(_ctx, getState()); enterRule(_localctx, 90, RULE_receiverParameter); int _la; try { enterOuterAlt(_localctx, 1); { setState(725); typeType(); setState(731); _errHandler.sync(this); _la = _input.LA(1); while (((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & ((1L << (MODULE - 51)) | (1L << (OPEN - 51)) | (1L << (REQUIRES - 51)) | (1L << (EXPORTS - 51)) | (1L << (OPENS - 51)) | (1L << (TO - 51)) | (1L << (USES - 51)) | (1L << (PROVIDES - 51)) | (1L << (WITH - 51)) | (1L << (TRANSITIVE - 51)) | (1L << (VAR - 51)) | (1L << (YIELD - 51)) | (1L << (RECORD - 51)) | (1L << (SEALED - 51)) | (1L << (PERMITS - 51)))) != 0) || _la==IDENTIFIER) { { { setState(726); identifier(); setState(727); match(DOT); } } setState(733); _errHandler.sync(this); _la = _input.LA(1); } setState(734); match(THIS); } } 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 List formalParameter() { return getRuleContexts(FormalParameterContext.class); } public FormalParameterContext formalParameter(int i) { return getRuleContext(FormalParameterContext.class,i); } public List COMMA() { return getTokens(JavaParser.COMMA); } public TerminalNode COMMA(int i) { return getToken(JavaParser.COMMA, i); } public LastFormalParameterContext lastFormalParameter() { return getRuleContext(LastFormalParameterContext.class,0); } public FormalParameterListContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_formalParameterList; } } public final FormalParameterListContext formalParameterList() throws RecognitionException { FormalParameterListContext _localctx = new FormalParameterListContext(_ctx, getState()); enterRule(_localctx, 92, RULE_formalParameterList); int _la; try { int _alt; setState(749); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,79,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { setState(736); formalParameter(); setState(741); _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(737); match(COMMA); setState(738); formalParameter(); } } } setState(743); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,77,_ctx); } setState(746); _errHandler.sync(this); _la = _input.LA(1); if (_la==COMMA) { { setState(744); match(COMMA); setState(745); lastFormalParameter(); } } } break; case 2: enterOuterAlt(_localctx, 2); { setState(748); lastFormalParameter(); } 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 TypeTypeContext typeType() { return getRuleContext(TypeTypeContext.class,0); } public VariableDeclaratorIdContext variableDeclaratorId() { return getRuleContext(VariableDeclaratorIdContext.class,0); } public List 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; } } public final FormalParameterContext formalParameter() throws RecognitionException { FormalParameterContext _localctx = new FormalParameterContext(_ctx, getState()); enterRule(_localctx, 94, RULE_formalParameter); try { int _alt; enterOuterAlt(_localctx, 1); { setState(754); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,80,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(751); variableModifier(); } } } setState(756); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,80,_ctx); } setState(757); typeType(); setState(758); variableDeclaratorId(); } } 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 TypeTypeContext typeType() { return getRuleContext(TypeTypeContext.class,0); } public TerminalNode ELLIPSIS() { return getToken(JavaParser.ELLIPSIS, 0); } public VariableDeclaratorIdContext variableDeclaratorId() { return getRuleContext(VariableDeclaratorIdContext.class,0); } public List variableModifier() { return getRuleContexts(VariableModifierContext.class); } public VariableModifierContext variableModifier(int i) { return getRuleContext(VariableModifierContext.class,i); } public List annotation() { return getRuleContexts(AnnotationContext.class); } public AnnotationContext annotation(int i) { return getRuleContext(AnnotationContext.class,i); } public LastFormalParameterContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_lastFormalParameter; } } public final LastFormalParameterContext lastFormalParameter() throws RecognitionException { LastFormalParameterContext _localctx = new LastFormalParameterContext(_ctx, getState()); enterRule(_localctx, 96, RULE_lastFormalParameter); int _la; try { int _alt; enterOuterAlt(_localctx, 1); { setState(763); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,81,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(760); variableModifier(); } } } setState(765); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,81,_ctx); } setState(766); typeType(); setState(770); _errHandler.sync(this); _la = _input.LA(1); while (((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & ((1L << (MODULE - 51)) | (1L << (OPEN - 51)) | (1L << (REQUIRES - 51)) | (1L << (EXPORTS - 51)) | (1L << (OPENS - 51)) | (1L << (TO - 51)) | (1L << (USES - 51)) | (1L << (PROVIDES - 51)) | (1L << (WITH - 51)) | (1L << (TRANSITIVE - 51)) | (1L << (VAR - 51)) | (1L << (YIELD - 51)) | (1L << (RECORD - 51)) | (1L << (SEALED - 51)) | (1L << (PERMITS - 51)))) != 0) || _la==AT || _la==IDENTIFIER) { { { setState(767); annotation(); } } setState(772); _errHandler.sync(this); _la = _input.LA(1); } setState(773); match(ELLIPSIS); setState(774); variableDeclaratorId(); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class LambdaLVTIListContext extends ParserRuleContext { public List lambdaLVTIParameter() { return getRuleContexts(LambdaLVTIParameterContext.class); } public LambdaLVTIParameterContext lambdaLVTIParameter(int i) { return getRuleContext(LambdaLVTIParameterContext.class,i); } public List COMMA() { return getTokens(JavaParser.COMMA); } public TerminalNode COMMA(int i) { return getToken(JavaParser.COMMA, i); } public LambdaLVTIListContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_lambdaLVTIList; } } public final LambdaLVTIListContext lambdaLVTIList() throws RecognitionException { LambdaLVTIListContext _localctx = new LambdaLVTIListContext(_ctx, getState()); enterRule(_localctx, 98, RULE_lambdaLVTIList); int _la; try { enterOuterAlt(_localctx, 1); { setState(776); lambdaLVTIParameter(); setState(781); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { setState(777); match(COMMA); setState(778); lambdaLVTIParameter(); } } setState(783); _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 LambdaLVTIParameterContext extends ParserRuleContext { public TerminalNode VAR() { return getToken(JavaParser.VAR, 0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public List variableModifier() { return getRuleContexts(VariableModifierContext.class); } public VariableModifierContext variableModifier(int i) { return getRuleContext(VariableModifierContext.class,i); } public LambdaLVTIParameterContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_lambdaLVTIParameter; } } public final LambdaLVTIParameterContext lambdaLVTIParameter() throws RecognitionException { LambdaLVTIParameterContext _localctx = new LambdaLVTIParameterContext(_ctx, getState()); enterRule(_localctx, 100, RULE_lambdaLVTIParameter); try { int _alt; enterOuterAlt(_localctx, 1); { setState(787); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,84,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(784); variableModifier(); } } } setState(789); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,84,_ctx); } setState(790); match(VAR); setState(791); identifier(); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class QualifiedNameContext extends ParserRuleContext { public List identifier() { return getRuleContexts(IdentifierContext.class); } public IdentifierContext identifier(int i) { return getRuleContext(IdentifierContext.class,i); } public List DOT() { return getTokens(JavaParser.DOT); } public TerminalNode DOT(int i) { return getToken(JavaParser.DOT, i); } public QualifiedNameContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_qualifiedName; } } public final QualifiedNameContext qualifiedName() throws RecognitionException { QualifiedNameContext _localctx = new QualifiedNameContext(_ctx, getState()); enterRule(_localctx, 102, RULE_qualifiedName); try { int _alt; enterOuterAlt(_localctx, 1); { setState(793); identifier(); setState(798); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,85,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(794); match(DOT); setState(795); identifier(); } } } setState(800); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,85,_ctx); } } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class LiteralContext extends ParserRuleContext { public IntegerLiteralContext integerLiteral() { return getRuleContext(IntegerLiteralContext.class,0); } public FloatLiteralContext floatLiteral() { return getRuleContext(FloatLiteralContext.class,0); } public TerminalNode CHAR_LITERAL() { return getToken(JavaParser.CHAR_LITERAL, 0); } public TerminalNode STRING_LITERAL() { return getToken(JavaParser.STRING_LITERAL, 0); } public TerminalNode BOOL_LITERAL() { return getToken(JavaParser.BOOL_LITERAL, 0); } public TerminalNode NULL_LITERAL() { return getToken(JavaParser.NULL_LITERAL, 0); } public TerminalNode TEXT_BLOCK() { return getToken(JavaParser.TEXT_BLOCK, 0); } public LiteralContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_literal; } } public final LiteralContext literal() throws RecognitionException { LiteralContext _localctx = new LiteralContext(_ctx, getState()); enterRule(_localctx, 104, RULE_literal); try { setState(808); _errHandler.sync(this); switch (_input.LA(1)) { case DECIMAL_LITERAL: case HEX_LITERAL: case OCT_LITERAL: case BINARY_LITERAL: enterOuterAlt(_localctx, 1); { setState(801); integerLiteral(); } break; case FLOAT_LITERAL: case HEX_FLOAT_LITERAL: enterOuterAlt(_localctx, 2); { setState(802); floatLiteral(); } break; case CHAR_LITERAL: enterOuterAlt(_localctx, 3); { setState(803); match(CHAR_LITERAL); } break; case STRING_LITERAL: enterOuterAlt(_localctx, 4); { setState(804); match(STRING_LITERAL); } break; case BOOL_LITERAL: enterOuterAlt(_localctx, 5); { setState(805); match(BOOL_LITERAL); } break; case NULL_LITERAL: enterOuterAlt(_localctx, 6); { setState(806); match(NULL_LITERAL); } break; case TEXT_BLOCK: enterOuterAlt(_localctx, 7); { setState(807); match(TEXT_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 IntegerLiteralContext extends ParserRuleContext { public TerminalNode DECIMAL_LITERAL() { return getToken(JavaParser.DECIMAL_LITERAL, 0); } public TerminalNode HEX_LITERAL() { return getToken(JavaParser.HEX_LITERAL, 0); } public TerminalNode OCT_LITERAL() { return getToken(JavaParser.OCT_LITERAL, 0); } public TerminalNode BINARY_LITERAL() { return getToken(JavaParser.BINARY_LITERAL, 0); } public IntegerLiteralContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_integerLiteral; } } public final IntegerLiteralContext integerLiteral() throws RecognitionException { IntegerLiteralContext _localctx = new IntegerLiteralContext(_ctx, getState()); enterRule(_localctx, 106, RULE_integerLiteral); int _la; try { enterOuterAlt(_localctx, 1); { setState(810); _la = _input.LA(1); if ( !(((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & ((1L << (DECIMAL_LITERAL - 67)) | (1L << (HEX_LITERAL - 67)) | (1L << (OCT_LITERAL - 67)) | (1L << (BINARY_LITERAL - 67)))) != 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 FloatLiteralContext extends ParserRuleContext { public TerminalNode FLOAT_LITERAL() { return getToken(JavaParser.FLOAT_LITERAL, 0); } public TerminalNode HEX_FLOAT_LITERAL() { return getToken(JavaParser.HEX_FLOAT_LITERAL, 0); } public FloatLiteralContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_floatLiteral; } } public final FloatLiteralContext floatLiteral() throws RecognitionException { FloatLiteralContext _localctx = new FloatLiteralContext(_ctx, getState()); enterRule(_localctx, 108, RULE_floatLiteral); int _la; try { enterOuterAlt(_localctx, 1); { setState(812); _la = _input.LA(1); if ( !(_la==FLOAT_LITERAL || _la==HEX_FLOAT_LITERAL) ) { _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 AltAnnotationQualifiedNameContext extends ParserRuleContext { public TerminalNode AT() { return getToken(JavaParser.AT, 0); } public List identifier() { return getRuleContexts(IdentifierContext.class); } public IdentifierContext identifier(int i) { return getRuleContext(IdentifierContext.class,i); } public List DOT() { return getTokens(JavaParser.DOT); } public TerminalNode DOT(int i) { return getToken(JavaParser.DOT, i); } public AltAnnotationQualifiedNameContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_altAnnotationQualifiedName; } } public final AltAnnotationQualifiedNameContext altAnnotationQualifiedName() throws RecognitionException { AltAnnotationQualifiedNameContext _localctx = new AltAnnotationQualifiedNameContext(_ctx, getState()); enterRule(_localctx, 110, RULE_altAnnotationQualifiedName); int _la; try { enterOuterAlt(_localctx, 1); { setState(819); _errHandler.sync(this); _la = _input.LA(1); while (((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & ((1L << (MODULE - 51)) | (1L << (OPEN - 51)) | (1L << (REQUIRES - 51)) | (1L << (EXPORTS - 51)) | (1L << (OPENS - 51)) | (1L << (TO - 51)) | (1L << (USES - 51)) | (1L << (PROVIDES - 51)) | (1L << (WITH - 51)) | (1L << (TRANSITIVE - 51)) | (1L << (VAR - 51)) | (1L << (YIELD - 51)) | (1L << (RECORD - 51)) | (1L << (SEALED - 51)) | (1L << (PERMITS - 51)))) != 0) || _la==IDENTIFIER) { { { setState(814); identifier(); setState(815); match(DOT); } } setState(821); _errHandler.sync(this); _la = _input.LA(1); } setState(822); match(AT); setState(823); identifier(); } } 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 TerminalNode AT() { return getToken(JavaParser.AT, 0); } public QualifiedNameContext qualifiedName() { return getRuleContext(QualifiedNameContext.class,0); } public AltAnnotationQualifiedNameContext altAnnotationQualifiedName() { return getRuleContext(AltAnnotationQualifiedNameContext.class,0); } public TerminalNode LPAREN() { return getToken(JavaParser.LPAREN, 0); } public TerminalNode RPAREN() { return getToken(JavaParser.RPAREN, 0); } public ElementValuePairsContext elementValuePairs() { return getRuleContext(ElementValuePairsContext.class,0); } public ElementValueContext elementValue() { return getRuleContext(ElementValueContext.class,0); } public AnnotationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_annotation; } } public final AnnotationContext annotation() throws RecognitionException { AnnotationContext _localctx = new AnnotationContext(_ctx, getState()); enterRule(_localctx, 112, RULE_annotation); int _la; try { enterOuterAlt(_localctx, 1); { setState(828); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,88,_ctx) ) { case 1: { setState(825); match(AT); setState(826); qualifiedName(); } break; case 2: { setState(827); altAnnotationQualifiedName(); } break; } setState(836); _errHandler.sync(this); _la = _input.LA(1); if (_la==LPAREN) { { setState(830); match(LPAREN); setState(833); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,89,_ctx) ) { case 1: { setState(831); elementValuePairs(); } break; case 2: { setState(832); elementValue(); } break; } setState(835); match(RPAREN); } } } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class ElementValuePairsContext extends ParserRuleContext { public List elementValuePair() { return getRuleContexts(ElementValuePairContext.class); } public ElementValuePairContext elementValuePair(int i) { return getRuleContext(ElementValuePairContext.class,i); } public List COMMA() { return getTokens(JavaParser.COMMA); } public TerminalNode COMMA(int i) { return getToken(JavaParser.COMMA, i); } public ElementValuePairsContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_elementValuePairs; } } public final ElementValuePairsContext elementValuePairs() throws RecognitionException { ElementValuePairsContext _localctx = new ElementValuePairsContext(_ctx, getState()); enterRule(_localctx, 114, RULE_elementValuePairs); int _la; try { enterOuterAlt(_localctx, 1); { setState(838); elementValuePair(); setState(843); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { setState(839); match(COMMA); setState(840); elementValuePair(); } } setState(845); _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 TerminalNode ASSIGN() { return getToken(JavaParser.ASSIGN, 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; } } public final ElementValuePairContext elementValuePair() throws RecognitionException { ElementValuePairContext _localctx = new ElementValuePairContext(_ctx, getState()); enterRule(_localctx, 116, RULE_elementValuePair); try { enterOuterAlt(_localctx, 1); { setState(846); identifier(); setState(847); match(ASSIGN); setState(848); 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 ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } public AnnotationContext annotation() { return getRuleContext(AnnotationContext.class,0); } public ElementValueArrayInitializerContext elementValueArrayInitializer() { return getRuleContext(ElementValueArrayInitializerContext.class,0); } public ElementValueContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_elementValue; } } public final ElementValueContext elementValue() throws RecognitionException { ElementValueContext _localctx = new ElementValueContext(_ctx, getState()); enterRule(_localctx, 118, RULE_elementValue); try { setState(853); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,92,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { setState(850); expression(0); } break; case 2: enterOuterAlt(_localctx, 2); { setState(851); annotation(); } break; case 3: enterOuterAlt(_localctx, 3); { setState(852); elementValueArrayInitializer(); } 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 TerminalNode LBRACE() { return getToken(JavaParser.LBRACE, 0); } public TerminalNode RBRACE() { return getToken(JavaParser.RBRACE, 0); } public List elementValue() { return getRuleContexts(ElementValueContext.class); } public ElementValueContext elementValue(int i) { return getRuleContext(ElementValueContext.class,i); } public List COMMA() { return getTokens(JavaParser.COMMA); } public TerminalNode COMMA(int i) { return getToken(JavaParser.COMMA, i); } public ElementValueArrayInitializerContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_elementValueArrayInitializer; } } public final ElementValueArrayInitializerContext elementValueArrayInitializer() throws RecognitionException { ElementValueArrayInitializerContext _localctx = new ElementValueArrayInitializerContext(_ctx, getState()); enterRule(_localctx, 120, RULE_elementValueArrayInitializer); int _la; try { int _alt; enterOuterAlt(_localctx, 1); { setState(855); match(LBRACE); setState(864); _errHandler.sync(this); _la = _input.LA(1); if (((((_la - 3)) & ~0x3f) == 0 && ((1L << (_la - 3)) & ((1L << (BOOLEAN - 3)) | (1L << (BYTE - 3)) | (1L << (CHAR - 3)) | (1L << (DOUBLE - 3)) | (1L << (FLOAT - 3)) | (1L << (INT - 3)) | (1L << (LONG - 3)) | (1L << (NEW - 3)) | (1L << (SHORT - 3)) | (1L << (SUPER - 3)) | (1L << (SWITCH - 3)) | (1L << (THIS - 3)) | (1L << (VOID - 3)) | (1L << (MODULE - 3)) | (1L << (OPEN - 3)) | (1L << (REQUIRES - 3)) | (1L << (EXPORTS - 3)) | (1L << (OPENS - 3)) | (1L << (TO - 3)) | (1L << (USES - 3)) | (1L << (PROVIDES - 3)) | (1L << (WITH - 3)) | (1L << (TRANSITIVE - 3)) | (1L << (VAR - 3)) | (1L << (YIELD - 3)) | (1L << (RECORD - 3)) | (1L << (SEALED - 3)) | (1L << (PERMITS - 3)))) != 0) || ((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & ((1L << (DECIMAL_LITERAL - 67)) | (1L << (HEX_LITERAL - 67)) | (1L << (OCT_LITERAL - 67)) | (1L << (BINARY_LITERAL - 67)) | (1L << (FLOAT_LITERAL - 67)) | (1L << (HEX_FLOAT_LITERAL - 67)) | (1L << (BOOL_LITERAL - 67)) | (1L << (CHAR_LITERAL - 67)) | (1L << (STRING_LITERAL - 67)) | (1L << (TEXT_BLOCK - 67)) | (1L << (NULL_LITERAL - 67)) | (1L << (LPAREN - 67)) | (1L << (LBRACE - 67)) | (1L << (LT - 67)) | (1L << (BANG - 67)) | (1L << (TILDE - 67)) | (1L << (INC - 67)) | (1L << (DEC - 67)) | (1L << (ADD - 67)) | (1L << (SUB - 67)) | (1L << (AT - 67)) | (1L << (IDENTIFIER - 67)))) != 0)) { { setState(856); elementValue(); setState(861); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,93,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(857); match(COMMA); setState(858); elementValue(); } } } setState(863); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,93,_ctx); } } } setState(867); _errHandler.sync(this); _la = _input.LA(1); if (_la==COMMA) { { setState(866); match(COMMA); } } setState(869); match(RBRACE); } } 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 TerminalNode AT() { return getToken(JavaParser.AT, 0); } public TerminalNode INTERFACE() { return getToken(JavaParser.INTERFACE, 0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public AnnotationTypeBodyContext annotationTypeBody() { return getRuleContext(AnnotationTypeBodyContext.class,0); } public AnnotationTypeDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_annotationTypeDeclaration; } } public final AnnotationTypeDeclarationContext annotationTypeDeclaration() throws RecognitionException { AnnotationTypeDeclarationContext _localctx = new AnnotationTypeDeclarationContext(_ctx, getState()); enterRule(_localctx, 122, RULE_annotationTypeDeclaration); try { enterOuterAlt(_localctx, 1); { setState(871); match(AT); setState(872); match(INTERFACE); setState(873); identifier(); setState(874); 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 TerminalNode LBRACE() { return getToken(JavaParser.LBRACE, 0); } public TerminalNode RBRACE() { return getToken(JavaParser.RBRACE, 0); } public List annotationTypeElementDeclaration() { return getRuleContexts(AnnotationTypeElementDeclarationContext.class); } public AnnotationTypeElementDeclarationContext annotationTypeElementDeclaration(int i) { return getRuleContext(AnnotationTypeElementDeclarationContext.class,i); } public AnnotationTypeBodyContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_annotationTypeBody; } } public final AnnotationTypeBodyContext annotationTypeBody() throws RecognitionException { AnnotationTypeBodyContext _localctx = new AnnotationTypeBodyContext(_ctx, getState()); enterRule(_localctx, 124, RULE_annotationTypeBody); int _la; try { enterOuterAlt(_localctx, 1); { setState(876); match(LBRACE); setState(880); _errHandler.sync(this); _la = _input.LA(1); while (((((_la - 1)) & ~0x3f) == 0 && ((1L << (_la - 1)) & ((1L << (ABSTRACT - 1)) | (1L << (BOOLEAN - 1)) | (1L << (BYTE - 1)) | (1L << (CHAR - 1)) | (1L << (CLASS - 1)) | (1L << (DOUBLE - 1)) | (1L << (ENUM - 1)) | (1L << (FINAL - 1)) | (1L << (FLOAT - 1)) | (1L << (INT - 1)) | (1L << (INTERFACE - 1)) | (1L << (LONG - 1)) | (1L << (NATIVE - 1)) | (1L << (PRIVATE - 1)) | (1L << (PROTECTED - 1)) | (1L << (PUBLIC - 1)) | (1L << (SHORT - 1)) | (1L << (STATIC - 1)) | (1L << (STRICTFP - 1)) | (1L << (SYNCHRONIZED - 1)) | (1L << (TRANSIENT - 1)) | (1L << (VOLATILE - 1)) | (1L << (MODULE - 1)) | (1L << (OPEN - 1)) | (1L << (REQUIRES - 1)) | (1L << (EXPORTS - 1)) | (1L << (OPENS - 1)) | (1L << (TO - 1)) | (1L << (USES - 1)) | (1L << (PROVIDES - 1)) | (1L << (WITH - 1)) | (1L << (TRANSITIVE - 1)) | (1L << (VAR - 1)) | (1L << (YIELD - 1)) | (1L << (RECORD - 1)) | (1L << (SEALED - 1)))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (PERMITS - 65)) | (1L << (NON_SEALED - 65)) | (1L << (SEMI - 65)) | (1L << (AT - 65)) | (1L << (IDENTIFIER - 65)))) != 0)) { { { setState(877); annotationTypeElementDeclaration(); } } setState(882); _errHandler.sync(this); _la = _input.LA(1); } setState(883); match(RBRACE); } } 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 AnnotationTypeElementRestContext annotationTypeElementRest() { return getRuleContext(AnnotationTypeElementRestContext.class,0); } public List modifier() { return getRuleContexts(ModifierContext.class); } public ModifierContext modifier(int i) { return getRuleContext(ModifierContext.class,i); } public TerminalNode SEMI() { return getToken(JavaParser.SEMI, 0); } public AnnotationTypeElementDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_annotationTypeElementDeclaration; } } public final AnnotationTypeElementDeclarationContext annotationTypeElementDeclaration() throws RecognitionException { AnnotationTypeElementDeclarationContext _localctx = new AnnotationTypeElementDeclarationContext(_ctx, getState()); enterRule(_localctx, 126, RULE_annotationTypeElementDeclaration); try { int _alt; setState(893); _errHandler.sync(this); switch (_input.LA(1)) { case ABSTRACT: case BOOLEAN: case BYTE: case CHAR: case CLASS: case DOUBLE: case ENUM: case FINAL: case FLOAT: case INT: case INTERFACE: case LONG: case NATIVE: case PRIVATE: case PROTECTED: case PUBLIC: case SHORT: case STATIC: case STRICTFP: case SYNCHRONIZED: case TRANSIENT: case VOLATILE: case MODULE: case OPEN: case REQUIRES: case EXPORTS: case OPENS: case TO: case USES: case PROVIDES: case WITH: case TRANSITIVE: case VAR: case YIELD: case RECORD: case SEALED: case PERMITS: case NON_SEALED: case AT: case IDENTIFIER: enterOuterAlt(_localctx, 1); { setState(888); _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(885); modifier(); } } } setState(890); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,97,_ctx); } setState(891); annotationTypeElementRest(); } break; case SEMI: enterOuterAlt(_localctx, 2); { setState(892); 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 AnnotationTypeElementRestContext extends ParserRuleContext { public TypeTypeContext typeType() { return getRuleContext(TypeTypeContext.class,0); } public AnnotationMethodOrConstantRestContext annotationMethodOrConstantRest() { return getRuleContext(AnnotationMethodOrConstantRestContext.class,0); } public TerminalNode SEMI() { return getToken(JavaParser.SEMI, 0); } public ClassDeclarationContext classDeclaration() { return getRuleContext(ClassDeclarationContext.class,0); } public InterfaceDeclarationContext interfaceDeclaration() { return getRuleContext(InterfaceDeclarationContext.class,0); } public EnumDeclarationContext enumDeclaration() { return getRuleContext(EnumDeclarationContext.class,0); } public AnnotationTypeDeclarationContext annotationTypeDeclaration() { return getRuleContext(AnnotationTypeDeclarationContext.class,0); } public RecordDeclarationContext recordDeclaration() { return getRuleContext(RecordDeclarationContext.class,0); } public AnnotationTypeElementRestContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_annotationTypeElementRest; } } public final AnnotationTypeElementRestContext annotationTypeElementRest() throws RecognitionException { AnnotationTypeElementRestContext _localctx = new AnnotationTypeElementRestContext(_ctx, getState()); enterRule(_localctx, 128, RULE_annotationTypeElementRest); try { setState(919); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,104,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { setState(895); typeType(); setState(896); annotationMethodOrConstantRest(); setState(897); match(SEMI); } break; case 2: enterOuterAlt(_localctx, 2); { setState(899); classDeclaration(); setState(901); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,99,_ctx) ) { case 1: { setState(900); match(SEMI); } break; } } break; case 3: enterOuterAlt(_localctx, 3); { setState(903); interfaceDeclaration(); setState(905); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,100,_ctx) ) { case 1: { setState(904); match(SEMI); } break; } } break; case 4: enterOuterAlt(_localctx, 4); { setState(907); enumDeclaration(); setState(909); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,101,_ctx) ) { case 1: { setState(908); match(SEMI); } break; } } break; case 5: enterOuterAlt(_localctx, 5); { setState(911); annotationTypeDeclaration(); setState(913); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,102,_ctx) ) { case 1: { setState(912); match(SEMI); } break; } } break; case 6: enterOuterAlt(_localctx, 6); { setState(915); recordDeclaration(); setState(917); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,103,_ctx) ) { case 1: { setState(916); match(SEMI); } break; } } break; } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class AnnotationMethodOrConstantRestContext extends ParserRuleContext { public AnnotationMethodRestContext annotationMethodRest() { return getRuleContext(AnnotationMethodRestContext.class,0); } public AnnotationConstantRestContext annotationConstantRest() { return getRuleContext(AnnotationConstantRestContext.class,0); } public AnnotationMethodOrConstantRestContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_annotationMethodOrConstantRest; } } public final AnnotationMethodOrConstantRestContext annotationMethodOrConstantRest() throws RecognitionException { AnnotationMethodOrConstantRestContext _localctx = new AnnotationMethodOrConstantRestContext(_ctx, getState()); enterRule(_localctx, 130, RULE_annotationMethodOrConstantRest); try { setState(923); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,105,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { setState(921); annotationMethodRest(); } break; case 2: enterOuterAlt(_localctx, 2); { setState(922); annotationConstantRest(); } break; } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class AnnotationMethodRestContext extends ParserRuleContext { public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public TerminalNode LPAREN() { return getToken(JavaParser.LPAREN, 0); } public TerminalNode RPAREN() { return getToken(JavaParser.RPAREN, 0); } public DefaultValueContext defaultValue() { return getRuleContext(DefaultValueContext.class,0); } public AnnotationMethodRestContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_annotationMethodRest; } } public final AnnotationMethodRestContext annotationMethodRest() throws RecognitionException { AnnotationMethodRestContext _localctx = new AnnotationMethodRestContext(_ctx, getState()); enterRule(_localctx, 132, RULE_annotationMethodRest); int _la; try { enterOuterAlt(_localctx, 1); { setState(925); identifier(); setState(926); match(LPAREN); setState(927); match(RPAREN); setState(929); _errHandler.sync(this); _la = _input.LA(1); if (_la==DEFAULT) { { setState(928); defaultValue(); } } } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class AnnotationConstantRestContext extends ParserRuleContext { public VariableDeclaratorsContext variableDeclarators() { return getRuleContext(VariableDeclaratorsContext.class,0); } public AnnotationConstantRestContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_annotationConstantRest; } } public final AnnotationConstantRestContext annotationConstantRest() throws RecognitionException { AnnotationConstantRestContext _localctx = new AnnotationConstantRestContext(_ctx, getState()); enterRule(_localctx, 134, RULE_annotationConstantRest); try { enterOuterAlt(_localctx, 1); { setState(931); variableDeclarators(); } } 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 TerminalNode DEFAULT() { return getToken(JavaParser.DEFAULT, 0); } public ElementValueContext elementValue() { return getRuleContext(ElementValueContext.class,0); } public DefaultValueContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_defaultValue; } } public final DefaultValueContext defaultValue() throws RecognitionException { DefaultValueContext _localctx = new DefaultValueContext(_ctx, getState()); enterRule(_localctx, 136, RULE_defaultValue); try { enterOuterAlt(_localctx, 1); { setState(933); match(DEFAULT); setState(934); elementValue(); } } 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 TerminalNode MODULE() { return getToken(JavaParser.MODULE, 0); } public QualifiedNameContext qualifiedName() { return getRuleContext(QualifiedNameContext.class,0); } public ModuleBodyContext moduleBody() { return getRuleContext(ModuleBodyContext.class,0); } public TerminalNode OPEN() { return getToken(JavaParser.OPEN, 0); } public ModuleDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_moduleDeclaration; } } public final ModuleDeclarationContext moduleDeclaration() throws RecognitionException { ModuleDeclarationContext _localctx = new ModuleDeclarationContext(_ctx, getState()); enterRule(_localctx, 138, RULE_moduleDeclaration); int _la; try { enterOuterAlt(_localctx, 1); { setState(937); _errHandler.sync(this); _la = _input.LA(1); if (_la==OPEN) { { setState(936); match(OPEN); } } setState(939); match(MODULE); setState(940); qualifiedName(); setState(941); moduleBody(); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class ModuleBodyContext extends ParserRuleContext { public TerminalNode LBRACE() { return getToken(JavaParser.LBRACE, 0); } public TerminalNode RBRACE() { return getToken(JavaParser.RBRACE, 0); } public List moduleDirective() { return getRuleContexts(ModuleDirectiveContext.class); } public ModuleDirectiveContext moduleDirective(int i) { return getRuleContext(ModuleDirectiveContext.class,i); } public ModuleBodyContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_moduleBody; } } public final ModuleBodyContext moduleBody() throws RecognitionException { ModuleBodyContext _localctx = new ModuleBodyContext(_ctx, getState()); enterRule(_localctx, 140, RULE_moduleBody); int _la; try { enterOuterAlt(_localctx, 1); { setState(943); match(LBRACE); setState(947); _errHandler.sync(this); _la = _input.LA(1); while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << REQUIRES) | (1L << EXPORTS) | (1L << OPENS) | (1L << USES) | (1L << PROVIDES))) != 0)) { { { setState(944); moduleDirective(); } } setState(949); _errHandler.sync(this); _la = _input.LA(1); } setState(950); 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 TerminalNode REQUIRES() { return getToken(JavaParser.REQUIRES, 0); } public List qualifiedName() { return getRuleContexts(QualifiedNameContext.class); } public QualifiedNameContext qualifiedName(int i) { return getRuleContext(QualifiedNameContext.class,i); } public TerminalNode SEMI() { return getToken(JavaParser.SEMI, 0); } public List requiresModifier() { return getRuleContexts(RequiresModifierContext.class); } public RequiresModifierContext requiresModifier(int i) { return getRuleContext(RequiresModifierContext.class,i); } public TerminalNode EXPORTS() { return getToken(JavaParser.EXPORTS, 0); } public TerminalNode TO() { return getToken(JavaParser.TO, 0); } public TerminalNode OPENS() { return getToken(JavaParser.OPENS, 0); } public TerminalNode USES() { return getToken(JavaParser.USES, 0); } public TerminalNode PROVIDES() { return getToken(JavaParser.PROVIDES, 0); } public TerminalNode WITH() { return getToken(JavaParser.WITH, 0); } public ModuleDirectiveContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_moduleDirective; } } public final ModuleDirectiveContext moduleDirective() throws RecognitionException { ModuleDirectiveContext _localctx = new ModuleDirectiveContext(_ctx, getState()); enterRule(_localctx, 142, RULE_moduleDirective); int _la; try { int _alt; setState(988); _errHandler.sync(this); switch (_input.LA(1)) { case REQUIRES: enterOuterAlt(_localctx, 1); { setState(952); match(REQUIRES); setState(956); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,109,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(953); requiresModifier(); } } } setState(958); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,109,_ctx); } setState(959); qualifiedName(); setState(960); match(SEMI); } break; case EXPORTS: enterOuterAlt(_localctx, 2); { setState(962); match(EXPORTS); setState(963); qualifiedName(); setState(966); _errHandler.sync(this); _la = _input.LA(1); if (_la==TO) { { setState(964); match(TO); setState(965); qualifiedName(); } } setState(968); match(SEMI); } break; case OPENS: enterOuterAlt(_localctx, 3); { setState(970); match(OPENS); setState(971); qualifiedName(); setState(974); _errHandler.sync(this); _la = _input.LA(1); if (_la==TO) { { setState(972); match(TO); setState(973); qualifiedName(); } } setState(976); match(SEMI); } break; case USES: enterOuterAlt(_localctx, 4); { setState(978); match(USES); setState(979); qualifiedName(); setState(980); match(SEMI); } break; case PROVIDES: enterOuterAlt(_localctx, 5); { setState(982); match(PROVIDES); setState(983); qualifiedName(); setState(984); match(WITH); setState(985); qualifiedName(); setState(986); 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 RequiresModifierContext extends ParserRuleContext { public TerminalNode TRANSITIVE() { return getToken(JavaParser.TRANSITIVE, 0); } public TerminalNode STATIC() { return getToken(JavaParser.STATIC, 0); } public RequiresModifierContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_requiresModifier; } } public final RequiresModifierContext requiresModifier() throws RecognitionException { RequiresModifierContext _localctx = new RequiresModifierContext(_ctx, getState()); enterRule(_localctx, 144, RULE_requiresModifier); int _la; try { enterOuterAlt(_localctx, 1); { setState(990); _la = _input.LA(1); if ( !(_la==STATIC || _la==TRANSITIVE) ) { _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 RecordDeclarationContext extends ParserRuleContext { public TerminalNode RECORD() { return getToken(JavaParser.RECORD, 0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public RecordHeaderContext recordHeader() { return getRuleContext(RecordHeaderContext.class,0); } public RecordBodyContext recordBody() { return getRuleContext(RecordBodyContext.class,0); } public TypeParametersContext typeParameters() { return getRuleContext(TypeParametersContext.class,0); } public TerminalNode IMPLEMENTS() { return getToken(JavaParser.IMPLEMENTS, 0); } public TypeListContext typeList() { return getRuleContext(TypeListContext.class,0); } public RecordDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_recordDeclaration; } } public final RecordDeclarationContext recordDeclaration() throws RecognitionException { RecordDeclarationContext _localctx = new RecordDeclarationContext(_ctx, getState()); enterRule(_localctx, 146, RULE_recordDeclaration); int _la; try { enterOuterAlt(_localctx, 1); { setState(992); match(RECORD); setState(993); identifier(); setState(995); _errHandler.sync(this); _la = _input.LA(1); if (_la==LT) { { setState(994); typeParameters(); } } setState(997); recordHeader(); setState(1000); _errHandler.sync(this); _la = _input.LA(1); if (_la==IMPLEMENTS) { { setState(998); match(IMPLEMENTS); setState(999); typeList(); } } setState(1002); recordBody(); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class RecordHeaderContext extends ParserRuleContext { public TerminalNode LPAREN() { return getToken(JavaParser.LPAREN, 0); } public TerminalNode RPAREN() { return getToken(JavaParser.RPAREN, 0); } public RecordComponentListContext recordComponentList() { return getRuleContext(RecordComponentListContext.class,0); } public RecordHeaderContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_recordHeader; } } public final RecordHeaderContext recordHeader() throws RecognitionException { RecordHeaderContext _localctx = new RecordHeaderContext(_ctx, getState()); enterRule(_localctx, 148, RULE_recordHeader); int _la; try { enterOuterAlt(_localctx, 1); { setState(1004); match(LPAREN); setState(1006); _errHandler.sync(this); _la = _input.LA(1); if (((((_la - 3)) & ~0x3f) == 0 && ((1L << (_la - 3)) & ((1L << (BOOLEAN - 3)) | (1L << (BYTE - 3)) | (1L << (CHAR - 3)) | (1L << (DOUBLE - 3)) | (1L << (FLOAT - 3)) | (1L << (INT - 3)) | (1L << (LONG - 3)) | (1L << (SHORT - 3)) | (1L << (MODULE - 3)) | (1L << (OPEN - 3)) | (1L << (REQUIRES - 3)) | (1L << (EXPORTS - 3)) | (1L << (OPENS - 3)) | (1L << (TO - 3)) | (1L << (USES - 3)) | (1L << (PROVIDES - 3)) | (1L << (WITH - 3)) | (1L << (TRANSITIVE - 3)) | (1L << (VAR - 3)) | (1L << (YIELD - 3)) | (1L << (RECORD - 3)) | (1L << (SEALED - 3)) | (1L << (PERMITS - 3)))) != 0) || _la==AT || _la==IDENTIFIER) { { setState(1005); recordComponentList(); } } setState(1008); match(RPAREN); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class RecordComponentListContext extends ParserRuleContext { public List recordComponent() { return getRuleContexts(RecordComponentContext.class); } public RecordComponentContext recordComponent(int i) { return getRuleContext(RecordComponentContext.class,i); } public List COMMA() { return getTokens(JavaParser.COMMA); } public TerminalNode COMMA(int i) { return getToken(JavaParser.COMMA, i); } public RecordComponentListContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_recordComponentList; } } public final RecordComponentListContext recordComponentList() throws RecognitionException { RecordComponentListContext _localctx = new RecordComponentListContext(_ctx, getState()); enterRule(_localctx, 150, RULE_recordComponentList); int _la; try { enterOuterAlt(_localctx, 1); { setState(1010); recordComponent(); setState(1015); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { setState(1011); match(COMMA); setState(1012); recordComponent(); } } setState(1017); _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 RecordComponentContext extends ParserRuleContext { public TypeTypeContext typeType() { return getRuleContext(TypeTypeContext.class,0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public RecordComponentContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_recordComponent; } } public final RecordComponentContext recordComponent() throws RecognitionException { RecordComponentContext _localctx = new RecordComponentContext(_ctx, getState()); enterRule(_localctx, 152, RULE_recordComponent); try { enterOuterAlt(_localctx, 1); { setState(1018); typeType(); setState(1019); identifier(); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class RecordBodyContext extends ParserRuleContext { public TerminalNode LBRACE() { return getToken(JavaParser.LBRACE, 0); } public TerminalNode RBRACE() { return getToken(JavaParser.RBRACE, 0); } public List classBodyDeclaration() { return getRuleContexts(ClassBodyDeclarationContext.class); } public ClassBodyDeclarationContext classBodyDeclaration(int i) { return getRuleContext(ClassBodyDeclarationContext.class,i); } public List compactConstructorDeclaration() { return getRuleContexts(CompactConstructorDeclarationContext.class); } public CompactConstructorDeclarationContext compactConstructorDeclaration(int i) { return getRuleContext(CompactConstructorDeclarationContext.class,i); } public RecordBodyContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_recordBody; } } public final RecordBodyContext recordBody() throws RecognitionException { RecordBodyContext _localctx = new RecordBodyContext(_ctx, getState()); enterRule(_localctx, 154, RULE_recordBody); int _la; try { enterOuterAlt(_localctx, 1); { setState(1021); match(LBRACE); setState(1026); _errHandler.sync(this); _la = _input.LA(1); while (((((_la - 1)) & ~0x3f) == 0 && ((1L << (_la - 1)) & ((1L << (ABSTRACT - 1)) | (1L << (BOOLEAN - 1)) | (1L << (BYTE - 1)) | (1L << (CHAR - 1)) | (1L << (CLASS - 1)) | (1L << (DOUBLE - 1)) | (1L << (ENUM - 1)) | (1L << (FINAL - 1)) | (1L << (FLOAT - 1)) | (1L << (INT - 1)) | (1L << (INTERFACE - 1)) | (1L << (LONG - 1)) | (1L << (NATIVE - 1)) | (1L << (PRIVATE - 1)) | (1L << (PROTECTED - 1)) | (1L << (PUBLIC - 1)) | (1L << (SHORT - 1)) | (1L << (STATIC - 1)) | (1L << (STRICTFP - 1)) | (1L << (SYNCHRONIZED - 1)) | (1L << (TRANSIENT - 1)) | (1L << (VOID - 1)) | (1L << (VOLATILE - 1)) | (1L << (MODULE - 1)) | (1L << (OPEN - 1)) | (1L << (REQUIRES - 1)) | (1L << (EXPORTS - 1)) | (1L << (OPENS - 1)) | (1L << (TO - 1)) | (1L << (USES - 1)) | (1L << (PROVIDES - 1)) | (1L << (WITH - 1)) | (1L << (TRANSITIVE - 1)) | (1L << (VAR - 1)) | (1L << (YIELD - 1)) | (1L << (RECORD - 1)) | (1L << (SEALED - 1)))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (PERMITS - 65)) | (1L << (NON_SEALED - 65)) | (1L << (LBRACE - 65)) | (1L << (SEMI - 65)) | (1L << (LT - 65)) | (1L << (AT - 65)) | (1L << (IDENTIFIER - 65)))) != 0)) { { setState(1024); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,117,_ctx) ) { case 1: { setState(1022); classBodyDeclaration(); } break; case 2: { setState(1023); compactConstructorDeclaration(); } break; } } setState(1028); _errHandler.sync(this); _la = _input.LA(1); } setState(1029); match(RBRACE); } } 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 TerminalNode LBRACE() { return getToken(JavaParser.LBRACE, 0); } public TerminalNode RBRACE() { return getToken(JavaParser.RBRACE, 0); } public List blockStatement() { return getRuleContexts(BlockStatementContext.class); } public BlockStatementContext blockStatement(int i) { return getRuleContext(BlockStatementContext.class,i); } public BlockContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_block; } } public final BlockContext block() throws RecognitionException { BlockContext _localctx = new BlockContext(_ctx, getState()); enterRule(_localctx, 156, RULE_block); int _la; try { enterOuterAlt(_localctx, 1); { setState(1031); match(LBRACE); setState(1035); _errHandler.sync(this); _la = _input.LA(1); while (((((_la - 1)) & ~0x3f) == 0 && ((1L << (_la - 1)) & ((1L << (ABSTRACT - 1)) | (1L << (ASSERT - 1)) | (1L << (BOOLEAN - 1)) | (1L << (BREAK - 1)) | (1L << (BYTE - 1)) | (1L << (CHAR - 1)) | (1L << (CLASS - 1)) | (1L << (CONTINUE - 1)) | (1L << (DO - 1)) | (1L << (DOUBLE - 1)) | (1L << (FINAL - 1)) | (1L << (FLOAT - 1)) | (1L << (FOR - 1)) | (1L << (IF - 1)) | (1L << (INT - 1)) | (1L << (INTERFACE - 1)) | (1L << (LONG - 1)) | (1L << (NEW - 1)) | (1L << (PRIVATE - 1)) | (1L << (PROTECTED - 1)) | (1L << (PUBLIC - 1)) | (1L << (RETURN - 1)) | (1L << (SHORT - 1)) | (1L << (STATIC - 1)) | (1L << (STRICTFP - 1)) | (1L << (SUPER - 1)) | (1L << (SWITCH - 1)) | (1L << (SYNCHRONIZED - 1)) | (1L << (THIS - 1)) | (1L << (THROW - 1)) | (1L << (TRY - 1)) | (1L << (VOID - 1)) | (1L << (WHILE - 1)) | (1L << (MODULE - 1)) | (1L << (OPEN - 1)) | (1L << (REQUIRES - 1)) | (1L << (EXPORTS - 1)) | (1L << (OPENS - 1)) | (1L << (TO - 1)) | (1L << (USES - 1)) | (1L << (PROVIDES - 1)) | (1L << (WITH - 1)) | (1L << (TRANSITIVE - 1)) | (1L << (VAR - 1)) | (1L << (YIELD - 1)) | (1L << (RECORD - 1)) | (1L << (SEALED - 1)))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (PERMITS - 65)) | (1L << (NON_SEALED - 65)) | (1L << (DECIMAL_LITERAL - 65)) | (1L << (HEX_LITERAL - 65)) | (1L << (OCT_LITERAL - 65)) | (1L << (BINARY_LITERAL - 65)) | (1L << (FLOAT_LITERAL - 65)) | (1L << (HEX_FLOAT_LITERAL - 65)) | (1L << (BOOL_LITERAL - 65)) | (1L << (CHAR_LITERAL - 65)) | (1L << (STRING_LITERAL - 65)) | (1L << (TEXT_BLOCK - 65)) | (1L << (NULL_LITERAL - 65)) | (1L << (LPAREN - 65)) | (1L << (LBRACE - 65)) | (1L << (SEMI - 65)) | (1L << (LT - 65)) | (1L << (BANG - 65)) | (1L << (TILDE - 65)) | (1L << (INC - 65)) | (1L << (DEC - 65)) | (1L << (ADD - 65)) | (1L << (SUB - 65)) | (1L << (AT - 65)) | (1L << (IDENTIFIER - 65)))) != 0)) { { { setState(1032); blockStatement(); } } setState(1037); _errHandler.sync(this); _la = _input.LA(1); } setState(1038); match(RBRACE); } } 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 LocalVariableDeclarationContext localVariableDeclaration() { return getRuleContext(LocalVariableDeclarationContext.class,0); } public TerminalNode SEMI() { return getToken(JavaParser.SEMI, 0); } public LocalTypeDeclarationContext localTypeDeclaration() { return getRuleContext(LocalTypeDeclarationContext.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; } } public final BlockStatementContext blockStatement() throws RecognitionException { BlockStatementContext _localctx = new BlockStatementContext(_ctx, getState()); enterRule(_localctx, 158, RULE_blockStatement); try { setState(1045); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,120,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { setState(1040); localVariableDeclaration(); setState(1041); match(SEMI); } break; case 2: enterOuterAlt(_localctx, 2); { setState(1043); localTypeDeclaration(); } break; case 3: enterOuterAlt(_localctx, 3); { setState(1044); statement(); } break; } } 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 TerminalNode VAR() { return getToken(JavaParser.VAR, 0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public TerminalNode ASSIGN() { return getToken(JavaParser.ASSIGN, 0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } public TypeTypeContext typeType() { return getRuleContext(TypeTypeContext.class,0); } public VariableDeclaratorsContext variableDeclarators() { return getRuleContext(VariableDeclaratorsContext.class,0); } public List 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; } } public final LocalVariableDeclarationContext localVariableDeclaration() throws RecognitionException { LocalVariableDeclarationContext _localctx = new LocalVariableDeclarationContext(_ctx, getState()); enterRule(_localctx, 160, RULE_localVariableDeclaration); try { int _alt; enterOuterAlt(_localctx, 1); { setState(1050); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,121,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(1047); variableModifier(); } } } setState(1052); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,121,_ctx); } setState(1061); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,122,_ctx) ) { case 1: { setState(1053); match(VAR); setState(1054); identifier(); setState(1055); match(ASSIGN); setState(1056); expression(0); } break; case 2: { setState(1058); typeType(); setState(1059); variableDeclarators(); } 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(JavaParser.IDENTIFIER, 0); } public TerminalNode MODULE() { return getToken(JavaParser.MODULE, 0); } public TerminalNode OPEN() { return getToken(JavaParser.OPEN, 0); } public TerminalNode REQUIRES() { return getToken(JavaParser.REQUIRES, 0); } public TerminalNode EXPORTS() { return getToken(JavaParser.EXPORTS, 0); } public TerminalNode OPENS() { return getToken(JavaParser.OPENS, 0); } public TerminalNode TO() { return getToken(JavaParser.TO, 0); } public TerminalNode USES() { return getToken(JavaParser.USES, 0); } public TerminalNode PROVIDES() { return getToken(JavaParser.PROVIDES, 0); } public TerminalNode WITH() { return getToken(JavaParser.WITH, 0); } public TerminalNode TRANSITIVE() { return getToken(JavaParser.TRANSITIVE, 0); } public TerminalNode YIELD() { return getToken(JavaParser.YIELD, 0); } public TerminalNode SEALED() { return getToken(JavaParser.SEALED, 0); } public TerminalNode PERMITS() { return getToken(JavaParser.PERMITS, 0); } public TerminalNode RECORD() { return getToken(JavaParser.RECORD, 0); } public TerminalNode VAR() { return getToken(JavaParser.VAR, 0); } public IdentifierContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_identifier; } } public final IdentifierContext identifier() throws RecognitionException { IdentifierContext _localctx = new IdentifierContext(_ctx, getState()); enterRule(_localctx, 162, RULE_identifier); int _la; try { enterOuterAlt(_localctx, 1); { setState(1063); _la = _input.LA(1); if ( !(((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & ((1L << (MODULE - 51)) | (1L << (OPEN - 51)) | (1L << (REQUIRES - 51)) | (1L << (EXPORTS - 51)) | (1L << (OPENS - 51)) | (1L << (TO - 51)) | (1L << (USES - 51)) | (1L << (PROVIDES - 51)) | (1L << (WITH - 51)) | (1L << (TRANSITIVE - 51)) | (1L << (VAR - 51)) | (1L << (YIELD - 51)) | (1L << (RECORD - 51)) | (1L << (SEALED - 51)) | (1L << (PERMITS - 51)))) != 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 static class TypeIdentifierContext extends ParserRuleContext { public TerminalNode IDENTIFIER() { return getToken(JavaParser.IDENTIFIER, 0); } public TerminalNode MODULE() { return getToken(JavaParser.MODULE, 0); } public TerminalNode OPEN() { return getToken(JavaParser.OPEN, 0); } public TerminalNode REQUIRES() { return getToken(JavaParser.REQUIRES, 0); } public TerminalNode EXPORTS() { return getToken(JavaParser.EXPORTS, 0); } public TerminalNode OPENS() { return getToken(JavaParser.OPENS, 0); } public TerminalNode TO() { return getToken(JavaParser.TO, 0); } public TerminalNode USES() { return getToken(JavaParser.USES, 0); } public TerminalNode PROVIDES() { return getToken(JavaParser.PROVIDES, 0); } public TerminalNode WITH() { return getToken(JavaParser.WITH, 0); } public TerminalNode TRANSITIVE() { return getToken(JavaParser.TRANSITIVE, 0); } public TerminalNode SEALED() { return getToken(JavaParser.SEALED, 0); } public TerminalNode PERMITS() { return getToken(JavaParser.PERMITS, 0); } public TerminalNode RECORD() { return getToken(JavaParser.RECORD, 0); } public TypeIdentifierContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_typeIdentifier; } } public final TypeIdentifierContext typeIdentifier() throws RecognitionException { TypeIdentifierContext _localctx = new TypeIdentifierContext(_ctx, getState()); enterRule(_localctx, 164, RULE_typeIdentifier); int _la; try { enterOuterAlt(_localctx, 1); { setState(1065); _la = _input.LA(1); if ( !(((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & ((1L << (MODULE - 51)) | (1L << (OPEN - 51)) | (1L << (REQUIRES - 51)) | (1L << (EXPORTS - 51)) | (1L << (OPENS - 51)) | (1L << (TO - 51)) | (1L << (USES - 51)) | (1L << (PROVIDES - 51)) | (1L << (WITH - 51)) | (1L << (TRANSITIVE - 51)) | (1L << (RECORD - 51)) | (1L << (SEALED - 51)) | (1L << (PERMITS - 51)))) != 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 static class LocalTypeDeclarationContext extends ParserRuleContext { public ClassDeclarationContext classDeclaration() { return getRuleContext(ClassDeclarationContext.class,0); } public InterfaceDeclarationContext interfaceDeclaration() { return getRuleContext(InterfaceDeclarationContext.class,0); } public RecordDeclarationContext recordDeclaration() { return getRuleContext(RecordDeclarationContext.class,0); } public List classOrInterfaceModifier() { return getRuleContexts(ClassOrInterfaceModifierContext.class); } public ClassOrInterfaceModifierContext classOrInterfaceModifier(int i) { return getRuleContext(ClassOrInterfaceModifierContext.class,i); } public LocalTypeDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_localTypeDeclaration; } } public final LocalTypeDeclarationContext localTypeDeclaration() throws RecognitionException { LocalTypeDeclarationContext _localctx = new LocalTypeDeclarationContext(_ctx, getState()); enterRule(_localctx, 166, RULE_localTypeDeclaration); try { int _alt; enterOuterAlt(_localctx, 1); { setState(1070); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,123,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(1067); classOrInterfaceModifier(); } } } setState(1072); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,123,_ctx); } setState(1076); _errHandler.sync(this); switch (_input.LA(1)) { case CLASS: { setState(1073); classDeclaration(); } break; case INTERFACE: { setState(1074); interfaceDeclaration(); } break; case RECORD: { setState(1075); recordDeclaration(); } 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 StatementContext extends ParserRuleContext { public BlockContext blockLabel; public ExpressionContext statementExpression; public IdentifierContext identifierLabel; public BlockContext block() { return getRuleContext(BlockContext.class,0); } public TerminalNode ASSERT() { return getToken(JavaParser.ASSERT, 0); } public List expression() { return getRuleContexts(ExpressionContext.class); } public ExpressionContext expression(int i) { return getRuleContext(ExpressionContext.class,i); } public TerminalNode SEMI() { return getToken(JavaParser.SEMI, 0); } public TerminalNode COLON() { return getToken(JavaParser.COLON, 0); } public TerminalNode IF() { return getToken(JavaParser.IF, 0); } public ParExpressionContext parExpression() { return getRuleContext(ParExpressionContext.class,0); } public List statement() { return getRuleContexts(StatementContext.class); } public StatementContext statement(int i) { return getRuleContext(StatementContext.class,i); } public TerminalNode ELSE() { return getToken(JavaParser.ELSE, 0); } public TerminalNode FOR() { return getToken(JavaParser.FOR, 0); } public TerminalNode LPAREN() { return getToken(JavaParser.LPAREN, 0); } public ForControlContext forControl() { return getRuleContext(ForControlContext.class,0); } public TerminalNode RPAREN() { return getToken(JavaParser.RPAREN, 0); } public TerminalNode WHILE() { return getToken(JavaParser.WHILE, 0); } public TerminalNode DO() { return getToken(JavaParser.DO, 0); } public TerminalNode TRY() { return getToken(JavaParser.TRY, 0); } public FinallyBlockContext finallyBlock() { return getRuleContext(FinallyBlockContext.class,0); } public List catchClause() { return getRuleContexts(CatchClauseContext.class); } public CatchClauseContext catchClause(int i) { return getRuleContext(CatchClauseContext.class,i); } public ResourceSpecificationContext resourceSpecification() { return getRuleContext(ResourceSpecificationContext.class,0); } public TerminalNode SWITCH() { return getToken(JavaParser.SWITCH, 0); } public TerminalNode LBRACE() { return getToken(JavaParser.LBRACE, 0); } public TerminalNode RBRACE() { return getToken(JavaParser.RBRACE, 0); } public List switchBlockStatementGroup() { return getRuleContexts(SwitchBlockStatementGroupContext.class); } public SwitchBlockStatementGroupContext switchBlockStatementGroup(int i) { return getRuleContext(SwitchBlockStatementGroupContext.class,i); } public List switchLabel() { return getRuleContexts(SwitchLabelContext.class); } public SwitchLabelContext switchLabel(int i) { return getRuleContext(SwitchLabelContext.class,i); } public TerminalNode SYNCHRONIZED() { return getToken(JavaParser.SYNCHRONIZED, 0); } public TerminalNode RETURN() { return getToken(JavaParser.RETURN, 0); } public TerminalNode THROW() { return getToken(JavaParser.THROW, 0); } public TerminalNode BREAK() { return getToken(JavaParser.BREAK, 0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public TerminalNode CONTINUE() { return getToken(JavaParser.CONTINUE, 0); } public TerminalNode YIELD() { return getToken(JavaParser.YIELD, 0); } public SwitchExpressionContext switchExpression() { return getRuleContext(SwitchExpressionContext.class,0); } public StatementContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_statement; } } public final StatementContext statement() throws RecognitionException { StatementContext _localctx = new StatementContext(_ctx, getState()); enterRule(_localctx, 168, RULE_statement); int _la; try { int _alt; setState(1191); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,138,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { setState(1078); ((StatementContext)_localctx).blockLabel = block(); } break; case 2: enterOuterAlt(_localctx, 2); { setState(1079); match(ASSERT); setState(1080); expression(0); setState(1083); _errHandler.sync(this); _la = _input.LA(1); if (_la==COLON) { { setState(1081); match(COLON); setState(1082); expression(0); } } setState(1085); match(SEMI); } break; case 3: enterOuterAlt(_localctx, 3); { setState(1087); match(IF); setState(1088); parExpression(); setState(1089); statement(); setState(1092); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) { case 1: { setState(1090); match(ELSE); setState(1091); statement(); } break; } } break; case 4: enterOuterAlt(_localctx, 4); { setState(1094); match(FOR); setState(1095); match(LPAREN); setState(1096); forControl(); setState(1097); match(RPAREN); setState(1098); statement(); } break; case 5: enterOuterAlt(_localctx, 5); { setState(1100); match(WHILE); setState(1101); parExpression(); setState(1102); statement(); } break; case 6: enterOuterAlt(_localctx, 6); { setState(1104); match(DO); setState(1105); statement(); setState(1106); match(WHILE); setState(1107); parExpression(); setState(1108); match(SEMI); } break; case 7: enterOuterAlt(_localctx, 7); { setState(1110); match(TRY); setState(1111); block(); setState(1121); _errHandler.sync(this); switch (_input.LA(1)) { case CATCH: { setState(1113); _errHandler.sync(this); _la = _input.LA(1); do { { { setState(1112); catchClause(); } } setState(1115); _errHandler.sync(this); _la = _input.LA(1); } while ( _la==CATCH ); setState(1118); _errHandler.sync(this); _la = _input.LA(1); if (_la==FINALLY) { { setState(1117); finallyBlock(); } } } break; case FINALLY: { setState(1120); finallyBlock(); } break; default: throw new NoViableAltException(this); } } break; case 8: enterOuterAlt(_localctx, 8); { setState(1123); match(TRY); setState(1124); resourceSpecification(); setState(1125); block(); setState(1129); _errHandler.sync(this); _la = _input.LA(1); while (_la==CATCH) { { { setState(1126); catchClause(); } } setState(1131); _errHandler.sync(this); _la = _input.LA(1); } setState(1133); _errHandler.sync(this); _la = _input.LA(1); if (_la==FINALLY) { { setState(1132); finallyBlock(); } } } break; case 9: enterOuterAlt(_localctx, 9); { setState(1135); match(SWITCH); setState(1136); parExpression(); setState(1137); match(LBRACE); setState(1141); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,132,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(1138); switchBlockStatementGroup(); } } } setState(1143); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,132,_ctx); } setState(1147); _errHandler.sync(this); _la = _input.LA(1); while (_la==CASE || _la==DEFAULT) { { { setState(1144); switchLabel(); } } setState(1149); _errHandler.sync(this); _la = _input.LA(1); } setState(1150); match(RBRACE); } break; case 10: enterOuterAlt(_localctx, 10); { setState(1152); match(SYNCHRONIZED); setState(1153); parExpression(); setState(1154); block(); } break; case 11: enterOuterAlt(_localctx, 11); { setState(1156); match(RETURN); setState(1158); _errHandler.sync(this); _la = _input.LA(1); if (((((_la - 3)) & ~0x3f) == 0 && ((1L << (_la - 3)) & ((1L << (BOOLEAN - 3)) | (1L << (BYTE - 3)) | (1L << (CHAR - 3)) | (1L << (DOUBLE - 3)) | (1L << (FLOAT - 3)) | (1L << (INT - 3)) | (1L << (LONG - 3)) | (1L << (NEW - 3)) | (1L << (SHORT - 3)) | (1L << (SUPER - 3)) | (1L << (SWITCH - 3)) | (1L << (THIS - 3)) | (1L << (VOID - 3)) | (1L << (MODULE - 3)) | (1L << (OPEN - 3)) | (1L << (REQUIRES - 3)) | (1L << (EXPORTS - 3)) | (1L << (OPENS - 3)) | (1L << (TO - 3)) | (1L << (USES - 3)) | (1L << (PROVIDES - 3)) | (1L << (WITH - 3)) | (1L << (TRANSITIVE - 3)) | (1L << (VAR - 3)) | (1L << (YIELD - 3)) | (1L << (RECORD - 3)) | (1L << (SEALED - 3)) | (1L << (PERMITS - 3)))) != 0) || ((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & ((1L << (DECIMAL_LITERAL - 67)) | (1L << (HEX_LITERAL - 67)) | (1L << (OCT_LITERAL - 67)) | (1L << (BINARY_LITERAL - 67)) | (1L << (FLOAT_LITERAL - 67)) | (1L << (HEX_FLOAT_LITERAL - 67)) | (1L << (BOOL_LITERAL - 67)) | (1L << (CHAR_LITERAL - 67)) | (1L << (STRING_LITERAL - 67)) | (1L << (TEXT_BLOCK - 67)) | (1L << (NULL_LITERAL - 67)) | (1L << (LPAREN - 67)) | (1L << (LT - 67)) | (1L << (BANG - 67)) | (1L << (TILDE - 67)) | (1L << (INC - 67)) | (1L << (DEC - 67)) | (1L << (ADD - 67)) | (1L << (SUB - 67)) | (1L << (AT - 67)) | (1L << (IDENTIFIER - 67)))) != 0)) { { setState(1157); expression(0); } } setState(1160); match(SEMI); } break; case 12: enterOuterAlt(_localctx, 12); { setState(1161); match(THROW); setState(1162); expression(0); setState(1163); match(SEMI); } break; case 13: enterOuterAlt(_localctx, 13); { setState(1165); match(BREAK); setState(1167); _errHandler.sync(this); _la = _input.LA(1); if (((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & ((1L << (MODULE - 51)) | (1L << (OPEN - 51)) | (1L << (REQUIRES - 51)) | (1L << (EXPORTS - 51)) | (1L << (OPENS - 51)) | (1L << (TO - 51)) | (1L << (USES - 51)) | (1L << (PROVIDES - 51)) | (1L << (WITH - 51)) | (1L << (TRANSITIVE - 51)) | (1L << (VAR - 51)) | (1L << (YIELD - 51)) | (1L << (RECORD - 51)) | (1L << (SEALED - 51)) | (1L << (PERMITS - 51)))) != 0) || _la==IDENTIFIER) { { setState(1166); identifier(); } } setState(1169); match(SEMI); } break; case 14: enterOuterAlt(_localctx, 14); { setState(1170); match(CONTINUE); setState(1172); _errHandler.sync(this); _la = _input.LA(1); if (((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & ((1L << (MODULE - 51)) | (1L << (OPEN - 51)) | (1L << (REQUIRES - 51)) | (1L << (EXPORTS - 51)) | (1L << (OPENS - 51)) | (1L << (TO - 51)) | (1L << (USES - 51)) | (1L << (PROVIDES - 51)) | (1L << (WITH - 51)) | (1L << (TRANSITIVE - 51)) | (1L << (VAR - 51)) | (1L << (YIELD - 51)) | (1L << (RECORD - 51)) | (1L << (SEALED - 51)) | (1L << (PERMITS - 51)))) != 0) || _la==IDENTIFIER) { { setState(1171); identifier(); } } setState(1174); match(SEMI); } break; case 15: enterOuterAlt(_localctx, 15); { setState(1175); match(YIELD); setState(1176); expression(0); setState(1177); match(SEMI); } break; case 16: enterOuterAlt(_localctx, 16); { setState(1179); match(SEMI); } break; case 17: enterOuterAlt(_localctx, 17); { setState(1180); ((StatementContext)_localctx).statementExpression = expression(0); setState(1181); match(SEMI); } break; case 18: enterOuterAlt(_localctx, 18); { setState(1183); switchExpression(); setState(1185); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,137,_ctx) ) { case 1: { setState(1184); match(SEMI); } break; } } break; case 19: enterOuterAlt(_localctx, 19); { setState(1187); ((StatementContext)_localctx).identifierLabel = identifier(); setState(1188); match(COLON); setState(1189); statement(); } break; } } 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 TerminalNode CATCH() { return getToken(JavaParser.CATCH, 0); } public TerminalNode LPAREN() { return getToken(JavaParser.LPAREN, 0); } public CatchTypeContext catchType() { return getRuleContext(CatchTypeContext.class,0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public TerminalNode RPAREN() { return getToken(JavaParser.RPAREN, 0); } public BlockContext block() { return getRuleContext(BlockContext.class,0); } public List variableModifier() { return getRuleContexts(VariableModifierContext.class); } public VariableModifierContext variableModifier(int i) { return getRuleContext(VariableModifierContext.class,i); } public CatchClauseContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_catchClause; } } public final CatchClauseContext catchClause() throws RecognitionException { CatchClauseContext _localctx = new CatchClauseContext(_ctx, getState()); enterRule(_localctx, 170, RULE_catchClause); try { int _alt; enterOuterAlt(_localctx, 1); { setState(1193); match(CATCH); setState(1194); match(LPAREN); setState(1198); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,139,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(1195); variableModifier(); } } } setState(1200); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,139,_ctx); } setState(1201); catchType(); setState(1202); identifier(); setState(1203); match(RPAREN); setState(1204); block(); } } 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 List qualifiedName() { return getRuleContexts(QualifiedNameContext.class); } public QualifiedNameContext qualifiedName(int i) { return getRuleContext(QualifiedNameContext.class,i); } public List BITOR() { return getTokens(JavaParser.BITOR); } public TerminalNode BITOR(int i) { return getToken(JavaParser.BITOR, i); } public CatchTypeContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_catchType; } } public final CatchTypeContext catchType() throws RecognitionException { CatchTypeContext _localctx = new CatchTypeContext(_ctx, getState()); enterRule(_localctx, 172, RULE_catchType); int _la; try { enterOuterAlt(_localctx, 1); { setState(1206); qualifiedName(); setState(1211); _errHandler.sync(this); _la = _input.LA(1); while (_la==BITOR) { { { setState(1207); match(BITOR); setState(1208); qualifiedName(); } } setState(1213); _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 FinallyBlockContext extends ParserRuleContext { public TerminalNode FINALLY() { return getToken(JavaParser.FINALLY, 0); } public BlockContext block() { return getRuleContext(BlockContext.class,0); } public FinallyBlockContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_finallyBlock; } } public final FinallyBlockContext finallyBlock() throws RecognitionException { FinallyBlockContext _localctx = new FinallyBlockContext(_ctx, getState()); enterRule(_localctx, 174, RULE_finallyBlock); try { enterOuterAlt(_localctx, 1); { setState(1214); match(FINALLY); setState(1215); block(); } } 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 TerminalNode LPAREN() { return getToken(JavaParser.LPAREN, 0); } public ResourcesContext resources() { return getRuleContext(ResourcesContext.class,0); } public TerminalNode RPAREN() { return getToken(JavaParser.RPAREN, 0); } public TerminalNode SEMI() { return getToken(JavaParser.SEMI, 0); } public ResourceSpecificationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_resourceSpecification; } } public final ResourceSpecificationContext resourceSpecification() throws RecognitionException { ResourceSpecificationContext _localctx = new ResourceSpecificationContext(_ctx, getState()); enterRule(_localctx, 176, RULE_resourceSpecification); int _la; try { enterOuterAlt(_localctx, 1); { setState(1217); match(LPAREN); setState(1218); resources(); setState(1220); _errHandler.sync(this); _la = _input.LA(1); if (_la==SEMI) { { setState(1219); match(SEMI); } } setState(1222); match(RPAREN); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class ResourcesContext extends ParserRuleContext { public List resource() { return getRuleContexts(ResourceContext.class); } public ResourceContext resource(int i) { return getRuleContext(ResourceContext.class,i); } public List SEMI() { return getTokens(JavaParser.SEMI); } public TerminalNode SEMI(int i) { return getToken(JavaParser.SEMI, i); } public ResourcesContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_resources; } } public final ResourcesContext resources() throws RecognitionException { ResourcesContext _localctx = new ResourcesContext(_ctx, getState()); enterRule(_localctx, 178, RULE_resources); try { int _alt; enterOuterAlt(_localctx, 1); { setState(1224); resource(); setState(1229); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,142,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(1225); match(SEMI); setState(1226); resource(); } } } setState(1231); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,142,_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 TerminalNode ASSIGN() { return getToken(JavaParser.ASSIGN, 0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } public ClassOrInterfaceTypeContext classOrInterfaceType() { return getRuleContext(ClassOrInterfaceTypeContext.class,0); } public VariableDeclaratorIdContext variableDeclaratorId() { return getRuleContext(VariableDeclaratorIdContext.class,0); } public TerminalNode VAR() { return getToken(JavaParser.VAR, 0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public List variableModifier() { return getRuleContexts(VariableModifierContext.class); } public VariableModifierContext variableModifier(int i) { return getRuleContext(VariableModifierContext.class,i); } public QualifiedNameContext qualifiedName() { return getRuleContext(QualifiedNameContext.class,0); } public ResourceContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_resource; } } public final ResourceContext resource() throws RecognitionException { ResourceContext _localctx = new ResourceContext(_ctx, getState()); enterRule(_localctx, 180, RULE_resource); try { int _alt; setState(1249); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,145,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { setState(1235); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,143,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(1232); variableModifier(); } } } setState(1237); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,143,_ctx); } setState(1243); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,144,_ctx) ) { case 1: { setState(1238); classOrInterfaceType(); setState(1239); variableDeclaratorId(); } break; case 2: { setState(1241); match(VAR); setState(1242); identifier(); } break; } setState(1245); match(ASSIGN); setState(1246); expression(0); } break; case 2: enterOuterAlt(_localctx, 2); { setState(1248); qualifiedName(); } break; } } 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 List switchLabel() { return getRuleContexts(SwitchLabelContext.class); } public SwitchLabelContext switchLabel(int i) { return getRuleContext(SwitchLabelContext.class,i); } public List blockStatement() { return getRuleContexts(BlockStatementContext.class); } public BlockStatementContext blockStatement(int i) { return getRuleContext(BlockStatementContext.class,i); } public SwitchBlockStatementGroupContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_switchBlockStatementGroup; } } public final SwitchBlockStatementGroupContext switchBlockStatementGroup() throws RecognitionException { SwitchBlockStatementGroupContext _localctx = new SwitchBlockStatementGroupContext(_ctx, getState()); enterRule(_localctx, 182, RULE_switchBlockStatementGroup); int _la; try { enterOuterAlt(_localctx, 1); { setState(1252); _errHandler.sync(this); _la = _input.LA(1); do { { { setState(1251); switchLabel(); } } setState(1254); _errHandler.sync(this); _la = _input.LA(1); } while ( _la==CASE || _la==DEFAULT ); setState(1257); _errHandler.sync(this); _la = _input.LA(1); do { { { setState(1256); blockStatement(); } } setState(1259); _errHandler.sync(this); _la = _input.LA(1); } while ( ((((_la - 1)) & ~0x3f) == 0 && ((1L << (_la - 1)) & ((1L << (ABSTRACT - 1)) | (1L << (ASSERT - 1)) | (1L << (BOOLEAN - 1)) | (1L << (BREAK - 1)) | (1L << (BYTE - 1)) | (1L << (CHAR - 1)) | (1L << (CLASS - 1)) | (1L << (CONTINUE - 1)) | (1L << (DO - 1)) | (1L << (DOUBLE - 1)) | (1L << (FINAL - 1)) | (1L << (FLOAT - 1)) | (1L << (FOR - 1)) | (1L << (IF - 1)) | (1L << (INT - 1)) | (1L << (INTERFACE - 1)) | (1L << (LONG - 1)) | (1L << (NEW - 1)) | (1L << (PRIVATE - 1)) | (1L << (PROTECTED - 1)) | (1L << (PUBLIC - 1)) | (1L << (RETURN - 1)) | (1L << (SHORT - 1)) | (1L << (STATIC - 1)) | (1L << (STRICTFP - 1)) | (1L << (SUPER - 1)) | (1L << (SWITCH - 1)) | (1L << (SYNCHRONIZED - 1)) | (1L << (THIS - 1)) | (1L << (THROW - 1)) | (1L << (TRY - 1)) | (1L << (VOID - 1)) | (1L << (WHILE - 1)) | (1L << (MODULE - 1)) | (1L << (OPEN - 1)) | (1L << (REQUIRES - 1)) | (1L << (EXPORTS - 1)) | (1L << (OPENS - 1)) | (1L << (TO - 1)) | (1L << (USES - 1)) | (1L << (PROVIDES - 1)) | (1L << (WITH - 1)) | (1L << (TRANSITIVE - 1)) | (1L << (VAR - 1)) | (1L << (YIELD - 1)) | (1L << (RECORD - 1)) | (1L << (SEALED - 1)))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (PERMITS - 65)) | (1L << (NON_SEALED - 65)) | (1L << (DECIMAL_LITERAL - 65)) | (1L << (HEX_LITERAL - 65)) | (1L << (OCT_LITERAL - 65)) | (1L << (BINARY_LITERAL - 65)) | (1L << (FLOAT_LITERAL - 65)) | (1L << (HEX_FLOAT_LITERAL - 65)) | (1L << (BOOL_LITERAL - 65)) | (1L << (CHAR_LITERAL - 65)) | (1L << (STRING_LITERAL - 65)) | (1L << (TEXT_BLOCK - 65)) | (1L << (NULL_LITERAL - 65)) | (1L << (LPAREN - 65)) | (1L << (LBRACE - 65)) | (1L << (SEMI - 65)) | (1L << (LT - 65)) | (1L << (BANG - 65)) | (1L << (TILDE - 65)) | (1L << (INC - 65)) | (1L << (DEC - 65)) | (1L << (ADD - 65)) | (1L << (SUB - 65)) | (1L << (AT - 65)) | (1L << (IDENTIFIER - 65)))) != 0) ); } } 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 ExpressionContext constantExpression; public Token enumConstantName; public IdentifierContext varName; public TerminalNode CASE() { return getToken(JavaParser.CASE, 0); } public TerminalNode COLON() { return getToken(JavaParser.COLON, 0); } public TypeTypeContext typeType() { return getRuleContext(TypeTypeContext.class,0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } public TerminalNode IDENTIFIER() { return getToken(JavaParser.IDENTIFIER, 0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public TerminalNode DEFAULT() { return getToken(JavaParser.DEFAULT, 0); } public SwitchLabelContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_switchLabel; } } public final SwitchLabelContext switchLabel() throws RecognitionException { SwitchLabelContext _localctx = new SwitchLabelContext(_ctx, getState()); enterRule(_localctx, 184, RULE_switchLabel); try { setState(1272); _errHandler.sync(this); switch (_input.LA(1)) { case CASE: enterOuterAlt(_localctx, 1); { setState(1261); match(CASE); setState(1267); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) { case 1: { setState(1262); ((SwitchLabelContext)_localctx).constantExpression = expression(0); } break; case 2: { setState(1263); ((SwitchLabelContext)_localctx).enumConstantName = match(IDENTIFIER); } break; case 3: { setState(1264); typeType(); setState(1265); ((SwitchLabelContext)_localctx).varName = identifier(); } break; } setState(1269); match(COLON); } break; case DEFAULT: enterOuterAlt(_localctx, 2); { setState(1270); match(DEFAULT); setState(1271); match(COLON); } 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 ForControlContext extends ParserRuleContext { public ExpressionListContext forUpdate; public EnhancedForControlContext enhancedForControl() { return getRuleContext(EnhancedForControlContext.class,0); } public List SEMI() { return getTokens(JavaParser.SEMI); } public TerminalNode SEMI(int i) { return getToken(JavaParser.SEMI, i); } public ForInitContext forInit() { return getRuleContext(ForInitContext.class,0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } public ExpressionListContext expressionList() { return getRuleContext(ExpressionListContext.class,0); } public ForControlContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_forControl; } } public final ForControlContext forControl() throws RecognitionException { ForControlContext _localctx = new ForControlContext(_ctx, getState()); enterRule(_localctx, 186, RULE_forControl); int _la; try { setState(1286); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,153,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { setState(1274); enhancedForControl(); } break; case 2: enterOuterAlt(_localctx, 2); { setState(1276); _errHandler.sync(this); _la = _input.LA(1); if (((((_la - 3)) & ~0x3f) == 0 && ((1L << (_la - 3)) & ((1L << (BOOLEAN - 3)) | (1L << (BYTE - 3)) | (1L << (CHAR - 3)) | (1L << (DOUBLE - 3)) | (1L << (FINAL - 3)) | (1L << (FLOAT - 3)) | (1L << (INT - 3)) | (1L << (LONG - 3)) | (1L << (NEW - 3)) | (1L << (SHORT - 3)) | (1L << (SUPER - 3)) | (1L << (SWITCH - 3)) | (1L << (THIS - 3)) | (1L << (VOID - 3)) | (1L << (MODULE - 3)) | (1L << (OPEN - 3)) | (1L << (REQUIRES - 3)) | (1L << (EXPORTS - 3)) | (1L << (OPENS - 3)) | (1L << (TO - 3)) | (1L << (USES - 3)) | (1L << (PROVIDES - 3)) | (1L << (WITH - 3)) | (1L << (TRANSITIVE - 3)) | (1L << (VAR - 3)) | (1L << (YIELD - 3)) | (1L << (RECORD - 3)) | (1L << (SEALED - 3)) | (1L << (PERMITS - 3)))) != 0) || ((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & ((1L << (DECIMAL_LITERAL - 67)) | (1L << (HEX_LITERAL - 67)) | (1L << (OCT_LITERAL - 67)) | (1L << (BINARY_LITERAL - 67)) | (1L << (FLOAT_LITERAL - 67)) | (1L << (HEX_FLOAT_LITERAL - 67)) | (1L << (BOOL_LITERAL - 67)) | (1L << (CHAR_LITERAL - 67)) | (1L << (STRING_LITERAL - 67)) | (1L << (TEXT_BLOCK - 67)) | (1L << (NULL_LITERAL - 67)) | (1L << (LPAREN - 67)) | (1L << (LT - 67)) | (1L << (BANG - 67)) | (1L << (TILDE - 67)) | (1L << (INC - 67)) | (1L << (DEC - 67)) | (1L << (ADD - 67)) | (1L << (SUB - 67)) | (1L << (AT - 67)) | (1L << (IDENTIFIER - 67)))) != 0)) { { setState(1275); forInit(); } } setState(1278); match(SEMI); setState(1280); _errHandler.sync(this); _la = _input.LA(1); if (((((_la - 3)) & ~0x3f) == 0 && ((1L << (_la - 3)) & ((1L << (BOOLEAN - 3)) | (1L << (BYTE - 3)) | (1L << (CHAR - 3)) | (1L << (DOUBLE - 3)) | (1L << (FLOAT - 3)) | (1L << (INT - 3)) | (1L << (LONG - 3)) | (1L << (NEW - 3)) | (1L << (SHORT - 3)) | (1L << (SUPER - 3)) | (1L << (SWITCH - 3)) | (1L << (THIS - 3)) | (1L << (VOID - 3)) | (1L << (MODULE - 3)) | (1L << (OPEN - 3)) | (1L << (REQUIRES - 3)) | (1L << (EXPORTS - 3)) | (1L << (OPENS - 3)) | (1L << (TO - 3)) | (1L << (USES - 3)) | (1L << (PROVIDES - 3)) | (1L << (WITH - 3)) | (1L << (TRANSITIVE - 3)) | (1L << (VAR - 3)) | (1L << (YIELD - 3)) | (1L << (RECORD - 3)) | (1L << (SEALED - 3)) | (1L << (PERMITS - 3)))) != 0) || ((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & ((1L << (DECIMAL_LITERAL - 67)) | (1L << (HEX_LITERAL - 67)) | (1L << (OCT_LITERAL - 67)) | (1L << (BINARY_LITERAL - 67)) | (1L << (FLOAT_LITERAL - 67)) | (1L << (HEX_FLOAT_LITERAL - 67)) | (1L << (BOOL_LITERAL - 67)) | (1L << (CHAR_LITERAL - 67)) | (1L << (STRING_LITERAL - 67)) | (1L << (TEXT_BLOCK - 67)) | (1L << (NULL_LITERAL - 67)) | (1L << (LPAREN - 67)) | (1L << (LT - 67)) | (1L << (BANG - 67)) | (1L << (TILDE - 67)) | (1L << (INC - 67)) | (1L << (DEC - 67)) | (1L << (ADD - 67)) | (1L << (SUB - 67)) | (1L << (AT - 67)) | (1L << (IDENTIFIER - 67)))) != 0)) { { setState(1279); expression(0); } } setState(1282); match(SEMI); setState(1284); _errHandler.sync(this); _la = _input.LA(1); if (((((_la - 3)) & ~0x3f) == 0 && ((1L << (_la - 3)) & ((1L << (BOOLEAN - 3)) | (1L << (BYTE - 3)) | (1L << (CHAR - 3)) | (1L << (DOUBLE - 3)) | (1L << (FLOAT - 3)) | (1L << (INT - 3)) | (1L << (LONG - 3)) | (1L << (NEW - 3)) | (1L << (SHORT - 3)) | (1L << (SUPER - 3)) | (1L << (SWITCH - 3)) | (1L << (THIS - 3)) | (1L << (VOID - 3)) | (1L << (MODULE - 3)) | (1L << (OPEN - 3)) | (1L << (REQUIRES - 3)) | (1L << (EXPORTS - 3)) | (1L << (OPENS - 3)) | (1L << (TO - 3)) | (1L << (USES - 3)) | (1L << (PROVIDES - 3)) | (1L << (WITH - 3)) | (1L << (TRANSITIVE - 3)) | (1L << (VAR - 3)) | (1L << (YIELD - 3)) | (1L << (RECORD - 3)) | (1L << (SEALED - 3)) | (1L << (PERMITS - 3)))) != 0) || ((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & ((1L << (DECIMAL_LITERAL - 67)) | (1L << (HEX_LITERAL - 67)) | (1L << (OCT_LITERAL - 67)) | (1L << (BINARY_LITERAL - 67)) | (1L << (FLOAT_LITERAL - 67)) | (1L << (HEX_FLOAT_LITERAL - 67)) | (1L << (BOOL_LITERAL - 67)) | (1L << (CHAR_LITERAL - 67)) | (1L << (STRING_LITERAL - 67)) | (1L << (TEXT_BLOCK - 67)) | (1L << (NULL_LITERAL - 67)) | (1L << (LPAREN - 67)) | (1L << (LT - 67)) | (1L << (BANG - 67)) | (1L << (TILDE - 67)) | (1L << (INC - 67)) | (1L << (DEC - 67)) | (1L << (ADD - 67)) | (1L << (SUB - 67)) | (1L << (AT - 67)) | (1L << (IDENTIFIER - 67)))) != 0)) { { setState(1283); ((ForControlContext)_localctx).forUpdate = expressionList(); } } } break; } } 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 LocalVariableDeclarationContext localVariableDeclaration() { return getRuleContext(LocalVariableDeclarationContext.class,0); } public ExpressionListContext expressionList() { return getRuleContext(ExpressionListContext.class,0); } public ForInitContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_forInit; } } public final ForInitContext forInit() throws RecognitionException { ForInitContext _localctx = new ForInitContext(_ctx, getState()); enterRule(_localctx, 188, RULE_forInit); try { setState(1290); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,154,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { setState(1288); localVariableDeclaration(); } break; case 2: enterOuterAlt(_localctx, 2); { setState(1289); expressionList(); } break; } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class EnhancedForControlContext extends ParserRuleContext { public VariableDeclaratorIdContext variableDeclaratorId() { return getRuleContext(VariableDeclaratorIdContext.class,0); } public TerminalNode COLON() { return getToken(JavaParser.COLON, 0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } public TypeTypeContext typeType() { return getRuleContext(TypeTypeContext.class,0); } public TerminalNode VAR() { return getToken(JavaParser.VAR, 0); } public List variableModifier() { return getRuleContexts(VariableModifierContext.class); } public VariableModifierContext variableModifier(int i) { return getRuleContext(VariableModifierContext.class,i); } public EnhancedForControlContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_enhancedForControl; } } public final EnhancedForControlContext enhancedForControl() throws RecognitionException { EnhancedForControlContext _localctx = new EnhancedForControlContext(_ctx, getState()); enterRule(_localctx, 190, RULE_enhancedForControl); try { int _alt; enterOuterAlt(_localctx, 1); { setState(1295); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,155,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(1292); variableModifier(); } } } setState(1297); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,155,_ctx); } setState(1300); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,156,_ctx) ) { case 1: { setState(1298); typeType(); } break; case 2: { setState(1299); match(VAR); } break; } setState(1302); variableDeclaratorId(); setState(1303); match(COLON); setState(1304); expression(0); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class ParExpressionContext extends ParserRuleContext { public TerminalNode LPAREN() { return getToken(JavaParser.LPAREN, 0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } public TerminalNode RPAREN() { return getToken(JavaParser.RPAREN, 0); } public ParExpressionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_parExpression; } } public final ParExpressionContext parExpression() throws RecognitionException { ParExpressionContext _localctx = new ParExpressionContext(_ctx, getState()); enterRule(_localctx, 192, RULE_parExpression); try { enterOuterAlt(_localctx, 1); { setState(1306); match(LPAREN); setState(1307); expression(0); setState(1308); match(RPAREN); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class ExpressionListContext extends ParserRuleContext { public List expression() { return getRuleContexts(ExpressionContext.class); } public ExpressionContext expression(int i) { return getRuleContext(ExpressionContext.class,i); } public List COMMA() { return getTokens(JavaParser.COMMA); } public TerminalNode COMMA(int i) { return getToken(JavaParser.COMMA, i); } public ExpressionListContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_expressionList; } } public final ExpressionListContext expressionList() throws RecognitionException { ExpressionListContext _localctx = new ExpressionListContext(_ctx, getState()); enterRule(_localctx, 194, RULE_expressionList); int _la; try { enterOuterAlt(_localctx, 1); { setState(1310); expression(0); setState(1315); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { setState(1311); match(COMMA); setState(1312); expression(0); } } setState(1317); _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 MethodCallContext extends ParserRuleContext { public ArgumentsContext arguments() { return getRuleContext(ArgumentsContext.class,0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public TerminalNode THIS() { return getToken(JavaParser.THIS, 0); } public TerminalNode SUPER() { return getToken(JavaParser.SUPER, 0); } public MethodCallContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_methodCall; } } public final MethodCallContext methodCall() throws RecognitionException { MethodCallContext _localctx = new MethodCallContext(_ctx, getState()); enterRule(_localctx, 196, RULE_methodCall); try { enterOuterAlt(_localctx, 1); { setState(1321); _errHandler.sync(this); switch (_input.LA(1)) { case MODULE: case OPEN: case REQUIRES: case EXPORTS: case OPENS: case TO: case USES: case PROVIDES: case WITH: case TRANSITIVE: case VAR: case YIELD: case RECORD: case SEALED: case PERMITS: case IDENTIFIER: { setState(1318); identifier(); } break; case THIS: { setState(1319); match(THIS); } break; case SUPER: { setState(1320); match(SUPER); } break; default: throw new NoViableAltException(this); } setState(1323); arguments(); } } 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 Token prefix; public Token bop; public Token postfix; public PrimaryContext primary() { return getRuleContext(PrimaryContext.class,0); } public MethodCallContext methodCall() { return getRuleContext(MethodCallContext.class,0); } public List typeType() { return getRuleContexts(TypeTypeContext.class); } public TypeTypeContext typeType(int i) { return getRuleContext(TypeTypeContext.class,i); } public TerminalNode COLONCOLON() { return getToken(JavaParser.COLONCOLON, 0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public TerminalNode NEW() { return getToken(JavaParser.NEW, 0); } public TypeArgumentsContext typeArguments() { return getRuleContext(TypeArgumentsContext.class,0); } public ClassTypeContext classType() { return getRuleContext(ClassTypeContext.class,0); } public SwitchExpressionContext switchExpression() { return getRuleContext(SwitchExpressionContext.class,0); } public List expression() { return getRuleContexts(ExpressionContext.class); } public ExpressionContext expression(int i) { return getRuleContext(ExpressionContext.class,i); } public TerminalNode ADD() { return getToken(JavaParser.ADD, 0); } public TerminalNode SUB() { return getToken(JavaParser.SUB, 0); } public TerminalNode INC() { return getToken(JavaParser.INC, 0); } public TerminalNode DEC() { return getToken(JavaParser.DEC, 0); } public TerminalNode TILDE() { return getToken(JavaParser.TILDE, 0); } public TerminalNode BANG() { return getToken(JavaParser.BANG, 0); } public TerminalNode LPAREN() { return getToken(JavaParser.LPAREN, 0); } public TerminalNode RPAREN() { return getToken(JavaParser.RPAREN, 0); } public List annotation() { return getRuleContexts(AnnotationContext.class); } public AnnotationContext annotation(int i) { return getRuleContext(AnnotationContext.class,i); } public List BITAND() { return getTokens(JavaParser.BITAND); } public TerminalNode BITAND(int i) { return getToken(JavaParser.BITAND, i); } public CreatorContext creator() { return getRuleContext(CreatorContext.class,0); } public LambdaExpressionContext lambdaExpression() { return getRuleContext(LambdaExpressionContext.class,0); } public TerminalNode MUL() { return getToken(JavaParser.MUL, 0); } public TerminalNode DIV() { return getToken(JavaParser.DIV, 0); } public TerminalNode MOD() { return getToken(JavaParser.MOD, 0); } public List LT() { return getTokens(JavaParser.LT); } public TerminalNode LT(int i) { return getToken(JavaParser.LT, i); } public List GT() { return getTokens(JavaParser.GT); } public TerminalNode GT(int i) { return getToken(JavaParser.GT, i); } public TerminalNode LE() { return getToken(JavaParser.LE, 0); } public TerminalNode GE() { return getToken(JavaParser.GE, 0); } public TerminalNode EQUAL() { return getToken(JavaParser.EQUAL, 0); } public TerminalNode NOTEQUAL() { return getToken(JavaParser.NOTEQUAL, 0); } public TerminalNode CARET() { return getToken(JavaParser.CARET, 0); } public TerminalNode BITOR() { return getToken(JavaParser.BITOR, 0); } public TerminalNode AND() { return getToken(JavaParser.AND, 0); } public TerminalNode OR() { return getToken(JavaParser.OR, 0); } public TerminalNode COLON() { return getToken(JavaParser.COLON, 0); } public TerminalNode QUESTION() { return getToken(JavaParser.QUESTION, 0); } public TerminalNode ASSIGN() { return getToken(JavaParser.ASSIGN, 0); } public TerminalNode ADD_ASSIGN() { return getToken(JavaParser.ADD_ASSIGN, 0); } public TerminalNode SUB_ASSIGN() { return getToken(JavaParser.SUB_ASSIGN, 0); } public TerminalNode MUL_ASSIGN() { return getToken(JavaParser.MUL_ASSIGN, 0); } public TerminalNode DIV_ASSIGN() { return getToken(JavaParser.DIV_ASSIGN, 0); } public TerminalNode AND_ASSIGN() { return getToken(JavaParser.AND_ASSIGN, 0); } public TerminalNode OR_ASSIGN() { return getToken(JavaParser.OR_ASSIGN, 0); } public TerminalNode XOR_ASSIGN() { return getToken(JavaParser.XOR_ASSIGN, 0); } public TerminalNode RSHIFT_ASSIGN() { return getToken(JavaParser.RSHIFT_ASSIGN, 0); } public TerminalNode URSHIFT_ASSIGN() { return getToken(JavaParser.URSHIFT_ASSIGN, 0); } public TerminalNode LSHIFT_ASSIGN() { return getToken(JavaParser.LSHIFT_ASSIGN, 0); } public TerminalNode MOD_ASSIGN() { return getToken(JavaParser.MOD_ASSIGN, 0); } public TerminalNode LBRACK() { return getToken(JavaParser.LBRACK, 0); } public TerminalNode RBRACK() { return getToken(JavaParser.RBRACK, 0); } public TerminalNode DOT() { return getToken(JavaParser.DOT, 0); } public TerminalNode THIS() { return getToken(JavaParser.THIS, 0); } public InnerCreatorContext innerCreator() { return getRuleContext(InnerCreatorContext.class,0); } public TerminalNode SUPER() { return getToken(JavaParser.SUPER, 0); } public SuperSuffixContext superSuffix() { return getRuleContext(SuperSuffixContext.class,0); } public ExplicitGenericInvocationContext explicitGenericInvocation() { return getRuleContext(ExplicitGenericInvocationContext.class,0); } public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() { return getRuleContext(NonWildcardTypeArgumentsContext.class,0); } public TerminalNode INSTANCEOF() { return getToken(JavaParser.INSTANCEOF, 0); } public PatternContext pattern() { return getRuleContext(PatternContext.class,0); } public ExpressionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_expression; } } public final ExpressionContext expression() throws RecognitionException { return expression(0); } private ExpressionContext expression(int _p) throws RecognitionException { ParserRuleContext _parentctx = _ctx; int _parentState = getState(); ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState); ExpressionContext _prevctx = _localctx; int _startState = 198; enterRecursionRule(_localctx, 198, RULE_expression, _p); int _la; try { int _alt; enterOuterAlt(_localctx, 1); { setState(1368); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,164,_ctx) ) { case 1: { setState(1326); primary(); } break; case 2: { setState(1327); methodCall(); } break; case 3: { setState(1328); typeType(); setState(1329); match(COLONCOLON); setState(1335); _errHandler.sync(this); switch (_input.LA(1)) { case MODULE: case OPEN: case REQUIRES: case EXPORTS: case OPENS: case TO: case USES: case PROVIDES: case WITH: case TRANSITIVE: case VAR: case YIELD: case RECORD: case SEALED: case PERMITS: case LT: case IDENTIFIER: { setState(1331); _errHandler.sync(this); _la = _input.LA(1); if (_la==LT) { { setState(1330); typeArguments(); } } setState(1333); identifier(); } break; case NEW: { setState(1334); match(NEW); } break; default: throw new NoViableAltException(this); } } break; case 4: { setState(1337); classType(); setState(1338); match(COLONCOLON); setState(1340); _errHandler.sync(this); _la = _input.LA(1); if (_la==LT) { { setState(1339); typeArguments(); } } setState(1342); match(NEW); } break; case 5: { setState(1344); switchExpression(); } break; case 6: { setState(1345); ((ExpressionContext)_localctx).prefix = _input.LT(1); _la = _input.LA(1); if ( !(((((_la - 90)) & ~0x3f) == 0 && ((1L << (_la - 90)) & ((1L << (BANG - 90)) | (1L << (TILDE - 90)) | (1L << (INC - 90)) | (1L << (DEC - 90)) | (1L << (ADD - 90)) | (1L << (SUB - 90)))) != 0)) ) { ((ExpressionContext)_localctx).prefix = (Token)_errHandler.recoverInline(this); } else { if ( _input.LA(1)==Token.EOF ) matchedEOF = true; _errHandler.reportMatch(this); consume(); } setState(1346); expression(17); } break; case 7: { setState(1347); match(LPAREN); setState(1351); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,162,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(1348); annotation(); } } } setState(1353); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,162,_ctx); } setState(1354); typeType(); setState(1359); _errHandler.sync(this); _la = _input.LA(1); while (_la==BITAND) { { { setState(1355); match(BITAND); setState(1356); typeType(); } } setState(1361); _errHandler.sync(this); _la = _input.LA(1); } setState(1362); match(RPAREN); setState(1363); expression(16); } break; case 8: { setState(1365); match(NEW); setState(1366); creator(); } break; case 9: { setState(1367); lambdaExpression(); } break; } _ctx.stop = _input.LT(-1); setState(1453); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,171,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { if ( _parseListeners!=null ) triggerExitRuleEvent(); _prevctx = _localctx; { setState(1451); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,170,_ctx) ) { case 1: { _localctx = new ExpressionContext(_parentctx, _parentState); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(1370); if (!(precpred(_ctx, 14))) throw new FailedPredicateException(this, "precpred(_ctx, 14)"); setState(1371); ((ExpressionContext)_localctx).bop = _input.LT(1); _la = _input.LA(1); if ( !(((((_la - 104)) & ~0x3f) == 0 && ((1L << (_la - 104)) & ((1L << (MUL - 104)) | (1L << (DIV - 104)) | (1L << (MOD - 104)))) != 0)) ) { ((ExpressionContext)_localctx).bop = (Token)_errHandler.recoverInline(this); } else { if ( _input.LA(1)==Token.EOF ) matchedEOF = true; _errHandler.reportMatch(this); consume(); } setState(1372); expression(15); } break; case 2: { _localctx = new ExpressionContext(_parentctx, _parentState); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(1373); if (!(precpred(_ctx, 13))) throw new FailedPredicateException(this, "precpred(_ctx, 13)"); setState(1374); ((ExpressionContext)_localctx).bop = _input.LT(1); _la = _input.LA(1); if ( !(_la==ADD || _la==SUB) ) { ((ExpressionContext)_localctx).bop = (Token)_errHandler.recoverInline(this); } else { if ( _input.LA(1)==Token.EOF ) matchedEOF = true; _errHandler.reportMatch(this); consume(); } setState(1375); expression(14); } break; case 3: { _localctx = new ExpressionContext(_parentctx, _parentState); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(1376); if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)"); setState(1384); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,165,_ctx) ) { case 1: { setState(1377); match(LT); setState(1378); match(LT); } break; case 2: { setState(1379); match(GT); setState(1380); match(GT); setState(1381); match(GT); } break; case 3: { setState(1382); match(GT); setState(1383); match(GT); } break; } setState(1386); expression(13); } break; case 4: { _localctx = new ExpressionContext(_parentctx, _parentState); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(1387); if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)"); setState(1388); ((ExpressionContext)_localctx).bop = _input.LT(1); _la = _input.LA(1); if ( !(((((_la - 88)) & ~0x3f) == 0 && ((1L << (_la - 88)) & ((1L << (GT - 88)) | (1L << (LT - 88)) | (1L << (LE - 88)) | (1L << (GE - 88)))) != 0)) ) { ((ExpressionContext)_localctx).bop = (Token)_errHandler.recoverInline(this); } else { if ( _input.LA(1)==Token.EOF ) matchedEOF = true; _errHandler.reportMatch(this); consume(); } setState(1389); expression(12); } break; case 5: { _localctx = new ExpressionContext(_parentctx, _parentState); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(1390); if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)"); setState(1391); ((ExpressionContext)_localctx).bop = _input.LT(1); _la = _input.LA(1); if ( !(_la==EQUAL || _la==NOTEQUAL) ) { ((ExpressionContext)_localctx).bop = (Token)_errHandler.recoverInline(this); } else { if ( _input.LA(1)==Token.EOF ) matchedEOF = true; _errHandler.reportMatch(this); consume(); } setState(1392); expression(10); } break; case 6: { _localctx = new ExpressionContext(_parentctx, _parentState); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(1393); if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)"); setState(1394); ((ExpressionContext)_localctx).bop = match(BITAND); setState(1395); expression(9); } break; case 7: { _localctx = new ExpressionContext(_parentctx, _parentState); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(1396); if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)"); setState(1397); ((ExpressionContext)_localctx).bop = match(CARET); setState(1398); expression(8); } break; case 8: { _localctx = new ExpressionContext(_parentctx, _parentState); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(1399); if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)"); setState(1400); ((ExpressionContext)_localctx).bop = match(BITOR); setState(1401); expression(7); } break; case 9: { _localctx = new ExpressionContext(_parentctx, _parentState); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(1402); if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)"); setState(1403); ((ExpressionContext)_localctx).bop = match(AND); setState(1404); expression(6); } break; case 10: { _localctx = new ExpressionContext(_parentctx, _parentState); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(1405); if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)"); setState(1406); ((ExpressionContext)_localctx).bop = match(OR); setState(1407); expression(5); } break; case 11: { _localctx = new ExpressionContext(_parentctx, _parentState); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(1408); if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)"); setState(1409); ((ExpressionContext)_localctx).bop = match(QUESTION); setState(1410); expression(0); setState(1411); match(COLON); setState(1412); expression(3); } break; case 12: { _localctx = new ExpressionContext(_parentctx, _parentState); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(1414); if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); setState(1415); ((ExpressionContext)_localctx).bop = _input.LT(1); _la = _input.LA(1); if ( !(((((_la - 87)) & ~0x3f) == 0 && ((1L << (_la - 87)) & ((1L << (ASSIGN - 87)) | (1L << (ADD_ASSIGN - 87)) | (1L << (SUB_ASSIGN - 87)) | (1L << (MUL_ASSIGN - 87)) | (1L << (DIV_ASSIGN - 87)) | (1L << (AND_ASSIGN - 87)) | (1L << (OR_ASSIGN - 87)) | (1L << (XOR_ASSIGN - 87)) | (1L << (MOD_ASSIGN - 87)) | (1L << (LSHIFT_ASSIGN - 87)) | (1L << (RSHIFT_ASSIGN - 87)) | (1L << (URSHIFT_ASSIGN - 87)))) != 0)) ) { ((ExpressionContext)_localctx).bop = (Token)_errHandler.recoverInline(this); } else { if ( _input.LA(1)==Token.EOF ) matchedEOF = true; _errHandler.reportMatch(this); consume(); } setState(1416); expression(2); } break; case 13: { _localctx = new ExpressionContext(_parentctx, _parentState); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(1417); if (!(precpred(_ctx, 25))) throw new FailedPredicateException(this, "precpred(_ctx, 25)"); setState(1418); match(LBRACK); setState(1419); expression(0); setState(1420); match(RBRACK); } break; case 14: { _localctx = new ExpressionContext(_parentctx, _parentState); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(1422); if (!(precpred(_ctx, 24))) throw new FailedPredicateException(this, "precpred(_ctx, 24)"); setState(1423); ((ExpressionContext)_localctx).bop = match(DOT); setState(1435); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,167,_ctx) ) { case 1: { setState(1424); identifier(); } break; case 2: { setState(1425); methodCall(); } break; case 3: { setState(1426); match(THIS); } break; case 4: { setState(1427); match(NEW); setState(1429); _errHandler.sync(this); _la = _input.LA(1); if (_la==LT) { { setState(1428); nonWildcardTypeArguments(); } } setState(1431); innerCreator(); } break; case 5: { setState(1432); match(SUPER); setState(1433); superSuffix(); } break; case 6: { setState(1434); explicitGenericInvocation(); } break; } } break; case 15: { _localctx = new ExpressionContext(_parentctx, _parentState); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(1437); if (!(precpred(_ctx, 22))) throw new FailedPredicateException(this, "precpred(_ctx, 22)"); setState(1438); match(COLONCOLON); setState(1440); _errHandler.sync(this); _la = _input.LA(1); if (_la==LT) { { setState(1439); typeArguments(); } } setState(1442); identifier(); } break; case 16: { _localctx = new ExpressionContext(_parentctx, _parentState); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(1443); if (!(precpred(_ctx, 18))) throw new FailedPredicateException(this, "precpred(_ctx, 18)"); setState(1444); ((ExpressionContext)_localctx).postfix = _input.LT(1); _la = _input.LA(1); if ( !(_la==INC || _la==DEC) ) { ((ExpressionContext)_localctx).postfix = (Token)_errHandler.recoverInline(this); } else { if ( _input.LA(1)==Token.EOF ) matchedEOF = true; _errHandler.reportMatch(this); consume(); } } break; case 17: { _localctx = new ExpressionContext(_parentctx, _parentState); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(1445); if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)"); setState(1446); ((ExpressionContext)_localctx).bop = match(INSTANCEOF); setState(1449); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,169,_ctx) ) { case 1: { setState(1447); typeType(); } break; case 2: { setState(1448); pattern(); } break; } } break; } } } setState(1455); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,171,_ctx); } } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { unrollRecursionContexts(_parentctx); } return _localctx; } public static class PatternContext extends ParserRuleContext { public TypeTypeContext typeType() { return getRuleContext(TypeTypeContext.class,0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public List variableModifier() { return getRuleContexts(VariableModifierContext.class); } public VariableModifierContext variableModifier(int i) { return getRuleContext(VariableModifierContext.class,i); } public List annotation() { return getRuleContexts(AnnotationContext.class); } public AnnotationContext annotation(int i) { return getRuleContext(AnnotationContext.class,i); } public PatternContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_pattern; } } public final PatternContext pattern() throws RecognitionException { PatternContext _localctx = new PatternContext(_ctx, getState()); enterRule(_localctx, 200, RULE_pattern); try { int _alt; enterOuterAlt(_localctx, 1); { setState(1459); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,172,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(1456); variableModifier(); } } } setState(1461); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,172,_ctx); } setState(1462); typeType(); setState(1466); _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(1463); annotation(); } } } setState(1468); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,173,_ctx); } setState(1469); identifier(); } } 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 TerminalNode ARROW() { return getToken(JavaParser.ARROW, 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; } } public final LambdaExpressionContext lambdaExpression() throws RecognitionException { LambdaExpressionContext _localctx = new LambdaExpressionContext(_ctx, getState()); enterRule(_localctx, 202, RULE_lambdaExpression); try { enterOuterAlt(_localctx, 1); { setState(1471); lambdaParameters(); setState(1472); match(ARROW); setState(1473); 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 List identifier() { return getRuleContexts(IdentifierContext.class); } public IdentifierContext identifier(int i) { return getRuleContext(IdentifierContext.class,i); } public TerminalNode LPAREN() { return getToken(JavaParser.LPAREN, 0); } public TerminalNode RPAREN() { return getToken(JavaParser.RPAREN, 0); } public FormalParameterListContext formalParameterList() { return getRuleContext(FormalParameterListContext.class,0); } public List COMMA() { return getTokens(JavaParser.COMMA); } public TerminalNode COMMA(int i) { return getToken(JavaParser.COMMA, i); } public LambdaLVTIListContext lambdaLVTIList() { return getRuleContext(LambdaLVTIListContext.class,0); } public LambdaParametersContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_lambdaParameters; } } public final LambdaParametersContext lambdaParameters() throws RecognitionException { LambdaParametersContext _localctx = new LambdaParametersContext(_ctx, getState()); enterRule(_localctx, 204, RULE_lambdaParameters); int _la; try { setState(1497); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,177,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { setState(1475); identifier(); } break; case 2: enterOuterAlt(_localctx, 2); { setState(1476); match(LPAREN); setState(1478); _errHandler.sync(this); _la = _input.LA(1); if (((((_la - 3)) & ~0x3f) == 0 && ((1L << (_la - 3)) & ((1L << (BOOLEAN - 3)) | (1L << (BYTE - 3)) | (1L << (CHAR - 3)) | (1L << (DOUBLE - 3)) | (1L << (FINAL - 3)) | (1L << (FLOAT - 3)) | (1L << (INT - 3)) | (1L << (LONG - 3)) | (1L << (SHORT - 3)) | (1L << (MODULE - 3)) | (1L << (OPEN - 3)) | (1L << (REQUIRES - 3)) | (1L << (EXPORTS - 3)) | (1L << (OPENS - 3)) | (1L << (TO - 3)) | (1L << (USES - 3)) | (1L << (PROVIDES - 3)) | (1L << (WITH - 3)) | (1L << (TRANSITIVE - 3)) | (1L << (VAR - 3)) | (1L << (YIELD - 3)) | (1L << (RECORD - 3)) | (1L << (SEALED - 3)) | (1L << (PERMITS - 3)))) != 0) || _la==AT || _la==IDENTIFIER) { { setState(1477); formalParameterList(); } } setState(1480); match(RPAREN); } break; case 3: enterOuterAlt(_localctx, 3); { setState(1481); match(LPAREN); setState(1482); identifier(); setState(1487); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { setState(1483); match(COMMA); setState(1484); identifier(); } } setState(1489); _errHandler.sync(this); _la = _input.LA(1); } setState(1490); match(RPAREN); } break; case 4: enterOuterAlt(_localctx, 4); { setState(1492); match(LPAREN); setState(1494); _errHandler.sync(this); _la = _input.LA(1); if (((((_la - 18)) & ~0x3f) == 0 && ((1L << (_la - 18)) & ((1L << (FINAL - 18)) | (1L << (MODULE - 18)) | (1L << (OPEN - 18)) | (1L << (REQUIRES - 18)) | (1L << (EXPORTS - 18)) | (1L << (OPENS - 18)) | (1L << (TO - 18)) | (1L << (USES - 18)) | (1L << (PROVIDES - 18)) | (1L << (WITH - 18)) | (1L << (TRANSITIVE - 18)) | (1L << (VAR - 18)) | (1L << (YIELD - 18)) | (1L << (RECORD - 18)) | (1L << (SEALED - 18)) | (1L << (PERMITS - 18)))) != 0) || _la==AT || _la==IDENTIFIER) { { setState(1493); lambdaLVTIList(); } } setState(1496); match(RPAREN); } break; } } 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; } } public final LambdaBodyContext lambdaBody() throws RecognitionException { LambdaBodyContext _localctx = new LambdaBodyContext(_ctx, getState()); enterRule(_localctx, 206, RULE_lambdaBody); try { setState(1501); _errHandler.sync(this); switch (_input.LA(1)) { case BOOLEAN: case BYTE: case CHAR: case DOUBLE: case FLOAT: case INT: case LONG: case NEW: case SHORT: case SUPER: case SWITCH: case THIS: case VOID: case MODULE: case OPEN: case REQUIRES: case EXPORTS: case OPENS: case TO: case USES: case PROVIDES: case WITH: case TRANSITIVE: case VAR: case YIELD: case RECORD: case SEALED: case PERMITS: case DECIMAL_LITERAL: case HEX_LITERAL: case OCT_LITERAL: case BINARY_LITERAL: case FLOAT_LITERAL: case HEX_FLOAT_LITERAL: case BOOL_LITERAL: case CHAR_LITERAL: case STRING_LITERAL: case TEXT_BLOCK: case NULL_LITERAL: case LPAREN: case LT: case BANG: case TILDE: case INC: case DEC: case ADD: case SUB: case AT: case IDENTIFIER: enterOuterAlt(_localctx, 1); { setState(1499); expression(0); } break; case LBRACE: enterOuterAlt(_localctx, 2); { setState(1500); 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 PrimaryContext extends ParserRuleContext { public TerminalNode LPAREN() { return getToken(JavaParser.LPAREN, 0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } public TerminalNode RPAREN() { return getToken(JavaParser.RPAREN, 0); } public TerminalNode THIS() { return getToken(JavaParser.THIS, 0); } public TerminalNode SUPER() { return getToken(JavaParser.SUPER, 0); } public LiteralContext literal() { return getRuleContext(LiteralContext.class,0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public TypeTypeOrVoidContext typeTypeOrVoid() { return getRuleContext(TypeTypeOrVoidContext.class,0); } public TerminalNode DOT() { return getToken(JavaParser.DOT, 0); } public TerminalNode CLASS() { return getToken(JavaParser.CLASS, 0); } public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() { return getRuleContext(NonWildcardTypeArgumentsContext.class,0); } public ExplicitGenericInvocationSuffixContext explicitGenericInvocationSuffix() { return getRuleContext(ExplicitGenericInvocationSuffixContext.class,0); } public ArgumentsContext arguments() { return getRuleContext(ArgumentsContext.class,0); } public PrimaryContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_primary; } } public final PrimaryContext primary() throws RecognitionException { PrimaryContext _localctx = new PrimaryContext(_ctx, getState()); enterRule(_localctx, 208, RULE_primary); try { setState(1521); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,180,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { setState(1503); match(LPAREN); setState(1504); expression(0); setState(1505); match(RPAREN); } break; case 2: enterOuterAlt(_localctx, 2); { setState(1507); match(THIS); } break; case 3: enterOuterAlt(_localctx, 3); { setState(1508); match(SUPER); } break; case 4: enterOuterAlt(_localctx, 4); { setState(1509); literal(); } break; case 5: enterOuterAlt(_localctx, 5); { setState(1510); identifier(); } break; case 6: enterOuterAlt(_localctx, 6); { setState(1511); typeTypeOrVoid(); setState(1512); match(DOT); setState(1513); match(CLASS); } break; case 7: enterOuterAlt(_localctx, 7); { setState(1515); nonWildcardTypeArguments(); setState(1519); _errHandler.sync(this); switch (_input.LA(1)) { case SUPER: case MODULE: case OPEN: case REQUIRES: case EXPORTS: case OPENS: case TO: case USES: case PROVIDES: case WITH: case TRANSITIVE: case VAR: case YIELD: case RECORD: case SEALED: case PERMITS: case IDENTIFIER: { setState(1516); explicitGenericInvocationSuffix(); } break; case THIS: { setState(1517); match(THIS); setState(1518); arguments(); } break; default: throw new NoViableAltException(this); } } break; } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class SwitchExpressionContext extends ParserRuleContext { public TerminalNode SWITCH() { return getToken(JavaParser.SWITCH, 0); } public ParExpressionContext parExpression() { return getRuleContext(ParExpressionContext.class,0); } public TerminalNode LBRACE() { return getToken(JavaParser.LBRACE, 0); } public TerminalNode RBRACE() { return getToken(JavaParser.RBRACE, 0); } public List switchLabeledRule() { return getRuleContexts(SwitchLabeledRuleContext.class); } public SwitchLabeledRuleContext switchLabeledRule(int i) { return getRuleContext(SwitchLabeledRuleContext.class,i); } public SwitchExpressionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_switchExpression; } } public final SwitchExpressionContext switchExpression() throws RecognitionException { SwitchExpressionContext _localctx = new SwitchExpressionContext(_ctx, getState()); enterRule(_localctx, 210, RULE_switchExpression); int _la; try { enterOuterAlt(_localctx, 1); { setState(1523); match(SWITCH); setState(1524); parExpression(); setState(1525); match(LBRACE); setState(1529); _errHandler.sync(this); _la = _input.LA(1); while (_la==CASE || _la==DEFAULT) { { { setState(1526); switchLabeledRule(); } } setState(1531); _errHandler.sync(this); _la = _input.LA(1); } setState(1532); match(RBRACE); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class SwitchLabeledRuleContext extends ParserRuleContext { public TerminalNode CASE() { return getToken(JavaParser.CASE, 0); } public SwitchRuleOutcomeContext switchRuleOutcome() { return getRuleContext(SwitchRuleOutcomeContext.class,0); } public TerminalNode ARROW() { return getToken(JavaParser.ARROW, 0); } public TerminalNode COLON() { return getToken(JavaParser.COLON, 0); } public ExpressionListContext expressionList() { return getRuleContext(ExpressionListContext.class,0); } public TerminalNode NULL_LITERAL() { return getToken(JavaParser.NULL_LITERAL, 0); } public GuardedPatternContext guardedPattern() { return getRuleContext(GuardedPatternContext.class,0); } public TerminalNode DEFAULT() { return getToken(JavaParser.DEFAULT, 0); } public SwitchLabeledRuleContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_switchLabeledRule; } } public final SwitchLabeledRuleContext switchLabeledRule() throws RecognitionException { SwitchLabeledRuleContext _localctx = new SwitchLabeledRuleContext(_ctx, getState()); enterRule(_localctx, 212, RULE_switchLabeledRule); int _la; try { setState(1545); _errHandler.sync(this); switch (_input.LA(1)) { case CASE: enterOuterAlt(_localctx, 1); { setState(1534); match(CASE); setState(1538); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,182,_ctx) ) { case 1: { setState(1535); expressionList(); } break; case 2: { setState(1536); match(NULL_LITERAL); } break; case 3: { setState(1537); guardedPattern(0); } break; } setState(1540); _la = _input.LA(1); if ( !(_la==COLON || _la==ARROW) ) { _errHandler.recoverInline(this); } else { if ( _input.LA(1)==Token.EOF ) matchedEOF = true; _errHandler.reportMatch(this); consume(); } setState(1541); switchRuleOutcome(); } break; case DEFAULT: enterOuterAlt(_localctx, 2); { setState(1542); match(DEFAULT); setState(1543); _la = _input.LA(1); if ( !(_la==COLON || _la==ARROW) ) { _errHandler.recoverInline(this); } else { if ( _input.LA(1)==Token.EOF ) matchedEOF = true; _errHandler.reportMatch(this); consume(); } setState(1544); switchRuleOutcome(); } 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 GuardedPatternContext extends ParserRuleContext { public TerminalNode LPAREN() { return getToken(JavaParser.LPAREN, 0); } public GuardedPatternContext guardedPattern() { return getRuleContext(GuardedPatternContext.class,0); } public TerminalNode RPAREN() { return getToken(JavaParser.RPAREN, 0); } public TypeTypeContext typeType() { return getRuleContext(TypeTypeContext.class,0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public List variableModifier() { return getRuleContexts(VariableModifierContext.class); } public VariableModifierContext variableModifier(int i) { return getRuleContext(VariableModifierContext.class,i); } public List annotation() { return getRuleContexts(AnnotationContext.class); } public AnnotationContext annotation(int i) { return getRuleContext(AnnotationContext.class,i); } public List AND() { return getTokens(JavaParser.AND); } public TerminalNode AND(int i) { return getToken(JavaParser.AND, i); } public List expression() { return getRuleContexts(ExpressionContext.class); } public ExpressionContext expression(int i) { return getRuleContext(ExpressionContext.class,i); } public GuardedPatternContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_guardedPattern; } } public final GuardedPatternContext guardedPattern() throws RecognitionException { return guardedPattern(0); } private GuardedPatternContext guardedPattern(int _p) throws RecognitionException { ParserRuleContext _parentctx = _ctx; int _parentState = getState(); GuardedPatternContext _localctx = new GuardedPatternContext(_ctx, _parentState); GuardedPatternContext _prevctx = _localctx; int _startState = 214; enterRecursionRule(_localctx, 214, RULE_guardedPattern, _p); try { int _alt; enterOuterAlt(_localctx, 1); { setState(1573); _errHandler.sync(this); switch (_input.LA(1)) { case LPAREN: { setState(1548); match(LPAREN); setState(1549); guardedPattern(0); setState(1550); match(RPAREN); } break; case BOOLEAN: case BYTE: case CHAR: case DOUBLE: case FINAL: case FLOAT: case INT: case LONG: case SHORT: case MODULE: case OPEN: case REQUIRES: case EXPORTS: case OPENS: case TO: case USES: case PROVIDES: case WITH: case TRANSITIVE: case VAR: case YIELD: case RECORD: case SEALED: case PERMITS: case AT: case IDENTIFIER: { setState(1555); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,184,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(1552); variableModifier(); } } } setState(1557); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,184,_ctx); } setState(1558); typeType(); setState(1562); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,185,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(1559); annotation(); } } } setState(1564); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,185,_ctx); } setState(1565); identifier(); setState(1570); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,186,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(1566); match(AND); setState(1567); expression(0); } } } setState(1572); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,186,_ctx); } } break; default: throw new NoViableAltException(this); } _ctx.stop = _input.LT(-1); setState(1580); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,188,_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 GuardedPatternContext(_parentctx, _parentState); pushNewRecursionContext(_localctx, _startState, RULE_guardedPattern); setState(1575); if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); setState(1576); match(AND); setState(1577); expression(0); } } } setState(1582); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,188,_ctx); } } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { unrollRecursionContexts(_parentctx); } return _localctx; } public static class SwitchRuleOutcomeContext extends ParserRuleContext { public BlockContext block() { return getRuleContext(BlockContext.class,0); } public List blockStatement() { return getRuleContexts(BlockStatementContext.class); } public BlockStatementContext blockStatement(int i) { return getRuleContext(BlockStatementContext.class,i); } public SwitchRuleOutcomeContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_switchRuleOutcome; } } public final SwitchRuleOutcomeContext switchRuleOutcome() throws RecognitionException { SwitchRuleOutcomeContext _localctx = new SwitchRuleOutcomeContext(_ctx, getState()); enterRule(_localctx, 216, RULE_switchRuleOutcome); int _la; try { setState(1590); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,190,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { setState(1583); block(); } break; case 2: enterOuterAlt(_localctx, 2); { setState(1587); _errHandler.sync(this); _la = _input.LA(1); while (((((_la - 1)) & ~0x3f) == 0 && ((1L << (_la - 1)) & ((1L << (ABSTRACT - 1)) | (1L << (ASSERT - 1)) | (1L << (BOOLEAN - 1)) | (1L << (BREAK - 1)) | (1L << (BYTE - 1)) | (1L << (CHAR - 1)) | (1L << (CLASS - 1)) | (1L << (CONTINUE - 1)) | (1L << (DO - 1)) | (1L << (DOUBLE - 1)) | (1L << (FINAL - 1)) | (1L << (FLOAT - 1)) | (1L << (FOR - 1)) | (1L << (IF - 1)) | (1L << (INT - 1)) | (1L << (INTERFACE - 1)) | (1L << (LONG - 1)) | (1L << (NEW - 1)) | (1L << (PRIVATE - 1)) | (1L << (PROTECTED - 1)) | (1L << (PUBLIC - 1)) | (1L << (RETURN - 1)) | (1L << (SHORT - 1)) | (1L << (STATIC - 1)) | (1L << (STRICTFP - 1)) | (1L << (SUPER - 1)) | (1L << (SWITCH - 1)) | (1L << (SYNCHRONIZED - 1)) | (1L << (THIS - 1)) | (1L << (THROW - 1)) | (1L << (TRY - 1)) | (1L << (VOID - 1)) | (1L << (WHILE - 1)) | (1L << (MODULE - 1)) | (1L << (OPEN - 1)) | (1L << (REQUIRES - 1)) | (1L << (EXPORTS - 1)) | (1L << (OPENS - 1)) | (1L << (TO - 1)) | (1L << (USES - 1)) | (1L << (PROVIDES - 1)) | (1L << (WITH - 1)) | (1L << (TRANSITIVE - 1)) | (1L << (VAR - 1)) | (1L << (YIELD - 1)) | (1L << (RECORD - 1)) | (1L << (SEALED - 1)))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (PERMITS - 65)) | (1L << (NON_SEALED - 65)) | (1L << (DECIMAL_LITERAL - 65)) | (1L << (HEX_LITERAL - 65)) | (1L << (OCT_LITERAL - 65)) | (1L << (BINARY_LITERAL - 65)) | (1L << (FLOAT_LITERAL - 65)) | (1L << (HEX_FLOAT_LITERAL - 65)) | (1L << (BOOL_LITERAL - 65)) | (1L << (CHAR_LITERAL - 65)) | (1L << (STRING_LITERAL - 65)) | (1L << (TEXT_BLOCK - 65)) | (1L << (NULL_LITERAL - 65)) | (1L << (LPAREN - 65)) | (1L << (LBRACE - 65)) | (1L << (SEMI - 65)) | (1L << (LT - 65)) | (1L << (BANG - 65)) | (1L << (TILDE - 65)) | (1L << (INC - 65)) | (1L << (DEC - 65)) | (1L << (ADD - 65)) | (1L << (SUB - 65)) | (1L << (AT - 65)) | (1L << (IDENTIFIER - 65)))) != 0)) { { { setState(1584); blockStatement(); } } setState(1589); _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 ClassTypeContext extends ParserRuleContext { public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public ClassOrInterfaceTypeContext classOrInterfaceType() { return getRuleContext(ClassOrInterfaceTypeContext.class,0); } public TerminalNode DOT() { return getToken(JavaParser.DOT, 0); } public List annotation() { return getRuleContexts(AnnotationContext.class); } public AnnotationContext annotation(int i) { return getRuleContext(AnnotationContext.class,i); } public TypeArgumentsContext typeArguments() { return getRuleContext(TypeArgumentsContext.class,0); } public ClassTypeContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_classType; } } public final ClassTypeContext classType() throws RecognitionException { ClassTypeContext _localctx = new ClassTypeContext(_ctx, getState()); enterRule(_localctx, 218, RULE_classType); int _la; try { int _alt; enterOuterAlt(_localctx, 1); { setState(1595); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,191,_ctx) ) { case 1: { setState(1592); classOrInterfaceType(); setState(1593); match(DOT); } break; } setState(1600); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,192,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(1597); annotation(); } } } setState(1602); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,192,_ctx); } setState(1603); identifier(); setState(1605); _errHandler.sync(this); _la = _input.LA(1); if (_la==LT) { { setState(1604); typeArguments(); } } } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class CreatorContext extends ParserRuleContext { public CreatedNameContext createdName() { return getRuleContext(CreatedNameContext.class,0); } public ClassCreatorRestContext classCreatorRest() { return getRuleContext(ClassCreatorRestContext.class,0); } public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() { return getRuleContext(NonWildcardTypeArgumentsContext.class,0); } public ArrayCreatorRestContext arrayCreatorRest() { return getRuleContext(ArrayCreatorRestContext.class,0); } public CreatorContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_creator; } } public final CreatorContext creator() throws RecognitionException { CreatorContext _localctx = new CreatorContext(_ctx, getState()); enterRule(_localctx, 220, RULE_creator); int _la; try { setState(1616); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,195,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { setState(1608); _errHandler.sync(this); _la = _input.LA(1); if (_la==LT) { { setState(1607); nonWildcardTypeArguments(); } } setState(1610); createdName(); setState(1611); classCreatorRest(); } break; case 2: enterOuterAlt(_localctx, 2); { setState(1613); createdName(); setState(1614); arrayCreatorRest(); } break; } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class CreatedNameContext extends ParserRuleContext { public List identifier() { return getRuleContexts(IdentifierContext.class); } public IdentifierContext identifier(int i) { return getRuleContext(IdentifierContext.class,i); } public List typeArgumentsOrDiamond() { return getRuleContexts(TypeArgumentsOrDiamondContext.class); } public TypeArgumentsOrDiamondContext typeArgumentsOrDiamond(int i) { return getRuleContext(TypeArgumentsOrDiamondContext.class,i); } public List DOT() { return getTokens(JavaParser.DOT); } public TerminalNode DOT(int i) { return getToken(JavaParser.DOT, i); } public PrimitiveTypeContext primitiveType() { return getRuleContext(PrimitiveTypeContext.class,0); } public CreatedNameContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_createdName; } } public final CreatedNameContext createdName() throws RecognitionException { CreatedNameContext _localctx = new CreatedNameContext(_ctx, getState()); enterRule(_localctx, 222, RULE_createdName); int _la; try { setState(1633); _errHandler.sync(this); switch (_input.LA(1)) { case MODULE: case OPEN: case REQUIRES: case EXPORTS: case OPENS: case TO: case USES: case PROVIDES: case WITH: case TRANSITIVE: case VAR: case YIELD: case RECORD: case SEALED: case PERMITS: case IDENTIFIER: enterOuterAlt(_localctx, 1); { setState(1618); identifier(); setState(1620); _errHandler.sync(this); _la = _input.LA(1); if (_la==LT) { { setState(1619); typeArgumentsOrDiamond(); } } setState(1629); _errHandler.sync(this); _la = _input.LA(1); while (_la==DOT) { { { setState(1622); match(DOT); setState(1623); identifier(); setState(1625); _errHandler.sync(this); _la = _input.LA(1); if (_la==LT) { { setState(1624); typeArgumentsOrDiamond(); } } } } setState(1631); _errHandler.sync(this); _la = _input.LA(1); } } break; case BOOLEAN: case BYTE: case CHAR: case DOUBLE: case FLOAT: case INT: case LONG: case SHORT: enterOuterAlt(_localctx, 2); { setState(1632); primitiveType(); } 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 InnerCreatorContext extends ParserRuleContext { public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public ClassCreatorRestContext classCreatorRest() { return getRuleContext(ClassCreatorRestContext.class,0); } public NonWildcardTypeArgumentsOrDiamondContext nonWildcardTypeArgumentsOrDiamond() { return getRuleContext(NonWildcardTypeArgumentsOrDiamondContext.class,0); } public InnerCreatorContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_innerCreator; } } public final InnerCreatorContext innerCreator() throws RecognitionException { InnerCreatorContext _localctx = new InnerCreatorContext(_ctx, getState()); enterRule(_localctx, 224, RULE_innerCreator); int _la; try { enterOuterAlt(_localctx, 1); { setState(1635); identifier(); setState(1637); _errHandler.sync(this); _la = _input.LA(1); if (_la==LT) { { setState(1636); nonWildcardTypeArgumentsOrDiamond(); } } setState(1639); classCreatorRest(); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class ArrayCreatorRestContext extends ParserRuleContext { public ArrayInitializerContext arrayInitializer() { return getRuleContext(ArrayInitializerContext.class,0); } public List LBRACK() { return getTokens(JavaParser.LBRACK); } public TerminalNode LBRACK(int i) { return getToken(JavaParser.LBRACK, i); } public List RBRACK() { return getTokens(JavaParser.RBRACK); } public TerminalNode RBRACK(int i) { return getToken(JavaParser.RBRACK, i); } public List expression() { return getRuleContexts(ExpressionContext.class); } public ExpressionContext expression(int i) { return getRuleContext(ExpressionContext.class,i); } public ArrayCreatorRestContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_arrayCreatorRest; } } public final ArrayCreatorRestContext arrayCreatorRest() throws RecognitionException { ArrayCreatorRestContext _localctx = new ArrayCreatorRestContext(_ctx, getState()); enterRule(_localctx, 226, RULE_arrayCreatorRest); int _la; try { int _alt; setState(1663); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,204,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { setState(1643); _errHandler.sync(this); _la = _input.LA(1); do { { { setState(1641); match(LBRACK); setState(1642); match(RBRACK); } } setState(1645); _errHandler.sync(this); _la = _input.LA(1); } while ( _la==LBRACK ); setState(1647); arrayInitializer(); } break; case 2: enterOuterAlt(_localctx, 2); { setState(1652); _errHandler.sync(this); _alt = 1; do { switch (_alt) { case 1: { { setState(1648); match(LBRACK); setState(1649); expression(0); setState(1650); match(RBRACK); } } break; default: throw new NoViableAltException(this); } setState(1654); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,202,_ctx); } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); setState(1660); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,203,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(1656); match(LBRACK); setState(1657); match(RBRACK); } } } setState(1662); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,203,_ctx); } } break; } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class ClassCreatorRestContext extends ParserRuleContext { public ArgumentsContext arguments() { return getRuleContext(ArgumentsContext.class,0); } public ClassBodyContext classBody() { return getRuleContext(ClassBodyContext.class,0); } public ClassCreatorRestContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_classCreatorRest; } } public final ClassCreatorRestContext classCreatorRest() throws RecognitionException { ClassCreatorRestContext _localctx = new ClassCreatorRestContext(_ctx, getState()); enterRule(_localctx, 228, RULE_classCreatorRest); try { enterOuterAlt(_localctx, 1); { setState(1665); arguments(); setState(1667); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,205,_ctx) ) { case 1: { setState(1666); classBody(); } break; } } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class ExplicitGenericInvocationContext extends ParserRuleContext { public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() { return getRuleContext(NonWildcardTypeArgumentsContext.class,0); } public ExplicitGenericInvocationSuffixContext explicitGenericInvocationSuffix() { return getRuleContext(ExplicitGenericInvocationSuffixContext.class,0); } public ExplicitGenericInvocationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_explicitGenericInvocation; } } public final ExplicitGenericInvocationContext explicitGenericInvocation() throws RecognitionException { ExplicitGenericInvocationContext _localctx = new ExplicitGenericInvocationContext(_ctx, getState()); enterRule(_localctx, 230, RULE_explicitGenericInvocation); try { enterOuterAlt(_localctx, 1); { setState(1669); nonWildcardTypeArguments(); setState(1670); explicitGenericInvocationSuffix(); } } 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 TerminalNode LT() { return getToken(JavaParser.LT, 0); } public TerminalNode GT() { return getToken(JavaParser.GT, 0); } public TypeArgumentsContext typeArguments() { return getRuleContext(TypeArgumentsContext.class,0); } public TypeArgumentsOrDiamondContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_typeArgumentsOrDiamond; } } public final TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() throws RecognitionException { TypeArgumentsOrDiamondContext _localctx = new TypeArgumentsOrDiamondContext(_ctx, getState()); enterRule(_localctx, 232, RULE_typeArgumentsOrDiamond); try { setState(1675); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,206,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { setState(1672); match(LT); setState(1673); match(GT); } break; case 2: enterOuterAlt(_localctx, 2); { setState(1674); typeArguments(); } break; } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class NonWildcardTypeArgumentsOrDiamondContext extends ParserRuleContext { public TerminalNode LT() { return getToken(JavaParser.LT, 0); } public TerminalNode GT() { return getToken(JavaParser.GT, 0); } public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() { return getRuleContext(NonWildcardTypeArgumentsContext.class,0); } public NonWildcardTypeArgumentsOrDiamondContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_nonWildcardTypeArgumentsOrDiamond; } } public final NonWildcardTypeArgumentsOrDiamondContext nonWildcardTypeArgumentsOrDiamond() throws RecognitionException { NonWildcardTypeArgumentsOrDiamondContext _localctx = new NonWildcardTypeArgumentsOrDiamondContext(_ctx, getState()); enterRule(_localctx, 234, RULE_nonWildcardTypeArgumentsOrDiamond); try { setState(1680); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,207,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { setState(1677); match(LT); setState(1678); match(GT); } break; case 2: enterOuterAlt(_localctx, 2); { setState(1679); nonWildcardTypeArguments(); } break; } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class NonWildcardTypeArgumentsContext extends ParserRuleContext { public TerminalNode LT() { return getToken(JavaParser.LT, 0); } public TypeListContext typeList() { return getRuleContext(TypeListContext.class,0); } public TerminalNode GT() { return getToken(JavaParser.GT, 0); } public NonWildcardTypeArgumentsContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_nonWildcardTypeArguments; } } public final NonWildcardTypeArgumentsContext nonWildcardTypeArguments() throws RecognitionException { NonWildcardTypeArgumentsContext _localctx = new NonWildcardTypeArgumentsContext(_ctx, getState()); enterRule(_localctx, 236, RULE_nonWildcardTypeArguments); try { enterOuterAlt(_localctx, 1); { setState(1682); match(LT); setState(1683); typeList(); setState(1684); match(GT); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class TypeListContext extends ParserRuleContext { public List typeType() { return getRuleContexts(TypeTypeContext.class); } public TypeTypeContext typeType(int i) { return getRuleContext(TypeTypeContext.class,i); } public List COMMA() { return getTokens(JavaParser.COMMA); } public TerminalNode COMMA(int i) { return getToken(JavaParser.COMMA, i); } public TypeListContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_typeList; } } public final TypeListContext typeList() throws RecognitionException { TypeListContext _localctx = new TypeListContext(_ctx, getState()); enterRule(_localctx, 238, RULE_typeList); int _la; try { enterOuterAlt(_localctx, 1); { setState(1686); typeType(); setState(1691); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { setState(1687); match(COMMA); setState(1688); typeType(); } } setState(1693); _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 TypeTypeContext extends ParserRuleContext { public ClassOrInterfaceTypeContext classOrInterfaceType() { return getRuleContext(ClassOrInterfaceTypeContext.class,0); } public PrimitiveTypeContext primitiveType() { return getRuleContext(PrimitiveTypeContext.class,0); } public List annotation() { return getRuleContexts(AnnotationContext.class); } public AnnotationContext annotation(int i) { return getRuleContext(AnnotationContext.class,i); } public List LBRACK() { return getTokens(JavaParser.LBRACK); } public TerminalNode LBRACK(int i) { return getToken(JavaParser.LBRACK, i); } public List RBRACK() { return getTokens(JavaParser.RBRACK); } public TerminalNode RBRACK(int i) { return getToken(JavaParser.RBRACK, i); } public TypeTypeContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_typeType; } } public final TypeTypeContext typeType() throws RecognitionException { TypeTypeContext _localctx = new TypeTypeContext(_ctx, getState()); enterRule(_localctx, 240, RULE_typeType); int _la; try { int _alt; enterOuterAlt(_localctx, 1); { setState(1697); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,209,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(1694); annotation(); } } } setState(1699); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,209,_ctx); } setState(1702); _errHandler.sync(this); switch (_input.LA(1)) { case MODULE: case OPEN: case REQUIRES: case EXPORTS: case OPENS: case TO: case USES: case PROVIDES: case WITH: case TRANSITIVE: case VAR: case YIELD: case RECORD: case SEALED: case PERMITS: case IDENTIFIER: { setState(1700); classOrInterfaceType(); } break; case BOOLEAN: case BYTE: case CHAR: case DOUBLE: case FLOAT: case INT: case LONG: case SHORT: { setState(1701); primitiveType(); } break; default: throw new NoViableAltException(this); } setState(1714); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,212,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(1707); _errHandler.sync(this); _la = _input.LA(1); while (((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & ((1L << (MODULE - 51)) | (1L << (OPEN - 51)) | (1L << (REQUIRES - 51)) | (1L << (EXPORTS - 51)) | (1L << (OPENS - 51)) | (1L << (TO - 51)) | (1L << (USES - 51)) | (1L << (PROVIDES - 51)) | (1L << (WITH - 51)) | (1L << (TRANSITIVE - 51)) | (1L << (VAR - 51)) | (1L << (YIELD - 51)) | (1L << (RECORD - 51)) | (1L << (SEALED - 51)) | (1L << (PERMITS - 51)))) != 0) || _la==AT || _la==IDENTIFIER) { { { setState(1704); annotation(); } } setState(1709); _errHandler.sync(this); _la = _input.LA(1); } setState(1710); match(LBRACK); setState(1711); match(RBRACK); } } } setState(1716); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,212,_ctx); } } } 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 TerminalNode BOOLEAN() { return getToken(JavaParser.BOOLEAN, 0); } public TerminalNode CHAR() { return getToken(JavaParser.CHAR, 0); } public TerminalNode BYTE() { return getToken(JavaParser.BYTE, 0); } public TerminalNode SHORT() { return getToken(JavaParser.SHORT, 0); } public TerminalNode INT() { return getToken(JavaParser.INT, 0); } public TerminalNode LONG() { return getToken(JavaParser.LONG, 0); } public TerminalNode FLOAT() { return getToken(JavaParser.FLOAT, 0); } public TerminalNode DOUBLE() { return getToken(JavaParser.DOUBLE, 0); } public PrimitiveTypeContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_primitiveType; } } public final PrimitiveTypeContext primitiveType() throws RecognitionException { PrimitiveTypeContext _localctx = new PrimitiveTypeContext(_ctx, getState()); enterRule(_localctx, 242, RULE_primitiveType); int _la; try { enterOuterAlt(_localctx, 1); { setState(1717); _la = _input.LA(1); if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (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 TypeArgumentsContext extends ParserRuleContext { public TerminalNode LT() { return getToken(JavaParser.LT, 0); } public List typeArgument() { return getRuleContexts(TypeArgumentContext.class); } public TypeArgumentContext typeArgument(int i) { return getRuleContext(TypeArgumentContext.class,i); } public TerminalNode GT() { return getToken(JavaParser.GT, 0); } public List COMMA() { return getTokens(JavaParser.COMMA); } public TerminalNode COMMA(int i) { return getToken(JavaParser.COMMA, i); } public TypeArgumentsContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_typeArguments; } } public final TypeArgumentsContext typeArguments() throws RecognitionException { TypeArgumentsContext _localctx = new TypeArgumentsContext(_ctx, getState()); enterRule(_localctx, 244, RULE_typeArguments); int _la; try { enterOuterAlt(_localctx, 1); { setState(1719); match(LT); setState(1720); typeArgument(); setState(1725); _errHandler.sync(this); _la = _input.LA(1); while (_la==COMMA) { { { setState(1721); match(COMMA); setState(1722); typeArgument(); } } setState(1727); _errHandler.sync(this); _la = _input.LA(1); } setState(1728); match(GT); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } public static class SuperSuffixContext extends ParserRuleContext { public ArgumentsContext arguments() { return getRuleContext(ArgumentsContext.class,0); } public TerminalNode DOT() { return getToken(JavaParser.DOT, 0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public TypeArgumentsContext typeArguments() { return getRuleContext(TypeArgumentsContext.class,0); } public SuperSuffixContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_superSuffix; } } public final SuperSuffixContext superSuffix() throws RecognitionException { SuperSuffixContext _localctx = new SuperSuffixContext(_ctx, getState()); enterRule(_localctx, 246, RULE_superSuffix); int _la; try { setState(1739); _errHandler.sync(this); switch (_input.LA(1)) { case LPAREN: enterOuterAlt(_localctx, 1); { setState(1730); arguments(); } break; case DOT: enterOuterAlt(_localctx, 2); { setState(1731); match(DOT); setState(1733); _errHandler.sync(this); _la = _input.LA(1); if (_la==LT) { { setState(1732); typeArguments(); } } setState(1735); identifier(); setState(1737); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,215,_ctx) ) { case 1: { setState(1736); arguments(); } 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 ExplicitGenericInvocationSuffixContext extends ParserRuleContext { public TerminalNode SUPER() { return getToken(JavaParser.SUPER, 0); } public SuperSuffixContext superSuffix() { return getRuleContext(SuperSuffixContext.class,0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public ArgumentsContext arguments() { return getRuleContext(ArgumentsContext.class,0); } public ExplicitGenericInvocationSuffixContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_explicitGenericInvocationSuffix; } } public final ExplicitGenericInvocationSuffixContext explicitGenericInvocationSuffix() throws RecognitionException { ExplicitGenericInvocationSuffixContext _localctx = new ExplicitGenericInvocationSuffixContext(_ctx, getState()); enterRule(_localctx, 248, RULE_explicitGenericInvocationSuffix); try { setState(1746); _errHandler.sync(this); switch (_input.LA(1)) { case SUPER: enterOuterAlt(_localctx, 1); { setState(1741); match(SUPER); setState(1742); superSuffix(); } break; case MODULE: case OPEN: case REQUIRES: case EXPORTS: case OPENS: case TO: case USES: case PROVIDES: case WITH: case TRANSITIVE: case VAR: case YIELD: case RECORD: case SEALED: case PERMITS: case IDENTIFIER: enterOuterAlt(_localctx, 2); { setState(1743); identifier(); setState(1744); arguments(); } 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 ArgumentsContext extends ParserRuleContext { public TerminalNode LPAREN() { return getToken(JavaParser.LPAREN, 0); } public TerminalNode RPAREN() { return getToken(JavaParser.RPAREN, 0); } public ExpressionListContext expressionList() { return getRuleContext(ExpressionListContext.class,0); } public ArgumentsContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_arguments; } } public final ArgumentsContext arguments() throws RecognitionException { ArgumentsContext _localctx = new ArgumentsContext(_ctx, getState()); enterRule(_localctx, 250, RULE_arguments); int _la; try { enterOuterAlt(_localctx, 1); { setState(1748); match(LPAREN); setState(1750); _errHandler.sync(this); _la = _input.LA(1); if (((((_la - 3)) & ~0x3f) == 0 && ((1L << (_la - 3)) & ((1L << (BOOLEAN - 3)) | (1L << (BYTE - 3)) | (1L << (CHAR - 3)) | (1L << (DOUBLE - 3)) | (1L << (FLOAT - 3)) | (1L << (INT - 3)) | (1L << (LONG - 3)) | (1L << (NEW - 3)) | (1L << (SHORT - 3)) | (1L << (SUPER - 3)) | (1L << (SWITCH - 3)) | (1L << (THIS - 3)) | (1L << (VOID - 3)) | (1L << (MODULE - 3)) | (1L << (OPEN - 3)) | (1L << (REQUIRES - 3)) | (1L << (EXPORTS - 3)) | (1L << (OPENS - 3)) | (1L << (TO - 3)) | (1L << (USES - 3)) | (1L << (PROVIDES - 3)) | (1L << (WITH - 3)) | (1L << (TRANSITIVE - 3)) | (1L << (VAR - 3)) | (1L << (YIELD - 3)) | (1L << (RECORD - 3)) | (1L << (SEALED - 3)) | (1L << (PERMITS - 3)))) != 0) || ((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & ((1L << (DECIMAL_LITERAL - 67)) | (1L << (HEX_LITERAL - 67)) | (1L << (OCT_LITERAL - 67)) | (1L << (BINARY_LITERAL - 67)) | (1L << (FLOAT_LITERAL - 67)) | (1L << (HEX_FLOAT_LITERAL - 67)) | (1L << (BOOL_LITERAL - 67)) | (1L << (CHAR_LITERAL - 67)) | (1L << (STRING_LITERAL - 67)) | (1L << (TEXT_BLOCK - 67)) | (1L << (NULL_LITERAL - 67)) | (1L << (LPAREN - 67)) | (1L << (LT - 67)) | (1L << (BANG - 67)) | (1L << (TILDE - 67)) | (1L << (INC - 67)) | (1L << (DEC - 67)) | (1L << (ADD - 67)) | (1L << (SUB - 67)) | (1L << (AT - 67)) | (1L << (IDENTIFIER - 67)))) != 0)) { { setState(1749); expressionList(); } } setState(1752); match(RPAREN); } } 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 99: return expression_sempred((ExpressionContext)_localctx, predIndex); case 107: return guardedPattern_sempred((GuardedPatternContext)_localctx, predIndex); } return true; } private boolean expression_sempred(ExpressionContext _localctx, int predIndex) { switch (predIndex) { case 0: return precpred(_ctx, 14); case 1: return precpred(_ctx, 13); case 2: return precpred(_ctx, 12); case 3: return precpred(_ctx, 11); case 4: return precpred(_ctx, 9); case 5: return precpred(_ctx, 8); case 6: return precpred(_ctx, 7); case 7: return precpred(_ctx, 6); case 8: return precpred(_ctx, 5); case 9: return precpred(_ctx, 4); case 10: return precpred(_ctx, 3); case 11: return precpred(_ctx, 2); case 12: return precpred(_ctx, 25); case 13: return precpred(_ctx, 24); case 14: return precpred(_ctx, 22); case 15: return precpred(_ctx, 18); case 16: return precpred(_ctx, 10); } return true; } private boolean guardedPattern_sempred(GuardedPatternContext _localctx, int predIndex) { switch (predIndex) { case 17: return precpred(_ctx, 1); } return true; } public static final String _serializedATN = "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u0082\u06dd\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\3\2\5\2\u0100"+ "\n\2\3\2\3\2\7\2\u0104\n\2\f\2\16\2\u0107\13\2\3\2\3\2\7\2\u010b\n\2\f"+ "\2\16\2\u010e\13\2\3\2\3\2\3\2\5\2\u0113\n\2\3\3\7\3\u0116\n\3\f\3\16"+ "\3\u0119\13\3\3\3\3\3\3\3\3\3\3\4\3\4\5\4\u0121\n\4\3\4\3\4\3\4\5\4\u0126"+ "\n\4\3\4\3\4\3\5\7\5\u012b\n\5\f\5\16\5\u012e\13\5\3\5\3\5\3\5\3\5\3\5"+ "\5\5\u0135\n\5\3\6\3\6\3\6\3\6\3\6\5\6\u013c\n\6\3\7\3\7\3\7\3\7\3\7\3"+ "\7\3\7\3\7\3\7\3\7\5\7\u0148\n\7\3\b\3\b\5\b\u014c\n\b\3\t\3\t\3\t\5\t"+ "\u0151\n\t\3\t\3\t\5\t\u0155\n\t\3\t\3\t\5\t\u0159\n\t\3\t\3\t\5\t\u015d"+ "\n\t\3\t\3\t\3\n\3\n\3\n\3\n\7\n\u0165\n\n\f\n\16\n\u0168\13\n\3\n\3\n"+ "\3\13\7\13\u016d\n\13\f\13\16\13\u0170\13\13\3\13\3\13\3\13\7\13\u0175"+ "\n\13\f\13\16\13\u0178\13\13\3\13\5\13\u017b\n\13\3\f\3\f\3\f\7\f\u0180"+ "\n\f\f\f\16\f\u0183\13\f\3\r\3\r\3\r\3\r\5\r\u0189\n\r\3\r\3\r\5\r\u018d"+ "\n\r\3\r\5\r\u0190\n\r\3\r\5\r\u0193\n\r\3\r\3\r\3\16\3\16\3\16\7\16\u019a"+ "\n\16\f\16\16\16\u019d\13\16\3\17\7\17\u01a0\n\17\f\17\16\17\u01a3\13"+ "\17\3\17\3\17\5\17\u01a7\n\17\3\17\5\17\u01aa\n\17\3\20\3\20\7\20\u01ae"+ "\n\20\f\20\16\20\u01b1\13\20\3\21\3\21\3\21\5\21\u01b6\n\21\3\21\3\21"+ "\5\21\u01ba\n\21\3\21\3\21\5\21\u01be\n\21\3\21\3\21\3\22\3\22\7\22\u01c4"+ "\n\22\f\22\16\22\u01c7\13\22\3\22\3\22\3\23\3\23\7\23\u01cd\n\23\f\23"+ "\16\23\u01d0\13\23\3\23\3\23\3\24\3\24\5\24\u01d6\n\24\3\24\3\24\7\24"+ "\u01da\n\24\f\24\16\24\u01dd\13\24\3\24\5\24\u01e0\n\24\3\25\3\25\3\25"+ "\3\25\3\25\3\25\3\25\3\25\3\25\3\25\5\25\u01ec\n\25\3\26\3\26\3\26\3\26"+ "\3\26\7\26\u01f3\n\26\f\26\16\26\u01f6\13\26\3\26\3\26\5\26\u01fa\n\26"+ "\3\26\3\26\3\27\3\27\5\27\u0200\n\27\3\30\3\30\5\30\u0204\n\30\3\31\3"+ "\31\3\31\3\32\3\32\3\32\3\33\3\33\3\33\3\33\5\33\u0210\n\33\3\33\3\33"+ "\3\34\7\34\u0215\n\34\f\34\16\34\u0218\13\34\3\34\3\34\3\34\3\35\3\35"+ "\3\35\3\35\3\36\7\36\u0222\n\36\f\36\16\36\u0225\13\36\3\36\3\36\5\36"+ "\u0229\n\36\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\5\37\u0233\n\37\3"+ " \3 \3 \3 \7 \u0239\n \f \16 \u023c\13 \3 \3 \3!\3!\3!\7!\u0243\n!\f!"+ "\16!\u0246\13!\3!\3!\3!\3\"\7\"\u024c\n\"\f\"\16\"\u024f\13\"\3\"\3\""+ "\3#\3#\3#\3#\3#\3#\5#\u0259\n#\3$\7$\u025c\n$\f$\16$\u025f\13$\3$\3$\3"+ "$\3%\7%\u0265\n%\f%\16%\u0268\13%\3%\3%\3%\3%\3%\7%\u026f\n%\f%\16%\u0272"+ "\13%\3%\3%\5%\u0276\n%\3%\3%\3&\3&\3&\7&\u027d\n&\f&\16&\u0280\13&\3\'"+ "\3\'\3\'\5\'\u0285\n\'\3(\3(\3(\7(\u028a\n(\f(\16(\u028d\13(\3)\3)\5)"+ "\u0291\n)\3*\3*\3*\3*\7*\u0297\n*\f*\16*\u029a\13*\3*\5*\u029d\n*\5*\u029f"+ "\n*\3*\3*\3+\3+\5+\u02a5\n+\3+\3+\7+\u02a9\n+\f+\16+\u02ac\13+\3+\3+\5"+ "+\u02b0\n+\3,\3,\7,\u02b4\n,\f,\16,\u02b7\13,\3,\3,\3,\5,\u02bc\n,\5,"+ "\u02be\n,\3-\3-\3-\7-\u02c3\n-\f-\16-\u02c6\13-\3.\3.\5.\u02ca\n.\3.\3"+ ".\3.\5.\u02cf\n.\3.\5.\u02d2\n.\5.\u02d4\n.\3.\3.\3/\3/\3/\3/\7/\u02dc"+ "\n/\f/\16/\u02df\13/\3/\3/\3\60\3\60\3\60\7\60\u02e6\n\60\f\60\16\60\u02e9"+ "\13\60\3\60\3\60\5\60\u02ed\n\60\3\60\5\60\u02f0\n\60\3\61\7\61\u02f3"+ "\n\61\f\61\16\61\u02f6\13\61\3\61\3\61\3\61\3\62\7\62\u02fc\n\62\f\62"+ "\16\62\u02ff\13\62\3\62\3\62\7\62\u0303\n\62\f\62\16\62\u0306\13\62\3"+ "\62\3\62\3\62\3\63\3\63\3\63\7\63\u030e\n\63\f\63\16\63\u0311\13\63\3"+ "\64\7\64\u0314\n\64\f\64\16\64\u0317\13\64\3\64\3\64\3\64\3\65\3\65\3"+ "\65\7\65\u031f\n\65\f\65\16\65\u0322\13\65\3\66\3\66\3\66\3\66\3\66\3"+ "\66\3\66\5\66\u032b\n\66\3\67\3\67\38\38\39\39\39\79\u0334\n9\f9\169\u0337"+ "\139\39\39\39\3:\3:\3:\5:\u033f\n:\3:\3:\3:\5:\u0344\n:\3:\5:\u0347\n"+ ":\3;\3;\3;\7;\u034c\n;\f;\16;\u034f\13;\3<\3<\3<\3<\3=\3=\3=\5=\u0358"+ "\n=\3>\3>\3>\3>\7>\u035e\n>\f>\16>\u0361\13>\5>\u0363\n>\3>\5>\u0366\n"+ ">\3>\3>\3?\3?\3?\3?\3?\3@\3@\7@\u0371\n@\f@\16@\u0374\13@\3@\3@\3A\7A"+ "\u0379\nA\fA\16A\u037c\13A\3A\3A\5A\u0380\nA\3B\3B\3B\3B\3B\3B\5B\u0388"+ "\nB\3B\3B\5B\u038c\nB\3B\3B\5B\u0390\nB\3B\3B\5B\u0394\nB\3B\3B\5B\u0398"+ "\nB\5B\u039a\nB\3C\3C\5C\u039e\nC\3D\3D\3D\3D\5D\u03a4\nD\3E\3E\3F\3F"+ "\3F\3G\5G\u03ac\nG\3G\3G\3G\3G\3H\3H\7H\u03b4\nH\fH\16H\u03b7\13H\3H\3"+ "H\3I\3I\7I\u03bd\nI\fI\16I\u03c0\13I\3I\3I\3I\3I\3I\3I\3I\5I\u03c9\nI"+ "\3I\3I\3I\3I\3I\3I\5I\u03d1\nI\3I\3I\3I\3I\3I\3I\3I\3I\3I\3I\3I\3I\5I"+ "\u03df\nI\3J\3J\3K\3K\3K\5K\u03e6\nK\3K\3K\3K\5K\u03eb\nK\3K\3K\3L\3L"+ "\5L\u03f1\nL\3L\3L\3M\3M\3M\7M\u03f8\nM\fM\16M\u03fb\13M\3N\3N\3N\3O\3"+ "O\3O\7O\u0403\nO\fO\16O\u0406\13O\3O\3O\3P\3P\7P\u040c\nP\fP\16P\u040f"+ "\13P\3P\3P\3Q\3Q\3Q\3Q\3Q\5Q\u0418\nQ\3R\7R\u041b\nR\fR\16R\u041e\13R"+ "\3R\3R\3R\3R\3R\3R\3R\3R\5R\u0428\nR\3S\3S\3T\3T\3U\7U\u042f\nU\fU\16"+ "U\u0432\13U\3U\3U\3U\5U\u0437\nU\3V\3V\3V\3V\3V\5V\u043e\nV\3V\3V\3V\3"+ "V\3V\3V\3V\5V\u0447\nV\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3"+ "V\3V\3V\3V\6V\u045c\nV\rV\16V\u045d\3V\5V\u0461\nV\3V\5V\u0464\nV\3V\3"+ "V\3V\3V\7V\u046a\nV\fV\16V\u046d\13V\3V\5V\u0470\nV\3V\3V\3V\3V\7V\u0476"+ "\nV\fV\16V\u0479\13V\3V\7V\u047c\nV\fV\16V\u047f\13V\3V\3V\3V\3V\3V\3"+ "V\3V\3V\5V\u0489\nV\3V\3V\3V\3V\3V\3V\3V\5V\u0492\nV\3V\3V\3V\5V\u0497"+ "\nV\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\3V\5V\u04a4\nV\3V\3V\3V\3V\5V\u04aa"+ "\nV\3W\3W\3W\7W\u04af\nW\fW\16W\u04b2\13W\3W\3W\3W\3W\3W\3X\3X\3X\7X\u04bc"+ "\nX\fX\16X\u04bf\13X\3Y\3Y\3Y\3Z\3Z\3Z\5Z\u04c7\nZ\3Z\3Z\3[\3[\3[\7[\u04ce"+ "\n[\f[\16[\u04d1\13[\3\\\7\\\u04d4\n\\\f\\\16\\\u04d7\13\\\3\\\3\\\3\\"+ "\3\\\3\\\5\\\u04de\n\\\3\\\3\\\3\\\3\\\5\\\u04e4\n\\\3]\6]\u04e7\n]\r"+ "]\16]\u04e8\3]\6]\u04ec\n]\r]\16]\u04ed\3^\3^\3^\3^\3^\3^\5^\u04f6\n^"+ "\3^\3^\3^\5^\u04fb\n^\3_\3_\5_\u04ff\n_\3_\3_\5_\u0503\n_\3_\3_\5_\u0507"+ "\n_\5_\u0509\n_\3`\3`\5`\u050d\n`\3a\7a\u0510\na\fa\16a\u0513\13a\3a\3"+ "a\5a\u0517\na\3a\3a\3a\3a\3b\3b\3b\3b\3c\3c\3c\7c\u0524\nc\fc\16c\u0527"+ "\13c\3d\3d\3d\5d\u052c\nd\3d\3d\3e\3e\3e\3e\3e\3e\5e\u0536\ne\3e\3e\5"+ "e\u053a\ne\3e\3e\3e\5e\u053f\ne\3e\3e\3e\3e\3e\3e\3e\7e\u0548\ne\fe\16"+ "e\u054b\13e\3e\3e\3e\7e\u0550\ne\fe\16e\u0553\13e\3e\3e\3e\3e\3e\3e\5"+ "e\u055b\ne\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\5e\u056b\ne\3e\3"+ "e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3"+ "e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\5e\u0598\ne\3"+ "e\3e\3e\3e\5e\u059e\ne\3e\3e\3e\5e\u05a3\ne\3e\3e\3e\3e\3e\3e\3e\5e\u05ac"+ "\ne\7e\u05ae\ne\fe\16e\u05b1\13e\3f\7f\u05b4\nf\ff\16f\u05b7\13f\3f\3"+ "f\7f\u05bb\nf\ff\16f\u05be\13f\3f\3f\3g\3g\3g\3g\3h\3h\3h\5h\u05c9\nh"+ "\3h\3h\3h\3h\3h\7h\u05d0\nh\fh\16h\u05d3\13h\3h\3h\3h\3h\5h\u05d9\nh\3"+ "h\5h\u05dc\nh\3i\3i\5i\u05e0\ni\3j\3j\3j\3j\3j\3j\3j\3j\3j\3j\3j\3j\3"+ "j\3j\3j\3j\5j\u05f2\nj\5j\u05f4\nj\3k\3k\3k\3k\7k\u05fa\nk\fk\16k\u05fd"+ "\13k\3k\3k\3l\3l\3l\3l\5l\u0605\nl\3l\3l\3l\3l\3l\5l\u060c\nl\3m\3m\3"+ "m\3m\3m\3m\7m\u0614\nm\fm\16m\u0617\13m\3m\3m\7m\u061b\nm\fm\16m\u061e"+ "\13m\3m\3m\3m\7m\u0623\nm\fm\16m\u0626\13m\5m\u0628\nm\3m\3m\3m\7m\u062d"+ "\nm\fm\16m\u0630\13m\3n\3n\7n\u0634\nn\fn\16n\u0637\13n\5n\u0639\nn\3"+ "o\3o\3o\5o\u063e\no\3o\7o\u0641\no\fo\16o\u0644\13o\3o\3o\5o\u0648\no"+ "\3p\5p\u064b\np\3p\3p\3p\3p\3p\3p\5p\u0653\np\3q\3q\5q\u0657\nq\3q\3q"+ "\3q\5q\u065c\nq\7q\u065e\nq\fq\16q\u0661\13q\3q\5q\u0664\nq\3r\3r\5r\u0668"+ "\nr\3r\3r\3s\3s\6s\u066e\ns\rs\16s\u066f\3s\3s\3s\3s\3s\6s\u0677\ns\r"+ "s\16s\u0678\3s\3s\7s\u067d\ns\fs\16s\u0680\13s\5s\u0682\ns\3t\3t\5t\u0686"+ "\nt\3u\3u\3u\3v\3v\3v\5v\u068e\nv\3w\3w\3w\5w\u0693\nw\3x\3x\3x\3x\3y"+ "\3y\3y\7y\u069c\ny\fy\16y\u069f\13y\3z\7z\u06a2\nz\fz\16z\u06a5\13z\3"+ "z\3z\5z\u06a9\nz\3z\7z\u06ac\nz\fz\16z\u06af\13z\3z\3z\7z\u06b3\nz\fz"+ "\16z\u06b6\13z\3{\3{\3|\3|\3|\3|\7|\u06be\n|\f|\16|\u06c1\13|\3|\3|\3"+ "}\3}\3}\5}\u06c8\n}\3}\3}\5}\u06cc\n}\5}\u06ce\n}\3~\3~\3~\3~\3~\5~\u06d5"+ "\n~\3\177\3\177\5\177\u06d9\n\177\3\177\3\177\3\177\2\4\u00c8\u00d8\u0080"+ "\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\2\21\4\2\23\23**\3\2"+ "EH\3\2IJ\4\2((>>\4\2\65C\u0082\u0082\5\2\65>AC\u0082\u0082\4\2\\]fi\4"+ "\2jkoo\3\2hi\4\2Z[ab\4\2``cc\4\2YYpz\3\2fg\4\2__{{\n\2\5\5\7\7\n\n\20"+ "\20\26\26\35\35\37\37\'\'\2\u07a1\2\u0112\3\2\2\2\4\u0117\3\2\2\2\6\u011e"+ "\3\2\2\2\b\u012c\3\2\2\2\n\u013b\3\2\2\2\f\u0147\3\2\2\2\16\u014b\3\2"+ "\2\2\20\u014d\3\2\2\2\22\u0160\3\2\2\2\24\u016e\3\2\2\2\26\u017c\3\2\2"+ "\2\30\u0184\3\2\2\2\32\u0196\3\2\2\2\34\u01a1\3\2\2\2\36\u01ab\3\2\2\2"+ " \u01b2\3\2\2\2\"\u01c1\3\2\2\2$\u01ca\3\2\2\2&\u01df\3\2\2\2(\u01eb\3"+ "\2\2\2*\u01ed\3\2\2\2,\u01ff\3\2\2\2.\u0203\3\2\2\2\60\u0205\3\2\2\2\62"+ "\u0208\3\2\2\2\64\u020b\3\2\2\2\66\u0216\3\2\2\28\u021c\3\2\2\2:\u0228"+ "\3\2\2\2<\u0232\3\2\2\2>\u0234\3\2\2\2@\u023f\3\2\2\2B\u024d\3\2\2\2D"+ "\u0258\3\2\2\2F\u025d\3\2\2\2H\u0266\3\2\2\2J\u0279\3\2\2\2L\u0281\3\2"+ "\2\2N\u0286\3\2\2\2P\u0290\3\2\2\2R\u0292\3\2\2\2T\u02aa\3\2\2\2V\u02bd"+ "\3\2\2\2X\u02bf\3\2\2\2Z\u02c7\3\2\2\2\\\u02d7\3\2\2\2^\u02ef\3\2\2\2"+ "`\u02f4\3\2\2\2b\u02fd\3\2\2\2d\u030a\3\2\2\2f\u0315\3\2\2\2h\u031b\3"+ "\2\2\2j\u032a\3\2\2\2l\u032c\3\2\2\2n\u032e\3\2\2\2p\u0335\3\2\2\2r\u033e"+ "\3\2\2\2t\u0348\3\2\2\2v\u0350\3\2\2\2x\u0357\3\2\2\2z\u0359\3\2\2\2|"+ "\u0369\3\2\2\2~\u036e\3\2\2\2\u0080\u037f\3\2\2\2\u0082\u0399\3\2\2\2"+ "\u0084\u039d\3\2\2\2\u0086\u039f\3\2\2\2\u0088\u03a5\3\2\2\2\u008a\u03a7"+ "\3\2\2\2\u008c\u03ab\3\2\2\2\u008e\u03b1\3\2\2\2\u0090\u03de\3\2\2\2\u0092"+ "\u03e0\3\2\2\2\u0094\u03e2\3\2\2\2\u0096\u03ee\3\2\2\2\u0098\u03f4\3\2"+ "\2\2\u009a\u03fc\3\2\2\2\u009c\u03ff\3\2\2\2\u009e\u0409\3\2\2\2\u00a0"+ "\u0417\3\2\2\2\u00a2\u041c\3\2\2\2\u00a4\u0429\3\2\2\2\u00a6\u042b\3\2"+ "\2\2\u00a8\u0430\3\2\2\2\u00aa\u04a9\3\2\2\2\u00ac\u04ab\3\2\2\2\u00ae"+ "\u04b8\3\2\2\2\u00b0\u04c0\3\2\2\2\u00b2\u04c3\3\2\2\2\u00b4\u04ca\3\2"+ "\2\2\u00b6\u04e3\3\2\2\2\u00b8\u04e6\3\2\2\2\u00ba\u04fa\3\2\2\2\u00bc"+ "\u0508\3\2\2\2\u00be\u050c\3\2\2\2\u00c0\u0511\3\2\2\2\u00c2\u051c\3\2"+ "\2\2\u00c4\u0520\3\2\2\2\u00c6\u052b\3\2\2\2\u00c8\u055a\3\2\2\2\u00ca"+ "\u05b5\3\2\2\2\u00cc\u05c1\3\2\2\2\u00ce\u05db\3\2\2\2\u00d0\u05df\3\2"+ "\2\2\u00d2\u05f3\3\2\2\2\u00d4\u05f5\3\2\2\2\u00d6\u060b\3\2\2\2\u00d8"+ "\u0627\3\2\2\2\u00da\u0638\3\2\2\2\u00dc\u063d\3\2\2\2\u00de\u0652\3\2"+ "\2\2\u00e0\u0663\3\2\2\2\u00e2\u0665\3\2\2\2\u00e4\u0681\3\2\2\2\u00e6"+ "\u0683\3\2\2\2\u00e8\u0687\3\2\2\2\u00ea\u068d\3\2\2\2\u00ec\u0692\3\2"+ "\2\2\u00ee\u0694\3\2\2\2\u00f0\u0698\3\2\2\2\u00f2\u06a3\3\2\2\2\u00f4"+ "\u06b7\3\2\2\2\u00f6\u06b9\3\2\2\2\u00f8\u06cd\3\2\2\2\u00fa\u06d4\3\2"+ "\2\2\u00fc\u06d6\3\2\2\2\u00fe\u0100\5\4\3\2\u00ff\u00fe\3\2\2\2\u00ff"+ "\u0100\3\2\2\2\u0100\u0105\3\2\2\2\u0101\u0104\5\6\4\2\u0102\u0104\7V"+ "\2\2\u0103\u0101\3\2\2\2\u0103\u0102\3\2\2\2\u0104\u0107\3\2\2\2\u0105"+ "\u0103\3\2\2\2\u0105\u0106\3\2\2\2\u0106\u010c\3\2\2\2\u0107\u0105\3\2"+ "\2\2\u0108\u010b\5\b\5\2\u0109\u010b\7V\2\2\u010a\u0108\3\2\2\2\u010a"+ "\u0109\3\2\2\2\u010b\u010e\3\2\2\2\u010c\u010a\3\2\2\2\u010c\u010d\3\2"+ "\2\2\u010d\u0113\3\2\2\2\u010e\u010c\3\2\2\2\u010f\u0110\5\u008cG\2\u0110"+ "\u0111\7\2\2\3\u0111\u0113\3\2\2\2\u0112\u00ff\3\2\2\2\u0112\u010f\3\2"+ "\2\2\u0113\3\3\2\2\2\u0114\u0116\5r:\2\u0115\u0114\3\2\2\2\u0116\u0119"+ "\3\2\2\2\u0117\u0115\3\2\2\2\u0117\u0118\3\2\2\2\u0118\u011a\3\2\2\2\u0119"+ "\u0117\3\2\2\2\u011a\u011b\7\"\2\2\u011b\u011c\5h\65\2\u011c\u011d\7V"+ "\2\2\u011d\5\3\2\2\2\u011e\u0120\7\33\2\2\u011f\u0121\7(\2\2\u0120\u011f"+ "\3\2\2\2\u0120\u0121\3\2\2\2\u0121\u0122\3\2\2\2\u0122\u0125\5h\65\2\u0123"+ "\u0124\7X\2\2\u0124\u0126\7j\2\2\u0125\u0123\3\2\2\2\u0125\u0126\3\2\2"+ "\2\u0126\u0127\3\2\2\2\u0127\u0128\7V\2\2\u0128\7\3\2\2\2\u0129\u012b"+ "\5\f\7\2\u012a\u0129\3\2\2\2\u012b\u012e\3\2\2\2\u012c\u012a\3\2\2\2\u012c"+ "\u012d\3\2\2\2\u012d\u0134\3\2\2\2\u012e\u012c\3\2\2\2\u012f\u0135\5\20"+ "\t\2\u0130\u0135\5\30\r\2\u0131\u0135\5 \21\2\u0132\u0135\5|?\2\u0133"+ "\u0135\5\u0094K\2\u0134\u012f\3\2\2\2\u0134\u0130\3\2\2\2\u0134\u0131"+ "\3\2\2\2\u0134\u0132\3\2\2\2\u0134\u0133\3\2\2\2\u0135\t\3\2\2\2\u0136"+ "\u013c\5\f\7\2\u0137\u013c\7 \2\2\u0138\u013c\7,\2\2\u0139\u013c\7\60"+ "\2\2\u013a\u013c\7\63\2\2\u013b\u0136\3\2\2\2\u013b\u0137\3\2\2\2\u013b"+ "\u0138\3\2\2\2\u013b\u0139\3\2\2\2\u013b\u013a\3\2\2\2\u013c\13\3\2\2"+ "\2\u013d\u0148\5r:\2\u013e\u0148\7%\2\2\u013f\u0148\7$\2\2\u0140\u0148"+ "\7#\2\2\u0141\u0148\7(\2\2\u0142\u0148\7\3\2\2\u0143\u0148\7\24\2\2\u0144"+ "\u0148\7)\2\2\u0145\u0148\7B\2\2\u0146\u0148\7D\2\2\u0147\u013d\3\2\2"+ "\2\u0147\u013e\3\2\2\2\u0147\u013f\3\2\2\2\u0147\u0140\3\2\2\2\u0147\u0141"+ "\3\2\2\2\u0147\u0142\3\2\2\2\u0147\u0143\3\2\2\2\u0147\u0144\3\2\2\2\u0147"+ "\u0145\3\2\2\2\u0147\u0146\3\2\2\2\u0148\r\3\2\2\2\u0149\u014c\7\24\2"+ "\2\u014a\u014c\5r:\2\u014b\u0149\3\2\2\2\u014b\u014a\3\2\2\2\u014c\17"+ "\3\2\2\2\u014d\u014e\7\13\2\2\u014e\u0150\5\u00a4S\2\u014f\u0151\5\22"+ "\n\2\u0150\u014f\3\2\2\2\u0150\u0151\3\2\2\2\u0151\u0154\3\2\2\2\u0152"+ "\u0153\7\23\2\2\u0153\u0155\5\u00f2z\2\u0154\u0152\3\2\2\2\u0154\u0155"+ "\3\2\2\2\u0155\u0158\3\2\2\2\u0156\u0157\7\32\2\2\u0157\u0159\5\u00f0"+ "y\2\u0158\u0156\3\2\2\2\u0158\u0159\3\2\2\2\u0159\u015c\3\2\2\2\u015a"+ "\u015b\7C\2\2\u015b\u015d\5\u00f0y\2\u015c\u015a\3\2\2\2\u015c\u015d\3"+ "\2\2\2\u015d\u015e\3\2\2\2\u015e\u015f\5\"\22\2\u015f\21\3\2\2\2\u0160"+ "\u0161\7[\2\2\u0161\u0166\5\24\13\2\u0162\u0163\7W\2\2\u0163\u0165\5\24"+ "\13\2\u0164\u0162\3\2\2\2\u0165\u0168\3\2\2\2\u0166\u0164\3\2\2\2\u0166"+ "\u0167\3\2\2\2\u0167\u0169\3\2\2\2\u0168\u0166\3\2\2\2\u0169\u016a\7Z"+ "\2\2\u016a\23\3\2\2\2\u016b\u016d\5r:\2\u016c\u016b\3\2\2\2\u016d\u0170"+ "\3\2\2\2\u016e\u016c\3\2\2\2\u016e\u016f\3\2\2\2\u016f\u0171\3\2\2\2\u0170"+ "\u016e\3\2\2\2\u0171\u017a\5\u00a4S\2\u0172\u0176\7\23\2\2\u0173\u0175"+ "\5r:\2\u0174\u0173\3\2\2\2\u0175\u0178\3\2\2\2\u0176\u0174\3\2\2\2\u0176"+ "\u0177\3\2\2\2\u0177\u0179\3\2\2\2\u0178\u0176\3\2\2\2\u0179\u017b\5\26"+ "\f\2\u017a\u0172\3\2\2\2\u017a\u017b\3\2\2\2\u017b\25\3\2\2\2\u017c\u0181"+ "\5\u00f2z\2\u017d\u017e\7l\2\2\u017e\u0180\5\u00f2z\2\u017f\u017d\3\2"+ "\2\2\u0180\u0183\3\2\2\2\u0181\u017f\3\2\2\2\u0181\u0182\3\2\2\2\u0182"+ "\27\3\2\2\2\u0183\u0181\3\2\2\2\u0184\u0185\7\22\2\2\u0185\u0188\5\u00a4"+ "S\2\u0186\u0187\7\32\2\2\u0187\u0189\5\u00f0y\2\u0188\u0186\3\2\2\2\u0188"+ "\u0189\3\2\2\2\u0189\u018a\3\2\2\2\u018a\u018c\7R\2\2\u018b\u018d\5\32"+ "\16\2\u018c\u018b\3\2\2\2\u018c\u018d\3\2\2\2\u018d\u018f\3\2\2\2\u018e"+ "\u0190\7W\2\2\u018f\u018e\3\2\2\2\u018f\u0190\3\2\2\2\u0190\u0192\3\2"+ "\2\2\u0191\u0193\5\36\20\2\u0192\u0191\3\2\2\2\u0192\u0193\3\2\2\2\u0193"+ "\u0194\3\2\2\2\u0194\u0195\7S\2\2\u0195\31\3\2\2\2\u0196\u019b\5\34\17"+ "\2\u0197\u0198\7W\2\2\u0198\u019a\5\34\17\2\u0199\u0197\3\2\2\2\u019a"+ "\u019d\3\2\2\2\u019b\u0199\3\2\2\2\u019b\u019c\3\2\2\2\u019c\33\3\2\2"+ "\2\u019d\u019b\3\2\2\2\u019e\u01a0\5r:\2\u019f\u019e\3\2\2\2\u01a0\u01a3"+ "\3\2\2\2\u01a1\u019f\3\2\2\2\u01a1\u01a2\3\2\2\2\u01a2\u01a4\3\2\2\2\u01a3"+ "\u01a1\3\2\2\2\u01a4\u01a6\5\u00a4S\2\u01a5\u01a7\5\u00fc\177\2\u01a6"+ "\u01a5\3\2\2\2\u01a6\u01a7\3\2\2\2\u01a7\u01a9\3\2\2\2\u01a8\u01aa\5\""+ "\22\2\u01a9\u01a8\3\2\2\2\u01a9\u01aa\3\2\2\2\u01aa\35\3\2\2\2\u01ab\u01af"+ "\7V\2\2\u01ac\u01ae\5&\24\2\u01ad\u01ac\3\2\2\2\u01ae\u01b1\3\2\2\2\u01af"+ "\u01ad\3\2\2\2\u01af\u01b0\3\2\2\2\u01b0\37\3\2\2\2\u01b1\u01af\3\2\2"+ "\2\u01b2\u01b3\7\36\2\2\u01b3\u01b5\5\u00a4S\2\u01b4\u01b6\5\22\n\2\u01b5"+ "\u01b4\3\2\2\2\u01b5\u01b6\3\2\2\2\u01b6\u01b9\3\2\2\2\u01b7\u01b8\7\23"+ "\2\2\u01b8\u01ba\5\u00f0y\2\u01b9\u01b7\3\2\2\2\u01b9\u01ba\3\2\2\2\u01ba"+ "\u01bd\3\2\2\2\u01bb\u01bc\7C\2\2\u01bc\u01be\5\u00f0y\2\u01bd\u01bb\3"+ "\2\2\2\u01bd\u01be\3\2\2\2\u01be\u01bf\3\2\2\2\u01bf\u01c0\5$\23\2\u01c0"+ "!\3\2\2\2\u01c1\u01c5\7R\2\2\u01c2\u01c4\5&\24\2\u01c3\u01c2\3\2\2\2\u01c4"+ "\u01c7\3\2\2\2\u01c5\u01c3\3\2\2\2\u01c5\u01c6\3\2\2\2\u01c6\u01c8\3\2"+ "\2\2\u01c7\u01c5\3\2\2\2\u01c8\u01c9\7S\2\2\u01c9#\3\2\2\2\u01ca\u01ce"+ "\7R\2\2\u01cb\u01cd\5:\36\2\u01cc\u01cb\3\2\2\2\u01cd\u01d0\3\2\2\2\u01ce"+ "\u01cc\3\2\2\2\u01ce\u01cf\3\2\2\2\u01cf\u01d1\3\2\2\2\u01d0\u01ce\3\2"+ "\2\2\u01d1\u01d2\7S\2\2\u01d2%\3\2\2\2\u01d3\u01e0\7V\2\2\u01d4\u01d6"+ "\7(\2\2\u01d5\u01d4\3\2\2\2\u01d5\u01d6\3\2\2\2\u01d6\u01d7\3\2\2\2\u01d7"+ "\u01e0\5\u009eP\2\u01d8\u01da\5\n\6\2\u01d9\u01d8\3\2\2\2\u01da\u01dd"+ "\3\2\2\2\u01db\u01d9\3\2\2\2\u01db\u01dc\3\2\2\2\u01dc\u01de\3\2\2\2\u01dd"+ "\u01db\3\2\2\2\u01de\u01e0\5(\25\2\u01df\u01d3\3\2\2\2\u01df\u01d5\3\2"+ "\2\2\u01df\u01db\3\2\2\2\u01e0\'\3\2\2\2\u01e1\u01ec\5\u0094K\2\u01e2"+ "\u01ec\5*\26\2\u01e3\u01ec\5\60\31\2\u01e4\u01ec\58\35\2\u01e5\u01ec\5"+ "\64\33\2\u01e6\u01ec\5\62\32\2\u01e7\u01ec\5 \21\2\u01e8\u01ec\5|?\2\u01e9"+ "\u01ec\5\20\t\2\u01ea\u01ec\5\30\r\2\u01eb\u01e1\3\2\2\2\u01eb\u01e2\3"+ "\2\2\2\u01eb\u01e3\3\2\2\2\u01eb\u01e4\3\2\2\2\u01eb\u01e5\3\2\2\2\u01eb"+ "\u01e6\3\2\2\2\u01eb\u01e7\3\2\2\2\u01eb\u01e8\3\2\2\2\u01eb\u01e9\3\2"+ "\2\2\u01eb\u01ea\3\2\2\2\u01ec)\3\2\2\2\u01ed\u01ee\5.\30\2\u01ee\u01ef"+ "\5\u00a4S\2\u01ef\u01f4\5Z.\2\u01f0\u01f1\7T\2\2\u01f1\u01f3\7U\2\2\u01f2"+ "\u01f0\3\2\2\2\u01f3\u01f6\3\2\2\2\u01f4\u01f2\3\2\2\2\u01f4\u01f5\3\2"+ "\2\2\u01f5\u01f9\3\2\2\2\u01f6\u01f4\3\2\2\2\u01f7\u01f8\7/\2\2\u01f8"+ "\u01fa\5X-\2\u01f9\u01f7\3\2\2\2\u01f9\u01fa\3\2\2\2\u01fa\u01fb\3\2\2"+ "\2\u01fb\u01fc\5,\27\2\u01fc+\3\2\2\2\u01fd\u0200\5\u009eP\2\u01fe\u0200"+ "\7V\2\2\u01ff\u01fd\3\2\2\2\u01ff\u01fe\3\2\2\2\u0200-\3\2\2\2\u0201\u0204"+ "\5\u00f2z\2\u0202\u0204\7\62\2\2\u0203\u0201\3\2\2\2\u0203\u0202\3\2\2"+ "\2\u0204/\3\2\2\2\u0205\u0206\5\22\n\2\u0206\u0207\5*\26\2\u0207\61\3"+ "\2\2\2\u0208\u0209\5\22\n\2\u0209\u020a\5\64\33\2\u020a\63\3\2\2\2\u020b"+ "\u020c\5\u00a4S\2\u020c\u020f\5Z.\2\u020d\u020e\7/\2\2\u020e\u0210\5X"+ "-\2\u020f\u020d\3\2\2\2\u020f\u0210\3\2\2\2\u0210\u0211\3\2\2\2\u0211"+ "\u0212\5\u009eP\2\u0212\65\3\2\2\2\u0213\u0215\5\n\6\2\u0214\u0213\3\2"+ "\2\2\u0215\u0218\3\2\2\2\u0216\u0214\3\2\2\2\u0216\u0217\3\2\2\2\u0217"+ "\u0219\3\2\2\2\u0218\u0216\3\2\2\2\u0219\u021a\5\u00a4S\2\u021a\u021b"+ "\5\u009eP\2\u021b\67\3\2\2\2\u021c\u021d\5\u00f2z\2\u021d\u021e\5J&\2"+ "\u021e\u021f\7V\2\2\u021f9\3\2\2\2\u0220\u0222\5\n\6\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\u0229\5<\37\2\u0227\u0229\7V"+ "\2\2\u0228\u0223\3\2\2\2\u0228\u0227\3\2\2\2\u0229;\3\2\2\2\u022a\u0233"+ "\5\u0094K\2\u022b\u0233\5> \2\u022c\u0233\5B\"\2\u022d\u0233\5F$\2\u022e"+ "\u0233\5 \21\2\u022f\u0233\5|?\2\u0230\u0233\5\20\t\2\u0231\u0233\5\30"+ "\r\2\u0232\u022a\3\2\2\2\u0232\u022b\3\2\2\2\u0232\u022c\3\2\2\2\u0232"+ "\u022d\3\2\2\2\u0232\u022e\3\2\2\2\u0232\u022f\3\2\2\2\u0232\u0230\3\2"+ "\2\2\u0232\u0231\3\2\2\2\u0233=\3\2\2\2\u0234\u0235\5\u00f2z\2\u0235\u023a"+ "\5@!\2\u0236\u0237\7W\2\2\u0237\u0239\5@!\2\u0238\u0236\3\2\2\2\u0239"+ "\u023c\3\2\2\2\u023a\u0238\3\2\2\2\u023a\u023b\3\2\2\2\u023b\u023d\3\2"+ "\2\2\u023c\u023a\3\2\2\2\u023d\u023e\7V\2\2\u023e?\3\2\2\2\u023f\u0244"+ "\5\u00a4S\2\u0240\u0241\7T\2\2\u0241\u0243\7U\2\2\u0242\u0240\3\2\2\2"+ "\u0243\u0246\3\2\2\2\u0244\u0242\3\2\2\2\u0244\u0245\3\2\2\2\u0245\u0247"+ "\3\2\2\2\u0246\u0244\3\2\2\2\u0247\u0248\7Y\2\2\u0248\u0249\5P)\2\u0249"+ "A\3\2\2\2\u024a\u024c\5D#\2\u024b\u024a\3\2\2\2\u024c\u024f\3\2\2\2\u024d"+ "\u024b\3\2\2\2\u024d\u024e\3\2\2\2\u024e\u0250\3\2\2\2\u024f\u024d\3\2"+ "\2\2\u0250\u0251\5H%\2\u0251C\3\2\2\2\u0252\u0259\5r:\2\u0253\u0259\7"+ "%\2\2\u0254\u0259\7\3\2\2\u0255\u0259\7\16\2\2\u0256\u0259\7(\2\2\u0257"+ "\u0259\7)\2\2\u0258\u0252\3\2\2\2\u0258\u0253\3\2\2\2\u0258\u0254\3\2"+ "\2\2\u0258\u0255\3\2\2\2\u0258\u0256\3\2\2\2\u0258\u0257\3\2\2\2\u0259"+ "E\3\2\2\2\u025a\u025c\5D#\2\u025b\u025a\3\2\2\2\u025c\u025f\3\2\2\2\u025d"+ "\u025b\3\2\2\2\u025d\u025e\3\2\2\2\u025e\u0260\3\2\2\2\u025f\u025d\3\2"+ "\2\2\u0260\u0261\5\22\n\2\u0261\u0262\5H%\2\u0262G\3\2\2\2\u0263\u0265"+ "\5r:\2\u0264\u0263\3\2\2\2\u0265\u0268\3\2\2\2\u0266\u0264\3\2\2\2\u0266"+ "\u0267\3\2\2\2\u0267\u0269\3\2\2\2\u0268\u0266\3\2\2\2\u0269\u026a\5."+ "\30\2\u026a\u026b\5\u00a4S\2\u026b\u0270\5Z.\2\u026c\u026d\7T\2\2\u026d"+ "\u026f\7U\2\2\u026e\u026c\3\2\2\2\u026f\u0272\3\2\2\2\u0270\u026e\3\2"+ "\2\2\u0270\u0271\3\2\2\2\u0271\u0275\3\2\2\2\u0272\u0270\3\2\2\2\u0273"+ "\u0274\7/\2\2\u0274\u0276\5X-\2\u0275\u0273\3\2\2\2\u0275\u0276\3\2\2"+ "\2\u0276\u0277\3\2\2\2\u0277\u0278\5,\27\2\u0278I\3\2\2\2\u0279\u027e"+ "\5L\'\2\u027a\u027b\7W\2\2\u027b\u027d\5L\'\2\u027c\u027a\3\2\2\2\u027d"+ "\u0280\3\2\2\2\u027e\u027c\3\2\2\2\u027e\u027f\3\2\2\2\u027fK\3\2\2\2"+ "\u0280\u027e\3\2\2\2\u0281\u0284\5N(\2\u0282\u0283\7Y\2\2\u0283\u0285"+ "\5P)\2\u0284\u0282\3\2\2\2\u0284\u0285\3\2\2\2\u0285M\3\2\2\2\u0286\u028b"+ "\5\u00a4S\2\u0287\u0288\7T\2\2\u0288\u028a\7U\2\2\u0289\u0287\3\2\2\2"+ "\u028a\u028d\3\2\2\2\u028b\u0289\3\2\2\2\u028b\u028c\3\2\2\2\u028cO\3"+ "\2\2\2\u028d\u028b\3\2\2\2\u028e\u0291\5R*\2\u028f\u0291\5\u00c8e\2\u0290"+ "\u028e\3\2\2\2\u0290\u028f\3\2\2\2\u0291Q\3\2\2\2\u0292\u029e\7R\2\2\u0293"+ "\u0298\5P)\2\u0294\u0295\7W\2\2\u0295\u0297\5P)\2\u0296\u0294\3\2\2\2"+ "\u0297\u029a\3\2\2\2\u0298\u0296\3\2\2\2\u0298\u0299\3\2\2\2\u0299\u029c"+ "\3\2\2\2\u029a\u0298\3\2\2\2\u029b\u029d\7W\2\2\u029c\u029b\3\2\2\2\u029c"+ "\u029d\3\2\2\2\u029d\u029f\3\2\2\2\u029e\u0293\3\2\2\2\u029e\u029f\3\2"+ "\2\2\u029f\u02a0\3\2\2\2\u02a0\u02a1\7S\2\2\u02a1S\3\2\2\2\u02a2\u02a4"+ "\5\u00a4S\2\u02a3\u02a5\5\u00f6|\2\u02a4\u02a3\3\2\2\2\u02a4\u02a5\3\2"+ "\2\2\u02a5\u02a6\3\2\2\2\u02a6\u02a7\7X\2\2\u02a7\u02a9\3\2\2\2\u02a8"+ "\u02a2\3\2\2\2\u02a9\u02ac\3\2\2\2\u02aa\u02a8\3\2\2\2\u02aa\u02ab\3\2"+ "\2\2\u02ab\u02ad\3\2\2\2\u02ac\u02aa\3\2\2\2\u02ad\u02af\5\u00a6T\2\u02ae"+ "\u02b0\5\u00f6|\2\u02af\u02ae\3\2\2\2\u02af\u02b0\3\2\2\2\u02b0U\3\2\2"+ "\2\u02b1\u02be\5\u00f2z\2\u02b2\u02b4\5r:\2\u02b3\u02b2\3\2\2\2\u02b4"+ "\u02b7\3\2\2\2\u02b5\u02b3\3\2\2\2\u02b5\u02b6\3\2\2\2\u02b6\u02b8\3\2"+ "\2\2\u02b7\u02b5\3\2\2\2\u02b8\u02bb\7^\2\2\u02b9\u02ba\t\2\2\2\u02ba"+ "\u02bc\5\u00f2z\2\u02bb\u02b9\3\2\2\2\u02bb\u02bc\3\2\2\2\u02bc\u02be"+ "\3\2\2\2\u02bd\u02b1\3\2\2\2\u02bd\u02b5\3\2\2\2\u02beW\3\2\2\2\u02bf"+ "\u02c4\5h\65\2\u02c0\u02c1\7W\2\2\u02c1\u02c3\5h\65\2\u02c2\u02c0\3\2"+ "\2\2\u02c3\u02c6\3\2\2\2\u02c4\u02c2\3\2\2\2\u02c4\u02c5\3\2\2\2\u02c5"+ "Y\3\2\2\2\u02c6\u02c4\3\2\2\2\u02c7\u02d3\7P\2\2\u02c8\u02ca\5\\/\2\u02c9"+ "\u02c8\3\2\2\2\u02c9\u02ca\3\2\2\2\u02ca\u02d4\3\2\2\2\u02cb\u02ce\5\\"+ "/\2\u02cc\u02cd\7W\2\2\u02cd\u02cf\5^\60\2\u02ce\u02cc\3\2\2\2\u02ce\u02cf"+ "\3\2\2\2\u02cf\u02d4\3\2\2\2\u02d0\u02d2\5^\60\2\u02d1\u02d0\3\2\2\2\u02d1"+ "\u02d2\3\2\2\2\u02d2\u02d4\3\2\2\2\u02d3\u02c9\3\2\2\2\u02d3\u02cb\3\2"+ "\2\2\u02d3\u02d1\3\2\2\2\u02d4\u02d5\3\2\2\2\u02d5\u02d6\7Q\2\2\u02d6"+ "[\3\2\2\2\u02d7\u02dd\5\u00f2z\2\u02d8\u02d9\5\u00a4S\2\u02d9\u02da\7"+ "X\2\2\u02da\u02dc\3\2\2\2\u02db\u02d8\3\2\2\2\u02dc\u02df\3\2\2\2\u02dd"+ "\u02db\3\2\2\2\u02dd\u02de\3\2\2\2\u02de\u02e0\3\2\2\2\u02df\u02dd\3\2"+ "\2\2\u02e0\u02e1\7-\2\2\u02e1]\3\2\2\2\u02e2\u02e7\5`\61\2\u02e3\u02e4"+ "\7W\2\2\u02e4\u02e6\5`\61\2\u02e5\u02e3\3\2\2\2\u02e6\u02e9\3\2\2\2\u02e7"+ "\u02e5\3\2\2\2\u02e7\u02e8\3\2\2\2\u02e8\u02ec\3\2\2\2\u02e9\u02e7\3\2"+ "\2\2\u02ea\u02eb\7W\2\2\u02eb\u02ed\5b\62\2\u02ec\u02ea\3\2\2\2\u02ec"+ "\u02ed\3\2\2\2\u02ed\u02f0\3\2\2\2\u02ee\u02f0\5b\62\2\u02ef\u02e2\3\2"+ "\2\2\u02ef\u02ee\3\2\2\2\u02f0_\3\2\2\2\u02f1\u02f3\5\16\b\2\u02f2\u02f1"+ "\3\2\2\2\u02f3\u02f6\3\2\2\2\u02f4\u02f2\3\2\2\2\u02f4\u02f5\3\2\2\2\u02f5"+ "\u02f7\3\2\2\2\u02f6\u02f4\3\2\2\2\u02f7\u02f8\5\u00f2z\2\u02f8\u02f9"+ "\5N(\2\u02f9a\3\2\2\2\u02fa\u02fc\5\16\b\2\u02fb\u02fa\3\2\2\2\u02fc\u02ff"+ "\3\2\2\2\u02fd\u02fb\3\2\2\2\u02fd\u02fe\3\2\2\2\u02fe\u0300\3\2\2\2\u02ff"+ "\u02fd\3\2\2\2\u0300\u0304\5\u00f2z\2\u0301\u0303\5r:\2\u0302\u0301\3"+ "\2\2\2\u0303\u0306\3\2\2\2\u0304\u0302\3\2\2\2\u0304\u0305\3\2\2\2\u0305"+ "\u0307\3\2\2\2\u0306\u0304\3\2\2\2\u0307\u0308\7~\2\2\u0308\u0309\5N("+ "\2\u0309c\3\2\2\2\u030a\u030f\5f\64\2\u030b\u030c\7W\2\2\u030c\u030e\5"+ "f\64\2\u030d\u030b\3\2\2\2\u030e\u0311\3\2\2\2\u030f\u030d\3\2\2\2\u030f"+ "\u0310\3\2\2\2\u0310e\3\2\2\2\u0311\u030f\3\2\2\2\u0312\u0314\5\16\b\2"+ "\u0313\u0312\3\2\2\2\u0314\u0317\3\2\2\2\u0315\u0313\3\2\2\2\u0315\u0316"+ "\3\2\2\2\u0316\u0318\3\2\2\2\u0317\u0315\3\2\2\2\u0318\u0319\7?\2\2\u0319"+ "\u031a\5\u00a4S\2\u031ag\3\2\2\2\u031b\u0320\5\u00a4S\2\u031c\u031d\7"+ "X\2\2\u031d\u031f\5\u00a4S\2\u031e\u031c\3\2\2\2\u031f\u0322\3\2\2\2\u0320"+ "\u031e\3\2\2\2\u0320\u0321\3\2\2\2\u0321i\3\2\2\2\u0322\u0320\3\2\2\2"+ "\u0323\u032b\5l\67\2\u0324\u032b\5n8\2\u0325\u032b\7L\2\2\u0326\u032b"+ "\7M\2\2\u0327\u032b\7K\2\2\u0328\u032b\7O\2\2\u0329\u032b\7N\2\2\u032a"+ "\u0323\3\2\2\2\u032a\u0324\3\2\2\2\u032a\u0325\3\2\2\2\u032a\u0326\3\2"+ "\2\2\u032a\u0327\3\2\2\2\u032a\u0328\3\2\2\2\u032a\u0329\3\2\2\2\u032b"+ "k\3\2\2\2\u032c\u032d\t\3\2\2\u032dm\3\2\2\2\u032e\u032f\t\4\2\2\u032f"+ "o\3\2\2\2\u0330\u0331\5\u00a4S\2\u0331\u0332\7X\2\2\u0332\u0334\3\2\2"+ "\2\u0333\u0330\3\2\2\2\u0334\u0337\3\2\2\2\u0335\u0333\3\2\2\2\u0335\u0336"+ "\3\2\2\2\u0336\u0338\3\2\2\2\u0337\u0335\3\2\2\2\u0338\u0339\7}\2\2\u0339"+ "\u033a\5\u00a4S\2\u033aq\3\2\2\2\u033b\u033c\7}\2\2\u033c\u033f\5h\65"+ "\2\u033d\u033f\5p9\2\u033e\u033b\3\2\2\2\u033e\u033d\3\2\2\2\u033f\u0346"+ "\3\2\2\2\u0340\u0343\7P\2\2\u0341\u0344\5t;\2\u0342\u0344\5x=\2\u0343"+ "\u0341\3\2\2\2\u0343\u0342\3\2\2\2\u0343\u0344\3\2\2\2\u0344\u0345\3\2"+ "\2\2\u0345\u0347\7Q\2\2\u0346\u0340\3\2\2\2\u0346\u0347\3\2\2\2\u0347"+ "s\3\2\2\2\u0348\u034d\5v<\2\u0349\u034a\7W\2\2\u034a\u034c\5v<\2\u034b"+ "\u0349\3\2\2\2\u034c\u034f\3\2\2\2\u034d\u034b\3\2\2\2\u034d\u034e\3\2"+ "\2\2\u034eu\3\2\2\2\u034f\u034d\3\2\2\2\u0350\u0351\5\u00a4S\2\u0351\u0352"+ "\7Y\2\2\u0352\u0353\5x=\2\u0353w\3\2\2\2\u0354\u0358\5\u00c8e\2\u0355"+ "\u0358\5r:\2\u0356\u0358\5z>\2\u0357\u0354\3\2\2\2\u0357\u0355\3\2\2\2"+ "\u0357\u0356\3\2\2\2\u0358y\3\2\2\2\u0359\u0362\7R\2\2\u035a\u035f\5x"+ "=\2\u035b\u035c\7W\2\2\u035c\u035e\5x=\2\u035d\u035b\3\2\2\2\u035e\u0361"+ "\3\2\2\2\u035f\u035d\3\2\2\2\u035f\u0360\3\2\2\2\u0360\u0363\3\2\2\2\u0361"+ "\u035f\3\2\2\2\u0362\u035a\3\2\2\2\u0362\u0363\3\2\2\2\u0363\u0365\3\2"+ "\2\2\u0364\u0366\7W\2\2\u0365\u0364\3\2\2\2\u0365\u0366\3\2\2\2\u0366"+ "\u0367\3\2\2\2\u0367\u0368\7S\2\2\u0368{\3\2\2\2\u0369\u036a\7}\2\2\u036a"+ "\u036b\7\36\2\2\u036b\u036c\5\u00a4S\2\u036c\u036d\5~@\2\u036d}\3\2\2"+ "\2\u036e\u0372\7R\2\2\u036f\u0371\5\u0080A\2\u0370\u036f\3\2\2\2\u0371"+ "\u0374\3\2\2\2\u0372\u0370\3\2\2\2\u0372\u0373\3\2\2\2\u0373\u0375\3\2"+ "\2\2\u0374\u0372\3\2\2\2\u0375\u0376\7S\2\2\u0376\177\3\2\2\2\u0377\u0379"+ "\5\n\6\2\u0378\u0377\3\2\2\2\u0379\u037c\3\2\2\2\u037a\u0378\3\2\2\2\u037a"+ "\u037b\3\2\2\2\u037b\u037d\3\2\2\2\u037c\u037a\3\2\2\2\u037d\u0380\5\u0082"+ "B\2\u037e\u0380\7V\2\2\u037f\u037a\3\2\2\2\u037f\u037e\3\2\2\2\u0380\u0081"+ "\3\2\2\2\u0381\u0382\5\u00f2z\2\u0382\u0383\5\u0084C\2\u0383\u0384\7V"+ "\2\2\u0384\u039a\3\2\2\2\u0385\u0387\5\20\t\2\u0386\u0388\7V\2\2\u0387"+ "\u0386\3\2\2\2\u0387\u0388\3\2\2\2\u0388\u039a\3\2\2\2\u0389\u038b\5 "+ "\21\2\u038a\u038c\7V\2\2\u038b\u038a\3\2\2\2\u038b\u038c\3\2\2\2\u038c"+ "\u039a\3\2\2\2\u038d\u038f\5\30\r\2\u038e\u0390\7V\2\2\u038f\u038e\3\2"+ "\2\2\u038f\u0390\3\2\2\2\u0390\u039a\3\2\2\2\u0391\u0393\5|?\2\u0392\u0394"+ "\7V\2\2\u0393\u0392\3\2\2\2\u0393\u0394\3\2\2\2\u0394\u039a\3\2\2\2\u0395"+ "\u0397\5\u0094K\2\u0396\u0398\7V\2\2\u0397\u0396\3\2\2\2\u0397\u0398\3"+ "\2\2\2\u0398\u039a\3\2\2\2\u0399\u0381\3\2\2\2\u0399\u0385\3\2\2\2\u0399"+ "\u0389\3\2\2\2\u0399\u038d\3\2\2\2\u0399\u0391\3\2\2\2\u0399\u0395\3\2"+ "\2\2\u039a\u0083\3\2\2\2\u039b\u039e\5\u0086D\2\u039c\u039e\5\u0088E\2"+ "\u039d\u039b\3\2\2\2\u039d\u039c\3\2\2\2\u039e\u0085\3\2\2\2\u039f\u03a0"+ "\5\u00a4S\2\u03a0\u03a1\7P\2\2\u03a1\u03a3\7Q\2\2\u03a2\u03a4\5\u008a"+ "F\2\u03a3\u03a2\3\2\2\2\u03a3\u03a4\3\2\2\2\u03a4\u0087\3\2\2\2\u03a5"+ "\u03a6\5J&\2\u03a6\u0089\3\2\2\2\u03a7\u03a8\7\16\2\2\u03a8\u03a9\5x="+ "\2\u03a9\u008b\3\2\2\2\u03aa\u03ac\7\66\2\2\u03ab\u03aa\3\2\2\2\u03ab"+ "\u03ac\3\2\2\2\u03ac\u03ad\3\2\2\2\u03ad\u03ae\7\65\2\2\u03ae\u03af\5"+ "h\65\2\u03af\u03b0\5\u008eH\2\u03b0\u008d\3\2\2\2\u03b1\u03b5\7R\2\2\u03b2"+ "\u03b4\5\u0090I\2\u03b3\u03b2\3\2\2\2\u03b4\u03b7\3\2\2\2\u03b5\u03b3"+ "\3\2\2\2\u03b5\u03b6\3\2\2\2\u03b6\u03b8\3\2\2\2\u03b7\u03b5\3\2\2\2\u03b8"+ "\u03b9\7S\2\2\u03b9\u008f\3\2\2\2\u03ba\u03be\7\67\2\2\u03bb\u03bd\5\u0092"+ "J\2\u03bc\u03bb\3\2\2\2\u03bd\u03c0\3\2\2\2\u03be\u03bc\3\2\2\2\u03be"+ "\u03bf\3\2\2\2\u03bf\u03c1\3\2\2\2\u03c0\u03be\3\2\2\2\u03c1\u03c2\5h"+ "\65\2\u03c2\u03c3\7V\2\2\u03c3\u03df\3\2\2\2\u03c4\u03c5\78\2\2\u03c5"+ "\u03c8\5h\65\2\u03c6\u03c7\7:\2\2\u03c7\u03c9\5h\65\2\u03c8\u03c6\3\2"+ "\2\2\u03c8\u03c9\3\2\2\2\u03c9\u03ca\3\2\2\2\u03ca\u03cb\7V\2\2\u03cb"+ "\u03df\3\2\2\2\u03cc\u03cd\79\2\2\u03cd\u03d0\5h\65\2\u03ce\u03cf\7:\2"+ "\2\u03cf\u03d1\5h\65\2\u03d0\u03ce\3\2\2\2\u03d0\u03d1\3\2\2\2\u03d1\u03d2"+ "\3\2\2\2\u03d2\u03d3\7V\2\2\u03d3\u03df\3\2\2\2\u03d4\u03d5\7;\2\2\u03d5"+ "\u03d6\5h\65\2\u03d6\u03d7\7V\2\2\u03d7\u03df\3\2\2\2\u03d8\u03d9\7<\2"+ "\2\u03d9\u03da\5h\65\2\u03da\u03db\7=\2\2\u03db\u03dc\5h\65\2\u03dc\u03dd"+ "\7V\2\2\u03dd\u03df\3\2\2\2\u03de\u03ba\3\2\2\2\u03de\u03c4\3\2\2\2\u03de"+ "\u03cc\3\2\2\2\u03de\u03d4\3\2\2\2\u03de\u03d8\3\2\2\2\u03df\u0091\3\2"+ "\2\2\u03e0\u03e1\t\5\2\2\u03e1\u0093\3\2\2\2\u03e2\u03e3\7A\2\2\u03e3"+ "\u03e5\5\u00a4S\2\u03e4\u03e6\5\22\n\2\u03e5\u03e4\3\2\2\2\u03e5\u03e6"+ "\3\2\2\2\u03e6\u03e7\3\2\2\2\u03e7\u03ea\5\u0096L\2\u03e8\u03e9\7\32\2"+ "\2\u03e9\u03eb\5\u00f0y\2\u03ea\u03e8\3\2\2\2\u03ea\u03eb\3\2\2\2\u03eb"+ "\u03ec\3\2\2\2\u03ec\u03ed\5\u009cO\2\u03ed\u0095\3\2\2\2\u03ee\u03f0"+ "\7P\2\2\u03ef\u03f1\5\u0098M\2\u03f0\u03ef\3\2\2\2\u03f0\u03f1\3\2\2\2"+ "\u03f1\u03f2\3\2\2\2\u03f2\u03f3\7Q\2\2\u03f3\u0097\3\2\2\2\u03f4\u03f9"+ "\5\u009aN\2\u03f5\u03f6\7W\2\2\u03f6\u03f8\5\u009aN\2\u03f7\u03f5\3\2"+ "\2\2\u03f8\u03fb\3\2\2\2\u03f9\u03f7\3\2\2\2\u03f9\u03fa\3\2\2\2\u03fa"+ "\u0099\3\2\2\2\u03fb\u03f9\3\2\2\2\u03fc\u03fd\5\u00f2z\2\u03fd\u03fe"+ "\5\u00a4S\2\u03fe\u009b\3\2\2\2\u03ff\u0404\7R\2\2\u0400\u0403\5&\24\2"+ "\u0401\u0403\5\66\34\2\u0402\u0400\3\2\2\2\u0402\u0401\3\2\2\2\u0403\u0406"+ "\3\2\2\2\u0404\u0402\3\2\2\2\u0404\u0405\3\2\2\2\u0405\u0407\3\2\2\2\u0406"+ "\u0404\3\2\2\2\u0407\u0408\7S\2\2\u0408\u009d\3\2\2\2\u0409\u040d\7R\2"+ "\2\u040a\u040c\5\u00a0Q\2\u040b\u040a\3\2\2\2\u040c\u040f\3\2\2\2\u040d"+ "\u040b\3\2\2\2\u040d\u040e\3\2\2\2\u040e\u0410\3\2\2\2\u040f\u040d\3\2"+ "\2\2\u0410\u0411\7S\2\2\u0411\u009f\3\2\2\2\u0412\u0413\5\u00a2R\2\u0413"+ "\u0414\7V\2\2\u0414\u0418\3\2\2\2\u0415\u0418\5\u00a8U\2\u0416\u0418\5"+ "\u00aaV\2\u0417\u0412\3\2\2\2\u0417\u0415\3\2\2\2\u0417\u0416\3\2\2\2"+ "\u0418\u00a1\3\2\2\2\u0419\u041b\5\16\b\2\u041a\u0419\3\2\2\2\u041b\u041e"+ "\3\2\2\2\u041c\u041a\3\2\2\2\u041c\u041d\3\2\2\2\u041d\u0427\3\2\2\2\u041e"+ "\u041c\3\2\2\2\u041f\u0420\7?\2\2\u0420\u0421\5\u00a4S\2\u0421\u0422\7"+ "Y\2\2\u0422\u0423\5\u00c8e\2\u0423\u0428\3\2\2\2\u0424\u0425\5\u00f2z"+ "\2\u0425\u0426\5J&\2\u0426\u0428\3\2\2\2\u0427\u041f\3\2\2\2\u0427\u0424"+ "\3\2\2\2\u0428\u00a3\3\2\2\2\u0429\u042a\t\6\2\2\u042a\u00a5\3\2\2\2\u042b"+ "\u042c\t\7\2\2\u042c\u00a7\3\2\2\2\u042d\u042f\5\f\7\2\u042e\u042d\3\2"+ "\2\2\u042f\u0432\3\2\2\2\u0430\u042e\3\2\2\2\u0430\u0431\3\2\2\2\u0431"+ "\u0436\3\2\2\2\u0432\u0430\3\2\2\2\u0433\u0437\5\20\t\2\u0434\u0437\5"+ " \21\2\u0435\u0437\5\u0094K\2\u0436\u0433\3\2\2\2\u0436\u0434\3\2\2\2"+ "\u0436\u0435\3\2\2\2\u0437\u00a9\3\2\2\2\u0438\u04aa\5\u009eP\2\u0439"+ "\u043a\7\4\2\2\u043a\u043d\5\u00c8e\2\u043b\u043c\7_\2\2\u043c\u043e\5"+ "\u00c8e\2\u043d\u043b\3\2\2\2\u043d\u043e\3\2\2\2\u043e\u043f\3\2\2\2"+ "\u043f\u0440\7V\2\2\u0440\u04aa\3\2\2\2\u0441\u0442\7\30\2\2\u0442\u0443"+ "\5\u00c2b\2\u0443\u0446\5\u00aaV\2\u0444\u0445\7\21\2\2\u0445\u0447\5"+ "\u00aaV\2\u0446\u0444\3\2\2\2\u0446\u0447\3\2\2\2\u0447\u04aa\3\2\2\2"+ "\u0448\u0449\7\27\2\2\u0449\u044a\7P\2\2\u044a\u044b\5\u00bc_\2\u044b"+ "\u044c\7Q\2\2\u044c\u044d\5\u00aaV\2\u044d\u04aa\3\2\2\2\u044e\u044f\7"+ "\64\2\2\u044f\u0450\5\u00c2b\2\u0450\u0451\5\u00aaV\2\u0451\u04aa\3\2"+ "\2\2\u0452\u0453\7\17\2\2\u0453\u0454\5\u00aaV\2\u0454\u0455\7\64\2\2"+ "\u0455\u0456\5\u00c2b\2\u0456\u0457\7V\2\2\u0457\u04aa\3\2\2\2\u0458\u0459"+ "\7\61\2\2\u0459\u0463\5\u009eP\2\u045a\u045c\5\u00acW\2\u045b\u045a\3"+ "\2\2\2\u045c\u045d\3\2\2\2\u045d\u045b\3\2\2\2\u045d\u045e\3\2\2\2\u045e"+ "\u0460\3\2\2\2\u045f\u0461\5\u00b0Y\2\u0460\u045f\3\2\2\2\u0460\u0461"+ "\3\2\2\2\u0461\u0464\3\2\2\2\u0462\u0464\5\u00b0Y\2\u0463\u045b\3\2\2"+ "\2\u0463\u0462\3\2\2\2\u0464\u04aa\3\2\2\2\u0465\u0466\7\61\2\2\u0466"+ "\u0467\5\u00b2Z\2\u0467\u046b\5\u009eP\2\u0468\u046a\5\u00acW\2\u0469"+ "\u0468\3\2\2\2\u046a\u046d\3\2\2\2\u046b\u0469\3\2\2\2\u046b\u046c\3\2"+ "\2\2\u046c\u046f\3\2\2\2\u046d\u046b\3\2\2\2\u046e\u0470\5\u00b0Y\2\u046f"+ "\u046e\3\2\2\2\u046f\u0470\3\2\2\2\u0470\u04aa\3\2\2\2\u0471\u0472\7+"+ "\2\2\u0472\u0473\5\u00c2b\2\u0473\u0477\7R\2\2\u0474\u0476\5\u00b8]\2"+ "\u0475\u0474\3\2\2\2\u0476\u0479\3\2\2\2\u0477\u0475\3\2\2\2\u0477\u0478"+ "\3\2\2\2\u0478\u047d\3\2\2\2\u0479\u0477\3\2\2\2\u047a\u047c\5\u00ba^"+ "\2\u047b\u047a\3\2\2\2\u047c\u047f\3\2\2\2\u047d\u047b\3\2\2\2\u047d\u047e"+ "\3\2\2\2\u047e\u0480\3\2\2\2\u047f\u047d\3\2\2\2\u0480\u0481\7S\2\2\u0481"+ "\u04aa\3\2\2\2\u0482\u0483\7,\2\2\u0483\u0484\5\u00c2b\2\u0484\u0485\5"+ "\u009eP\2\u0485\u04aa\3\2\2\2\u0486\u0488\7&\2\2\u0487\u0489\5\u00c8e"+ "\2\u0488\u0487\3\2\2\2\u0488\u0489\3\2\2\2\u0489\u048a\3\2\2\2\u048a\u04aa"+ "\7V\2\2\u048b\u048c\7.\2\2\u048c\u048d\5\u00c8e\2\u048d\u048e\7V\2\2\u048e"+ "\u04aa\3\2\2\2\u048f\u0491\7\6\2\2\u0490\u0492\5\u00a4S\2\u0491\u0490"+ "\3\2\2\2\u0491\u0492\3\2\2\2\u0492\u0493\3\2\2\2\u0493\u04aa\7V\2\2\u0494"+ "\u0496\7\r\2\2\u0495\u0497\5\u00a4S\2\u0496\u0495\3\2\2\2\u0496\u0497"+ "\3\2\2\2\u0497\u0498\3\2\2\2\u0498\u04aa\7V\2\2\u0499\u049a\7@\2\2\u049a"+ "\u049b\5\u00c8e\2\u049b\u049c\7V\2\2\u049c\u04aa\3\2\2\2\u049d\u04aa\7"+ "V\2\2\u049e\u049f\5\u00c8e\2\u049f\u04a0\7V\2\2\u04a0\u04aa\3\2\2\2\u04a1"+ "\u04a3\5\u00d4k\2\u04a2\u04a4\7V\2\2\u04a3\u04a2\3\2\2\2\u04a3\u04a4\3"+ "\2\2\2\u04a4\u04aa\3\2\2\2\u04a5\u04a6\5\u00a4S\2\u04a6\u04a7\7_\2\2\u04a7"+ "\u04a8\5\u00aaV\2\u04a8\u04aa\3\2\2\2\u04a9\u0438\3\2\2\2\u04a9\u0439"+ "\3\2\2\2\u04a9\u0441\3\2\2\2\u04a9\u0448\3\2\2\2\u04a9\u044e\3\2\2\2\u04a9"+ "\u0452\3\2\2\2\u04a9\u0458\3\2\2\2\u04a9\u0465\3\2\2\2\u04a9\u0471\3\2"+ "\2\2\u04a9\u0482\3\2\2\2\u04a9\u0486\3\2\2\2\u04a9\u048b\3\2\2\2\u04a9"+ "\u048f\3\2\2\2\u04a9\u0494\3\2\2\2\u04a9\u0499\3\2\2\2\u04a9\u049d\3\2"+ "\2\2\u04a9\u049e\3\2\2\2\u04a9\u04a1\3\2\2\2\u04a9\u04a5\3\2\2\2\u04aa"+ "\u00ab\3\2\2\2\u04ab\u04ac\7\t\2\2\u04ac\u04b0\7P\2\2\u04ad\u04af\5\16"+ "\b\2\u04ae\u04ad\3\2\2\2\u04af\u04b2\3\2\2\2\u04b0\u04ae\3\2\2\2\u04b0"+ "\u04b1\3\2\2\2\u04b1\u04b3\3\2\2\2\u04b2\u04b0\3\2\2\2\u04b3\u04b4\5\u00ae"+ "X\2\u04b4\u04b5\5\u00a4S\2\u04b5\u04b6\7Q\2\2\u04b6\u04b7\5\u009eP\2\u04b7"+ "\u00ad\3\2\2\2\u04b8\u04bd\5h\65\2\u04b9\u04ba\7m\2\2\u04ba\u04bc\5h\65"+ "\2\u04bb\u04b9\3\2\2\2\u04bc\u04bf\3\2\2\2\u04bd\u04bb\3\2\2\2\u04bd\u04be"+ "\3\2\2\2\u04be\u00af\3\2\2\2\u04bf\u04bd\3\2\2\2\u04c0\u04c1\7\25\2\2"+ "\u04c1\u04c2\5\u009eP\2\u04c2\u00b1\3\2\2\2\u04c3\u04c4\7P\2\2\u04c4\u04c6"+ "\5\u00b4[\2\u04c5\u04c7\7V\2\2\u04c6\u04c5\3\2\2\2\u04c6\u04c7\3\2\2\2"+ "\u04c7\u04c8\3\2\2\2\u04c8\u04c9\7Q\2\2\u04c9\u00b3\3\2\2\2\u04ca\u04cf"+ "\5\u00b6\\\2\u04cb\u04cc\7V\2\2\u04cc\u04ce\5\u00b6\\\2\u04cd\u04cb\3"+ "\2\2\2\u04ce\u04d1\3\2\2\2\u04cf\u04cd\3\2\2\2\u04cf\u04d0\3\2\2\2\u04d0"+ "\u00b5\3\2\2\2\u04d1\u04cf\3\2\2\2\u04d2\u04d4\5\16\b\2\u04d3\u04d2\3"+ "\2\2\2\u04d4\u04d7\3\2\2\2\u04d5\u04d3\3\2\2\2\u04d5\u04d6\3\2\2\2\u04d6"+ "\u04dd\3\2\2\2\u04d7\u04d5\3\2\2\2\u04d8\u04d9\5T+\2\u04d9\u04da\5N(\2"+ "\u04da\u04de\3\2\2\2\u04db\u04dc\7?\2\2\u04dc\u04de\5\u00a4S\2\u04dd\u04d8"+ "\3\2\2\2\u04dd\u04db\3\2\2\2\u04de\u04df\3\2\2\2\u04df\u04e0\7Y\2\2\u04e0"+ "\u04e1\5\u00c8e\2\u04e1\u04e4\3\2\2\2\u04e2\u04e4\5h\65\2\u04e3\u04d5"+ "\3\2\2\2\u04e3\u04e2\3\2\2\2\u04e4\u00b7\3\2\2\2\u04e5\u04e7\5\u00ba^"+ "\2\u04e6\u04e5\3\2\2\2\u04e7\u04e8\3\2\2\2\u04e8\u04e6\3\2\2\2\u04e8\u04e9"+ "\3\2\2\2\u04e9\u04eb\3\2\2\2\u04ea\u04ec\5\u00a0Q\2\u04eb\u04ea\3\2\2"+ "\2\u04ec\u04ed\3\2\2\2\u04ed\u04eb\3\2\2\2\u04ed\u04ee\3\2\2\2\u04ee\u00b9"+ "\3\2\2\2\u04ef\u04f5\7\b\2\2\u04f0\u04f6\5\u00c8e\2\u04f1\u04f6\7\u0082"+ "\2\2\u04f2\u04f3\5\u00f2z\2\u04f3\u04f4\5\u00a4S\2\u04f4\u04f6\3\2\2\2"+ "\u04f5\u04f0\3\2\2\2\u04f5\u04f1\3\2\2\2\u04f5\u04f2\3\2\2\2\u04f6\u04f7"+ "\3\2\2\2\u04f7\u04fb\7_\2\2\u04f8\u04f9\7\16\2\2\u04f9\u04fb\7_\2\2\u04fa"+ "\u04ef\3\2\2\2\u04fa\u04f8\3\2\2\2\u04fb\u00bb\3\2\2\2\u04fc\u0509\5\u00c0"+ "a\2\u04fd\u04ff\5\u00be`\2\u04fe\u04fd\3\2\2\2\u04fe\u04ff\3\2\2\2\u04ff"+ "\u0500\3\2\2\2\u0500\u0502\7V\2\2\u0501\u0503\5\u00c8e\2\u0502\u0501\3"+ "\2\2\2\u0502\u0503\3\2\2\2\u0503\u0504\3\2\2\2\u0504\u0506\7V\2\2\u0505"+ "\u0507\5\u00c4c\2\u0506\u0505\3\2\2\2\u0506\u0507\3\2\2\2\u0507\u0509"+ "\3\2\2\2\u0508\u04fc\3\2\2\2\u0508\u04fe\3\2\2\2\u0509\u00bd\3\2\2\2\u050a"+ "\u050d\5\u00a2R\2\u050b\u050d\5\u00c4c\2\u050c\u050a\3\2\2\2\u050c\u050b"+ "\3\2\2\2\u050d\u00bf\3\2\2\2\u050e\u0510\5\16\b\2\u050f\u050e\3\2\2\2"+ "\u0510\u0513\3\2\2\2\u0511\u050f\3\2\2\2\u0511\u0512\3\2\2\2\u0512\u0516"+ "\3\2\2\2\u0513\u0511\3\2\2\2\u0514\u0517\5\u00f2z\2\u0515\u0517\7?\2\2"+ "\u0516\u0514\3\2\2\2\u0516\u0515\3\2\2\2\u0517\u0518\3\2\2\2\u0518\u0519"+ "\5N(\2\u0519\u051a\7_\2\2\u051a\u051b\5\u00c8e\2\u051b\u00c1\3\2\2\2\u051c"+ "\u051d\7P\2\2\u051d\u051e\5\u00c8e\2\u051e\u051f\7Q\2\2\u051f\u00c3\3"+ "\2\2\2\u0520\u0525\5\u00c8e\2\u0521\u0522\7W\2\2\u0522\u0524\5\u00c8e"+ "\2\u0523\u0521\3\2\2\2\u0524\u0527\3\2\2\2\u0525\u0523\3\2\2\2\u0525\u0526"+ "\3\2\2\2\u0526\u00c5\3\2\2\2\u0527\u0525\3\2\2\2\u0528\u052c\5\u00a4S"+ "\2\u0529\u052c\7-\2\2\u052a\u052c\7*\2\2\u052b\u0528\3\2\2\2\u052b\u0529"+ "\3\2\2\2\u052b\u052a\3\2\2\2\u052c\u052d\3\2\2\2\u052d\u052e\5\u00fc\177"+ "\2\u052e\u00c7\3\2\2\2\u052f\u0530\be\1\2\u0530\u055b\5\u00d2j\2\u0531"+ "\u055b\5\u00c6d\2\u0532\u0533\5\u00f2z\2\u0533\u0539\7|\2\2\u0534\u0536"+ "\5\u00f6|\2\u0535\u0534\3\2\2\2\u0535\u0536\3\2\2\2\u0536\u0537\3\2\2"+ "\2\u0537\u053a\5\u00a4S\2\u0538\u053a\7!\2\2\u0539\u0535\3\2\2\2\u0539"+ "\u0538\3\2\2\2\u053a\u055b\3\2\2\2\u053b\u053c\5\u00dco\2\u053c\u053e"+ "\7|\2\2\u053d\u053f\5\u00f6|\2\u053e\u053d\3\2\2\2\u053e\u053f\3\2\2\2"+ "\u053f\u0540\3\2\2\2\u0540\u0541\7!\2\2\u0541\u055b\3\2\2\2\u0542\u055b"+ "\5\u00d4k\2\u0543\u0544\t\b\2\2\u0544\u055b\5\u00c8e\23\u0545\u0549\7"+ "P\2\2\u0546\u0548\5r:\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\u0551\5\u00f2z\2\u054d\u054e\7l\2\2\u054e\u0550\5\u00f2z\2"+ "\u054f\u054d\3\2\2\2\u0550\u0553\3\2\2\2\u0551\u054f\3\2\2\2\u0551\u0552"+ "\3\2\2\2\u0552\u0554\3\2\2\2\u0553\u0551\3\2\2\2\u0554\u0555\7Q\2\2\u0555"+ "\u0556\5\u00c8e\22\u0556\u055b\3\2\2\2\u0557\u0558\7!\2\2\u0558\u055b"+ "\5\u00dep\2\u0559\u055b\5\u00ccg\2\u055a\u052f\3\2\2\2\u055a\u0531\3\2"+ "\2\2\u055a\u0532\3\2\2\2\u055a\u053b\3\2\2\2\u055a\u0542\3\2\2\2\u055a"+ "\u0543\3\2\2\2\u055a\u0545\3\2\2\2\u055a\u0557\3\2\2\2\u055a\u0559\3\2"+ "\2\2\u055b\u05af\3\2\2\2\u055c\u055d\f\20\2\2\u055d\u055e\t\t\2\2\u055e"+ "\u05ae\5\u00c8e\21\u055f\u0560\f\17\2\2\u0560\u0561\t\n\2\2\u0561\u05ae"+ "\5\u00c8e\20\u0562\u056a\f\16\2\2\u0563\u0564\7[\2\2\u0564\u056b\7[\2"+ "\2\u0565\u0566\7Z\2\2\u0566\u0567\7Z\2\2\u0567\u056b\7Z\2\2\u0568\u0569"+ "\7Z\2\2\u0569\u056b\7Z\2\2\u056a\u0563\3\2\2\2\u056a\u0565\3\2\2\2\u056a"+ "\u0568\3\2\2\2\u056b\u056c\3\2\2\2\u056c\u05ae\5\u00c8e\17\u056d\u056e"+ "\f\r\2\2\u056e\u056f\t\13\2\2\u056f\u05ae\5\u00c8e\16\u0570\u0571\f\13"+ "\2\2\u0571\u0572\t\f\2\2\u0572\u05ae\5\u00c8e\f\u0573\u0574\f\n\2\2\u0574"+ "\u0575\7l\2\2\u0575\u05ae\5\u00c8e\13\u0576\u0577\f\t\2\2\u0577\u0578"+ "\7n\2\2\u0578\u05ae\5\u00c8e\n\u0579\u057a\f\b\2\2\u057a\u057b\7m\2\2"+ "\u057b\u05ae\5\u00c8e\t\u057c\u057d\f\7\2\2\u057d\u057e\7d\2\2\u057e\u05ae"+ "\5\u00c8e\b\u057f\u0580\f\6\2\2\u0580\u0581\7e\2\2\u0581\u05ae\5\u00c8"+ "e\7\u0582\u0583\f\5\2\2\u0583\u0584\7^\2\2\u0584\u0585\5\u00c8e\2\u0585"+ "\u0586\7_\2\2\u0586\u0587\5\u00c8e\5\u0587\u05ae\3\2\2\2\u0588\u0589\f"+ "\4\2\2\u0589\u058a\t\r\2\2\u058a\u05ae\5\u00c8e\4\u058b\u058c\f\33\2\2"+ "\u058c\u058d\7T\2\2\u058d\u058e\5\u00c8e\2\u058e\u058f\7U\2\2\u058f\u05ae"+ "\3\2\2\2\u0590\u0591\f\32\2\2\u0591\u059d\7X\2\2\u0592\u059e\5\u00a4S"+ "\2\u0593\u059e\5\u00c6d\2\u0594\u059e\7-\2\2\u0595\u0597\7!\2\2\u0596"+ "\u0598\5\u00eex\2\u0597\u0596\3\2\2\2\u0597\u0598\3\2\2\2\u0598\u0599"+ "\3\2\2\2\u0599\u059e\5\u00e2r\2\u059a\u059b\7*\2\2\u059b\u059e\5\u00f8"+ "}\2\u059c\u059e\5\u00e8u\2\u059d\u0592\3\2\2\2\u059d\u0593\3\2\2\2\u059d"+ "\u0594\3\2\2\2\u059d\u0595\3\2\2\2\u059d\u059a\3\2\2\2\u059d\u059c\3\2"+ "\2\2\u059e\u05ae\3\2\2\2\u059f\u05a0\f\30\2\2\u05a0\u05a2\7|\2\2\u05a1"+ "\u05a3\5\u00f6|\2\u05a2\u05a1\3\2\2\2\u05a2\u05a3\3\2\2\2\u05a3\u05a4"+ "\3\2\2\2\u05a4\u05ae\5\u00a4S\2\u05a5\u05a6\f\24\2\2\u05a6\u05ae\t\16"+ "\2\2\u05a7\u05a8\f\f\2\2\u05a8\u05ab\7\34\2\2\u05a9\u05ac\5\u00f2z\2\u05aa"+ "\u05ac\5\u00caf\2\u05ab\u05a9\3\2\2\2\u05ab\u05aa\3\2\2\2\u05ac\u05ae"+ "\3\2\2\2\u05ad\u055c\3\2\2\2\u05ad\u055f\3\2\2\2\u05ad\u0562\3\2\2\2\u05ad"+ "\u056d\3\2\2\2\u05ad\u0570\3\2\2\2\u05ad\u0573\3\2\2\2\u05ad\u0576\3\2"+ "\2\2\u05ad\u0579\3\2\2\2\u05ad\u057c\3\2\2\2\u05ad\u057f\3\2\2\2\u05ad"+ "\u0582\3\2\2\2\u05ad\u0588\3\2\2\2\u05ad\u058b\3\2\2\2\u05ad\u0590\3\2"+ "\2\2\u05ad\u059f\3\2\2\2\u05ad\u05a5\3\2\2\2\u05ad\u05a7\3\2\2\2\u05ae"+ "\u05b1\3\2\2\2\u05af\u05ad\3\2\2\2\u05af\u05b0\3\2\2\2\u05b0\u00c9\3\2"+ "\2\2\u05b1\u05af\3\2\2\2\u05b2\u05b4\5\16\b\2\u05b3\u05b2\3\2\2\2\u05b4"+ "\u05b7\3\2\2\2\u05b5\u05b3\3\2\2\2\u05b5\u05b6\3\2\2\2\u05b6\u05b8\3\2"+ "\2\2\u05b7\u05b5\3\2\2\2\u05b8\u05bc\5\u00f2z\2\u05b9\u05bb\5r:\2\u05ba"+ "\u05b9\3\2\2\2\u05bb\u05be\3\2\2\2\u05bc\u05ba\3\2\2\2\u05bc\u05bd\3\2"+ "\2\2\u05bd\u05bf\3\2\2\2\u05be\u05bc\3\2\2\2\u05bf\u05c0\5\u00a4S\2\u05c0"+ "\u00cb\3\2\2\2\u05c1\u05c2\5\u00ceh\2\u05c2\u05c3\7{\2\2\u05c3\u05c4\5"+ "\u00d0i\2\u05c4\u00cd\3\2\2\2\u05c5\u05dc\5\u00a4S\2\u05c6\u05c8\7P\2"+ "\2\u05c7\u05c9\5^\60\2\u05c8\u05c7\3\2\2\2\u05c8\u05c9\3\2\2\2\u05c9\u05ca"+ "\3\2\2\2\u05ca\u05dc\7Q\2\2\u05cb\u05cc\7P\2\2\u05cc\u05d1\5\u00a4S\2"+ "\u05cd\u05ce\7W\2\2\u05ce\u05d0\5\u00a4S\2\u05cf\u05cd\3\2\2\2\u05d0\u05d3"+ "\3\2\2\2\u05d1\u05cf\3\2\2\2\u05d1\u05d2\3\2\2\2\u05d2\u05d4\3\2\2\2\u05d3"+ "\u05d1\3\2\2\2\u05d4\u05d5\7Q\2\2\u05d5\u05dc\3\2\2\2\u05d6\u05d8\7P\2"+ "\2\u05d7\u05d9\5d\63\2\u05d8\u05d7\3\2\2\2\u05d8\u05d9\3\2\2\2\u05d9\u05da"+ "\3\2\2\2\u05da\u05dc\7Q\2\2\u05db\u05c5\3\2\2\2\u05db\u05c6\3\2\2\2\u05db"+ "\u05cb\3\2\2\2\u05db\u05d6\3\2\2\2\u05dc\u00cf\3\2\2\2\u05dd\u05e0\5\u00c8"+ "e\2\u05de\u05e0\5\u009eP\2\u05df\u05dd\3\2\2\2\u05df\u05de\3\2\2\2\u05e0"+ "\u00d1\3\2\2\2\u05e1\u05e2\7P\2\2\u05e2\u05e3\5\u00c8e\2\u05e3\u05e4\7"+ "Q\2\2\u05e4\u05f4\3\2\2\2\u05e5\u05f4\7-\2\2\u05e6\u05f4\7*\2\2\u05e7"+ "\u05f4\5j\66\2\u05e8\u05f4\5\u00a4S\2\u05e9\u05ea\5.\30\2\u05ea\u05eb"+ "\7X\2\2\u05eb\u05ec\7\13\2\2\u05ec\u05f4\3\2\2\2\u05ed\u05f1\5\u00eex"+ "\2\u05ee\u05f2\5\u00fa~\2\u05ef\u05f0\7-\2\2\u05f0\u05f2\5\u00fc\177\2"+ "\u05f1\u05ee\3\2\2\2\u05f1\u05ef\3\2\2\2\u05f2\u05f4\3\2\2\2\u05f3\u05e1"+ "\3\2\2\2\u05f3\u05e5\3\2\2\2\u05f3\u05e6\3\2\2\2\u05f3\u05e7\3\2\2\2\u05f3"+ "\u05e8\3\2\2\2\u05f3\u05e9\3\2\2\2\u05f3\u05ed\3\2\2\2\u05f4\u00d3\3\2"+ "\2\2\u05f5\u05f6\7+\2\2\u05f6\u05f7\5\u00c2b\2\u05f7\u05fb\7R\2\2\u05f8"+ "\u05fa\5\u00d6l\2\u05f9\u05f8\3\2\2\2\u05fa\u05fd\3\2\2\2\u05fb\u05f9"+ "\3\2\2\2\u05fb\u05fc\3\2\2\2\u05fc\u05fe\3\2\2\2\u05fd\u05fb\3\2\2\2\u05fe"+ "\u05ff\7S\2\2\u05ff\u00d5\3\2\2\2\u0600\u0604\7\b\2\2\u0601\u0605\5\u00c4"+ "c\2\u0602\u0605\7O\2\2\u0603\u0605\5\u00d8m\2\u0604\u0601\3\2\2\2\u0604"+ "\u0602\3\2\2\2\u0604\u0603\3\2\2\2\u0605\u0606\3\2\2\2\u0606\u0607\t\17"+ "\2\2\u0607\u060c\5\u00dan\2\u0608\u0609\7\16\2\2\u0609\u060a\t\17\2\2"+ "\u060a\u060c\5\u00dan\2\u060b\u0600\3\2\2\2\u060b\u0608\3\2\2\2\u060c"+ "\u00d7\3\2\2\2\u060d\u060e\bm\1\2\u060e\u060f\7P\2\2\u060f\u0610\5\u00d8"+ "m\2\u0610\u0611\7Q\2\2\u0611\u0628\3\2\2\2\u0612\u0614\5\16\b\2\u0613"+ "\u0612\3\2\2\2\u0614\u0617\3\2\2\2\u0615\u0613\3\2\2\2\u0615\u0616\3\2"+ "\2\2\u0616\u0618\3\2\2\2\u0617\u0615\3\2\2\2\u0618\u061c\5\u00f2z\2\u0619"+ "\u061b\5r:\2\u061a\u0619\3\2\2\2\u061b\u061e\3\2\2\2\u061c\u061a\3\2\2"+ "\2\u061c\u061d\3\2\2\2\u061d\u061f\3\2\2\2\u061e\u061c\3\2\2\2\u061f\u0624"+ "\5\u00a4S\2\u0620\u0621\7d\2\2\u0621\u0623\5\u00c8e\2\u0622\u0620\3\2"+ "\2\2\u0623\u0626\3\2\2\2\u0624\u0622\3\2\2\2\u0624\u0625\3\2\2\2\u0625"+ "\u0628\3\2\2\2\u0626\u0624\3\2\2\2\u0627\u060d\3\2\2\2\u0627\u0615\3\2"+ "\2\2\u0628\u062e\3\2\2\2\u0629\u062a\f\3\2\2\u062a\u062b\7d\2\2\u062b"+ "\u062d\5\u00c8e\2\u062c\u0629\3\2\2\2\u062d\u0630\3\2\2\2\u062e\u062c"+ "\3\2\2\2\u062e\u062f\3\2\2\2\u062f\u00d9\3\2\2\2\u0630\u062e\3\2\2\2\u0631"+ "\u0639\5\u009eP\2\u0632\u0634\5\u00a0Q\2\u0633\u0632\3\2\2\2\u0634\u0637"+ "\3\2\2\2\u0635\u0633\3\2\2\2\u0635\u0636\3\2\2\2\u0636\u0639\3\2\2\2\u0637"+ "\u0635\3\2\2\2\u0638\u0631\3\2\2\2\u0638\u0635\3\2\2\2\u0639\u00db\3\2"+ "\2\2\u063a\u063b\5T+\2\u063b\u063c\7X\2\2\u063c\u063e\3\2\2\2\u063d\u063a"+ "\3\2\2\2\u063d\u063e\3\2\2\2\u063e\u0642\3\2\2\2\u063f\u0641\5r:\2\u0640"+ "\u063f\3\2\2\2\u0641\u0644\3\2\2\2\u0642\u0640\3\2\2\2\u0642\u0643\3\2"+ "\2\2\u0643\u0645\3\2\2\2\u0644\u0642\3\2\2\2\u0645\u0647\5\u00a4S\2\u0646"+ "\u0648\5\u00f6|\2\u0647\u0646\3\2\2\2\u0647\u0648\3\2\2\2\u0648\u00dd"+ "\3\2\2\2\u0649\u064b\5\u00eex\2\u064a\u0649\3\2\2\2\u064a\u064b\3\2\2"+ "\2\u064b\u064c\3\2\2\2\u064c\u064d\5\u00e0q\2\u064d\u064e\5\u00e6t\2\u064e"+ "\u0653\3\2\2\2\u064f\u0650\5\u00e0q\2\u0650\u0651\5\u00e4s\2\u0651\u0653"+ "\3\2\2\2\u0652\u064a\3\2\2\2\u0652\u064f\3\2\2\2\u0653\u00df\3\2\2\2\u0654"+ "\u0656\5\u00a4S\2\u0655\u0657\5\u00eav\2\u0656\u0655\3\2\2\2\u0656\u0657"+ "\3\2\2\2\u0657\u065f\3\2\2\2\u0658\u0659\7X\2\2\u0659\u065b\5\u00a4S\2"+ "\u065a\u065c\5\u00eav\2\u065b\u065a\3\2\2\2\u065b\u065c\3\2\2\2\u065c"+ "\u065e\3\2\2\2\u065d\u0658\3\2\2\2\u065e\u0661\3\2\2\2\u065f\u065d\3\2"+ "\2\2\u065f\u0660\3\2\2\2\u0660\u0664\3\2\2\2\u0661\u065f\3\2\2\2\u0662"+ "\u0664\5\u00f4{\2\u0663\u0654\3\2\2\2\u0663\u0662\3\2\2\2\u0664\u00e1"+ "\3\2\2\2\u0665\u0667\5\u00a4S\2\u0666\u0668\5\u00ecw\2\u0667\u0666\3\2"+ "\2\2\u0667\u0668\3\2\2\2\u0668\u0669\3\2\2\2\u0669\u066a\5\u00e6t\2\u066a"+ "\u00e3\3\2\2\2\u066b\u066c\7T\2\2\u066c\u066e\7U\2\2\u066d\u066b\3\2\2"+ "\2\u066e\u066f\3\2\2\2\u066f\u066d\3\2\2\2\u066f\u0670\3\2\2\2\u0670\u0671"+ "\3\2\2\2\u0671\u0682\5R*\2\u0672\u0673\7T\2\2\u0673\u0674\5\u00c8e\2\u0674"+ "\u0675\7U\2\2\u0675\u0677\3\2\2\2\u0676\u0672\3\2\2\2\u0677\u0678\3\2"+ "\2\2\u0678\u0676\3\2\2\2\u0678\u0679\3\2\2\2\u0679\u067e\3\2\2\2\u067a"+ "\u067b\7T\2\2\u067b\u067d\7U\2\2\u067c\u067a\3\2\2\2\u067d\u0680\3\2\2"+ "\2\u067e\u067c\3\2\2\2\u067e\u067f\3\2\2\2\u067f\u0682\3\2\2\2\u0680\u067e"+ "\3\2\2\2\u0681\u066d\3\2\2\2\u0681\u0676\3\2\2\2\u0682\u00e5\3\2\2\2\u0683"+ "\u0685\5\u00fc\177\2\u0684\u0686\5\"\22\2\u0685\u0684\3\2\2\2\u0685\u0686"+ "\3\2\2\2\u0686\u00e7\3\2\2\2\u0687\u0688\5\u00eex\2\u0688\u0689\5\u00fa"+ "~\2\u0689\u00e9\3\2\2\2\u068a\u068b\7[\2\2\u068b\u068e\7Z\2\2\u068c\u068e"+ "\5\u00f6|\2\u068d\u068a\3\2\2\2\u068d\u068c\3\2\2\2\u068e\u00eb\3\2\2"+ "\2\u068f\u0690\7[\2\2\u0690\u0693\7Z\2\2\u0691\u0693\5\u00eex\2\u0692"+ "\u068f\3\2\2\2\u0692\u0691\3\2\2\2\u0693\u00ed\3\2\2\2\u0694\u0695\7["+ "\2\2\u0695\u0696\5\u00f0y\2\u0696\u0697\7Z\2\2\u0697\u00ef\3\2\2\2\u0698"+ "\u069d\5\u00f2z\2\u0699\u069a\7W\2\2\u069a\u069c\5\u00f2z\2\u069b\u0699"+ "\3\2\2\2\u069c\u069f\3\2\2\2\u069d\u069b\3\2\2\2\u069d\u069e\3\2\2\2\u069e"+ "\u00f1\3\2\2\2\u069f\u069d\3\2\2\2\u06a0\u06a2\5r:\2\u06a1\u06a0\3\2\2"+ "\2\u06a2\u06a5\3\2\2\2\u06a3\u06a1\3\2\2\2\u06a3\u06a4\3\2\2\2\u06a4\u06a8"+ "\3\2\2\2\u06a5\u06a3\3\2\2\2\u06a6\u06a9\5T+\2\u06a7\u06a9\5\u00f4{\2"+ "\u06a8\u06a6\3\2\2\2\u06a8\u06a7\3\2\2\2\u06a9\u06b4\3\2\2\2\u06aa\u06ac"+ "\5r:\2\u06ab\u06aa\3\2\2\2\u06ac\u06af\3\2\2\2\u06ad\u06ab\3\2\2\2\u06ad"+ "\u06ae\3\2\2\2\u06ae\u06b0\3\2\2\2\u06af\u06ad\3\2\2\2\u06b0\u06b1\7T"+ "\2\2\u06b1\u06b3\7U\2\2\u06b2\u06ad\3\2\2\2\u06b3\u06b6\3\2\2\2\u06b4"+ "\u06b2\3\2\2\2\u06b4\u06b5\3\2\2\2\u06b5\u00f3\3\2\2\2\u06b6\u06b4\3\2"+ "\2\2\u06b7\u06b8\t\20\2\2\u06b8\u00f5\3\2\2\2\u06b9\u06ba\7[\2\2\u06ba"+ "\u06bf\5V,\2\u06bb\u06bc\7W\2\2\u06bc\u06be\5V,\2\u06bd\u06bb\3\2\2\2"+ "\u06be\u06c1\3\2\2\2\u06bf\u06bd\3\2\2\2\u06bf\u06c0\3\2\2\2\u06c0\u06c2"+ "\3\2\2\2\u06c1\u06bf\3\2\2\2\u06c2\u06c3\7Z\2\2\u06c3\u00f7\3\2\2\2\u06c4"+ "\u06ce\5\u00fc\177\2\u06c5\u06c7\7X\2\2\u06c6\u06c8\5\u00f6|\2\u06c7\u06c6"+ "\3\2\2\2\u06c7\u06c8\3\2\2\2\u06c8\u06c9\3\2\2\2\u06c9\u06cb\5\u00a4S"+ "\2\u06ca\u06cc\5\u00fc\177\2\u06cb\u06ca\3\2\2\2\u06cb\u06cc\3\2\2\2\u06cc"+ "\u06ce\3\2\2\2\u06cd\u06c4\3\2\2\2\u06cd\u06c5\3\2\2\2\u06ce\u00f9\3\2"+ "\2\2\u06cf\u06d0\7*\2\2\u06d0\u06d5\5\u00f8}\2\u06d1\u06d2\5\u00a4S\2"+ "\u06d2\u06d3\5\u00fc\177\2\u06d3\u06d5\3\2\2\2\u06d4\u06cf\3\2\2\2\u06d4"+ "\u06d1\3\2\2\2\u06d5\u00fb\3\2\2\2\u06d6\u06d8\7P\2\2\u06d7\u06d9\5\u00c4"+ "c\2\u06d8\u06d7\3\2\2\2\u06d8\u06d9\3\2\2\2\u06d9\u06da\3\2\2\2\u06da"+ "\u06db\7Q\2\2\u06db\u00fd\3\2\2\2\u00dd\u00ff\u0103\u0105\u010a\u010c"+ "\u0112\u0117\u0120\u0125\u012c\u0134\u013b\u0147\u014b\u0150\u0154\u0158"+ "\u015c\u0166\u016e\u0176\u017a\u0181\u0188\u018c\u018f\u0192\u019b\u01a1"+ "\u01a6\u01a9\u01af\u01b5\u01b9\u01bd\u01c5\u01ce\u01d5\u01db\u01df\u01eb"+ "\u01f4\u01f9\u01ff\u0203\u020f\u0216\u0223\u0228\u0232\u023a\u0244\u024d"+ "\u0258\u025d\u0266\u0270\u0275\u027e\u0284\u028b\u0290\u0298\u029c\u029e"+ "\u02a4\u02aa\u02af\u02b5\u02bb\u02bd\u02c4\u02c9\u02ce\u02d1\u02d3\u02dd"+ "\u02e7\u02ec\u02ef\u02f4\u02fd\u0304\u030f\u0315\u0320\u032a\u0335\u033e"+ "\u0343\u0346\u034d\u0357\u035f\u0362\u0365\u0372\u037a\u037f\u0387\u038b"+ "\u038f\u0393\u0397\u0399\u039d\u03a3\u03ab\u03b5\u03be\u03c8\u03d0\u03de"+ "\u03e5\u03ea\u03f0\u03f9\u0402\u0404\u040d\u0417\u041c\u0427\u0430\u0436"+ "\u043d\u0446\u045d\u0460\u0463\u046b\u046f\u0477\u047d\u0488\u0491\u0496"+ "\u04a3\u04a9\u04b0\u04bd\u04c6\u04cf\u04d5\u04dd\u04e3\u04e8\u04ed\u04f5"+ "\u04fa\u04fe\u0502\u0506\u0508\u050c\u0511\u0516\u0525\u052b\u0535\u0539"+ "\u053e\u0549\u0551\u055a\u056a\u0597\u059d\u05a2\u05ab\u05ad\u05af\u05b5"+ "\u05bc\u05c8\u05d1\u05d8\u05db\u05df\u05f1\u05f3\u05fb\u0604\u060b\u0615"+ "\u061c\u0624\u0627\u062e\u0635\u0638\u063d\u0642\u0647\u064a\u0652\u0656"+ "\u065b\u065f\u0663\u0667\u066f\u0678\u067e\u0681\u0685\u068d\u0692\u069d"+ "\u06a3\u06a8\u06ad\u06b4\u06bf\u06c7\u06cb\u06cd\u06d4\u06d8"; 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); } } }