edu.illinois.cs.cs125.questioner.antlr.JavaParser Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of plugin Show documentation
Show all versions of plugin Show documentation
Questioner Gradle plugin for CS 124.
// Generated from edu/illinois/cs/cs125/questioner/antlr/java/JavaParser.g4 by ANTLR 4.13.2
package edu.illinois.cs.cs125.questioner.antlr;
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", "CheckReturnValue", "this-escape"})
public class JavaParser extends Parser {
static { RuntimeMetaData.checkVersion("4.13.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, RECORD=36,
RETURN=37, SHORT=38, STATIC=39, STRICTFP=40, SUPER=41, SWITCH=42, SYNCHRONIZED=43,
THIS=44, THROW=45, THROWS=46, TRANSIENT=47, TRY=48, VOID=49, VOLATILE=50,
YIELD=51, WHILE=52, DECIMAL_LITERAL=53, HEX_LITERAL=54, OCT_LITERAL=55,
BINARY_LITERAL=56, FLOAT_LITERAL=57, HEX_FLOAT_LITERAL=58, BOOL_LITERAL=59,
CHAR_LITERAL=60, STRING_LITERAL=61, TEXT_BLOCK_LITERAL=62, NULL_LITERAL=63,
LPAREN=64, RPAREN=65, LBRACE=66, RBRACE=67, LBRACK=68, RBRACK=69, SEMI=70,
COMMA=71, DOT=72, ASSIGN=73, GT=74, LT=75, BANG=76, TILDE=77, QUESTION=78,
COLON=79, EQUAL=80, LE=81, GE=82, NOTEQUAL=83, AND=84, OR=85, INC=86,
DEC=87, ADD=88, SUB=89, MUL=90, DIV=91, BITAND=92, BITOR=93, CARET=94,
MOD=95, ADD_ASSIGN=96, SUB_ASSIGN=97, MUL_ASSIGN=98, DIV_ASSIGN=99, AND_ASSIGN=100,
OR_ASSIGN=101, XOR_ASSIGN=102, MOD_ASSIGN=103, LSHIFT_ASSIGN=104, RSHIFT_ASSIGN=105,
URSHIFT_ASSIGN=106, ARROW=107, COLONCOLON=108, AT=109, ELLIPSIS=110, WS=111,
COMMENT=112, LINE_COMMENT=113, IDENTIFIER=114;
public static final int
RULE_identifier = 0, RULE_compilationUnit = 1, RULE_packageDeclaration = 2,
RULE_importDeclaration = 3, RULE_typeDeclaration = 4, RULE_modifier = 5,
RULE_classOrInterfaceModifier = 6, RULE_variableModifier = 7, RULE_recordDeclaration = 8,
RULE_classDeclaration = 9, RULE_typeParameters = 10, RULE_typeParameter = 11,
RULE_typeBound = 12, RULE_enumDeclaration = 13, RULE_enumConstants = 14,
RULE_enumConstant = 15, RULE_enumBodyDeclarations = 16, RULE_interfaceDeclaration = 17,
RULE_classBody = 18, RULE_interfaceBody = 19, RULE_classBodyDeclaration = 20,
RULE_memberDeclaration = 21, RULE_methodDeclaration = 22, RULE_methodBody = 23,
RULE_typeTypeOrVoid = 24, RULE_genericMethodDeclaration = 25, RULE_genericConstructorDeclaration = 26,
RULE_constructorDeclaration = 27, RULE_recordConstructorDeclaration = 28,
RULE_fieldDeclaration = 29, RULE_interfaceBodyDeclaration = 30, RULE_interfaceMemberDeclaration = 31,
RULE_constDeclaration = 32, RULE_constantDeclarator = 33, RULE_interfaceMethodDeclaration = 34,
RULE_interfaceMethodModifier = 35, RULE_genericInterfaceMethodDeclaration = 36,
RULE_variableDeclarators = 37, RULE_variableDeclarator = 38, RULE_variableDeclaratorId = 39,
RULE_variableInitializer = 40, RULE_arrayInitializer = 41, RULE_classOrInterfaceType = 42,
RULE_typeArgument = 43, RULE_qualifiedNameList = 44, RULE_formalParameters = 45,
RULE_formalParameterList = 46, RULE_formalParameter = 47, RULE_lastFormalParameter = 48,
RULE_qualifiedName = 49, RULE_literal = 50, RULE_integerLiteral = 51,
RULE_floatLiteral = 52, RULE_annotation = 53, RULE_elementValuePairs = 54,
RULE_elementValuePair = 55, RULE_elementValue = 56, RULE_elementValueArrayInitializer = 57,
RULE_annotationTypeDeclaration = 58, RULE_annotationTypeBody = 59, RULE_annotationTypeElementDeclaration = 60,
RULE_annotationTypeElementRest = 61, RULE_annotationMethodOrConstantRest = 62,
RULE_annotationMethodRest = 63, RULE_annotationConstantRest = 64, RULE_defaultValue = 65,
RULE_block = 66, RULE_blockStatement = 67, RULE_localVariableDeclaration = 68,
RULE_localTypeDeclaration = 69, RULE_statement = 70, RULE_catchClause = 71,
RULE_catchType = 72, RULE_finallyBlock = 73, RULE_resourceSpecification = 74,
RULE_resources = 75, RULE_resource = 76, RULE_switchBlockStatementGroup = 77,
RULE_switchLabel = 78, RULE_switchExpressionBlockStatementGroup = 79,
RULE_switchExpressionLabel = 80, RULE_forControl = 81, RULE_forInit = 82,
RULE_enhancedForControl = 83, RULE_parExpression = 84, RULE_expressionList = 85,
RULE_methodCall = 86, RULE_expression = 87, RULE_lambdaExpression = 88,
RULE_lambdaParameters = 89, RULE_lambdaBody = 90, RULE_primary = 91, RULE_classType = 92,
RULE_creator = 93, RULE_createdName = 94, RULE_innerCreator = 95, RULE_arrayCreatorRest = 96,
RULE_classCreatorRest = 97, RULE_explicitGenericInvocation = 98, RULE_typeArgumentsOrDiamond = 99,
RULE_nonWildcardTypeArgumentsOrDiamond = 100, RULE_nonWildcardTypeArguments = 101,
RULE_typeList = 102, RULE_typeType = 103, RULE_primitiveType = 104, RULE_typeArguments = 105,
RULE_superSuffix = 106, RULE_explicitGenericInvocationSuffix = 107, RULE_arguments = 108;
private static String[] makeRuleNames() {
return new String[] {
"identifier", "compilationUnit", "packageDeclaration", "importDeclaration",
"typeDeclaration", "modifier", "classOrInterfaceModifier", "variableModifier",
"recordDeclaration", "classDeclaration", "typeParameters", "typeParameter",
"typeBound", "enumDeclaration", "enumConstants", "enumConstant", "enumBodyDeclarations",
"interfaceDeclaration", "classBody", "interfaceBody", "classBodyDeclaration",
"memberDeclaration", "methodDeclaration", "methodBody", "typeTypeOrVoid",
"genericMethodDeclaration", "genericConstructorDeclaration", "constructorDeclaration",
"recordConstructorDeclaration", "fieldDeclaration", "interfaceBodyDeclaration",
"interfaceMemberDeclaration", "constDeclaration", "constantDeclarator",
"interfaceMethodDeclaration", "interfaceMethodModifier", "genericInterfaceMethodDeclaration",
"variableDeclarators", "variableDeclarator", "variableDeclaratorId",
"variableInitializer", "arrayInitializer", "classOrInterfaceType", "typeArgument",
"qualifiedNameList", "formalParameters", "formalParameterList", "formalParameter",
"lastFormalParameter", "qualifiedName", "literal", "integerLiteral",
"floatLiteral", "annotation", "elementValuePairs", "elementValuePair",
"elementValue", "elementValueArrayInitializer", "annotationTypeDeclaration",
"annotationTypeBody", "annotationTypeElementDeclaration", "annotationTypeElementRest",
"annotationMethodOrConstantRest", "annotationMethodRest", "annotationConstantRest",
"defaultValue", "block", "blockStatement", "localVariableDeclaration",
"localTypeDeclaration", "statement", "catchClause", "catchType", "finallyBlock",
"resourceSpecification", "resources", "resource", "switchBlockStatementGroup",
"switchLabel", "switchExpressionBlockStatementGroup", "switchExpressionLabel",
"forControl", "forInit", "enhancedForControl", "parExpression", "expressionList",
"methodCall", "expression", "lambdaExpression", "lambdaParameters", "lambdaBody",
"primary", "classType", "creator", "createdName", "innerCreator", "arrayCreatorRest",
"classCreatorRest", "explicitGenericInvocation", "typeArgumentsOrDiamond",
"nonWildcardTypeArgumentsOrDiamond", "nonWildcardTypeArguments", "typeList",
"typeType", "primitiveType", "typeArguments", "superSuffix", "explicitGenericInvocationSuffix",
"arguments"
};
}
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'", "'record'", "'return'", "'short'", "'static'",
"'strictfp'", "'super'", "'switch'", "'synchronized'", "'this'", "'throw'",
"'throws'", "'transient'", "'try'", "'void'", "'volatile'", "'yield'",
"'while'", 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", "RECORD", "RETURN",
"SHORT", "STATIC", "STRICTFP", "SUPER", "SWITCH", "SYNCHRONIZED", "THIS",
"THROW", "THROWS", "TRANSIENT", "TRY", "VOID", "VOLATILE", "YIELD", "WHILE",
"DECIMAL_LITERAL", "HEX_LITERAL", "OCT_LITERAL", "BINARY_LITERAL", "FLOAT_LITERAL",
"HEX_FLOAT_LITERAL", "BOOL_LITERAL", "CHAR_LITERAL", "STRING_LITERAL",
"TEXT_BLOCK_LITERAL", "NULL_LITERAL", "LPAREN", "RPAREN", "LBRACE", "RBRACE",
"LBRACK", "RBRACK", "SEMI", "COMMA", "DOT", "ASSIGN", "GT", "LT", "BANG",
"TILDE", "QUESTION", "COLON", "EQUAL", "LE", "GE", "NOTEQUAL", "AND",
"OR", "INC", "DEC", "ADD", "SUB", "MUL", "DIV", "BITAND", "BITOR", "CARET",
"MOD", "ADD_ASSIGN", "SUB_ASSIGN", "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN",
"OR_ASSIGN", "XOR_ASSIGN", "MOD_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN",
"URSHIFT_ASSIGN", "ARROW", "COLONCOLON", "AT", "ELLIPSIS", "WS", "COMMENT",
"LINE_COMMENT", "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);
}
@SuppressWarnings("CheckReturnValue")
public static class IdentifierContext extends ParserRuleContext {
public TerminalNode IDENTIFIER() { return getToken(JavaParser.IDENTIFIER, 0); }
public TerminalNode RECORD() { return getToken(JavaParser.RECORD, 0); }
public IdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final IdentifierContext identifier() throws RecognitionException {
IdentifierContext _localctx = new IdentifierContext(_ctx, getState());
enterRule(_localctx, 0, RULE_identifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(218);
_la = _input.LA(1);
if ( !(_la==RECORD || _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;
}
@SuppressWarnings("CheckReturnValue")
public static class CompilationUnitContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(JavaParser.EOF, 0); }
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 typeDeclaration() {
return getRuleContexts(TypeDeclarationContext.class);
}
public TypeDeclarationContext typeDeclaration(int i) {
return getRuleContext(TypeDeclarationContext.class,i);
}
public CompilationUnitContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_compilationUnit; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterCompilationUnit(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitCompilationUnit(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitCompilationUnit(this);
else return visitor.visitChildren(this);
}
}
public final CompilationUnitContext compilationUnit() throws RecognitionException {
CompilationUnitContext _localctx = new CompilationUnitContext(_ctx, getState());
enterRule(_localctx, 2, RULE_compilationUnit);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(221);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
case 1:
{
setState(220);
packageDeclaration();
}
break;
}
setState(226);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==IMPORT) {
{
{
setState(223);
importDeclaration();
}
}
setState(228);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(232);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1778385224194L) != 0) || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & 4947802324993L) != 0)) {
{
{
setState(229);
typeDeclaration();
}
}
setState(234);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(235);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterPackageDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitPackageDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitPackageDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final PackageDeclarationContext packageDeclaration() throws RecognitionException {
PackageDeclarationContext _localctx = new PackageDeclarationContext(_ctx, getState());
enterRule(_localctx, 4, RULE_packageDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(240);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(237);
annotation();
}
}
setState(242);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(243);
match(PACKAGE);
setState(244);
qualifiedName();
setState(245);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterImportDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitImportDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitImportDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final ImportDeclarationContext importDeclaration() throws RecognitionException {
ImportDeclarationContext _localctx = new ImportDeclarationContext(_ctx, getState());
enterRule(_localctx, 6, RULE_importDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(247);
match(IMPORT);
setState(249);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==STATIC) {
{
setState(248);
match(STATIC);
}
}
setState(251);
qualifiedName();
setState(254);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(252);
match(DOT);
setState(253);
match(MUL);
}
}
setState(256);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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 TerminalNode COMMENT() { return getToken(JavaParser.COMMENT, 0); }
public List classOrInterfaceModifier() {
return getRuleContexts(ClassOrInterfaceModifierContext.class);
}
public ClassOrInterfaceModifierContext classOrInterfaceModifier(int i) {
return getRuleContext(ClassOrInterfaceModifierContext.class,i);
}
public TerminalNode SEMI() { return getToken(JavaParser.SEMI, 0); }
public TypeDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterTypeDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitTypeDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitTypeDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final TypeDeclarationContext typeDeclaration() throws RecognitionException {
TypeDeclarationContext _localctx = new TypeDeclarationContext(_ctx, getState());
enterRule(_localctx, 8, RULE_typeDeclaration);
int _la;
try {
int _alt;
setState(275);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ABSTRACT:
case CLASS:
case ENUM:
case FINAL:
case INTERFACE:
case PRIVATE:
case PROTECTED:
case PUBLIC:
case RECORD:
case STATIC:
case STRICTFP:
case AT:
case COMMENT:
enterOuterAlt(_localctx, 1);
{
setState(259);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMENT) {
{
setState(258);
match(COMMENT);
}
}
setState(264);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,7,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(261);
classOrInterfaceModifier();
}
}
}
setState(266);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,7,_ctx);
}
setState(272);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CLASS:
{
setState(267);
classDeclaration();
}
break;
case ENUM:
{
setState(268);
enumDeclaration();
}
break;
case INTERFACE:
{
setState(269);
interfaceDeclaration();
}
break;
case AT:
{
setState(270);
annotationTypeDeclaration();
}
break;
case RECORD:
{
setState(271);
recordDeclaration();
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case SEMI:
enterOuterAlt(_localctx, 2);
{
setState(274);
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;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterModifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitModifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitModifier(this);
else return visitor.visitChildren(this);
}
}
public final ModifierContext modifier() throws RecognitionException {
ModifierContext _localctx = new ModifierContext(_ctx, getState());
enterRule(_localctx, 10, RULE_modifier);
try {
setState(282);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ABSTRACT:
case FINAL:
case PRIVATE:
case PROTECTED:
case PUBLIC:
case STATIC:
case STRICTFP:
case AT:
enterOuterAlt(_localctx, 1);
{
setState(277);
classOrInterfaceModifier();
}
break;
case NATIVE:
enterOuterAlt(_localctx, 2);
{
setState(278);
match(NATIVE);
}
break;
case SYNCHRONIZED:
enterOuterAlt(_localctx, 3);
{
setState(279);
match(SYNCHRONIZED);
}
break;
case TRANSIENT:
enterOuterAlt(_localctx, 4);
{
setState(280);
match(TRANSIENT);
}
break;
case VOLATILE:
enterOuterAlt(_localctx, 5);
{
setState(281);
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;
}
@SuppressWarnings("CheckReturnValue")
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 ClassOrInterfaceModifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classOrInterfaceModifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterClassOrInterfaceModifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitClassOrInterfaceModifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitClassOrInterfaceModifier(this);
else return visitor.visitChildren(this);
}
}
public final ClassOrInterfaceModifierContext classOrInterfaceModifier() throws RecognitionException {
ClassOrInterfaceModifierContext _localctx = new ClassOrInterfaceModifierContext(_ctx, getState());
enterRule(_localctx, 12, RULE_classOrInterfaceModifier);
try {
setState(292);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AT:
enterOuterAlt(_localctx, 1);
{
setState(284);
annotation();
}
break;
case PUBLIC:
enterOuterAlt(_localctx, 2);
{
setState(285);
match(PUBLIC);
}
break;
case PROTECTED:
enterOuterAlt(_localctx, 3);
{
setState(286);
match(PROTECTED);
}
break;
case PRIVATE:
enterOuterAlt(_localctx, 4);
{
setState(287);
match(PRIVATE);
}
break;
case STATIC:
enterOuterAlt(_localctx, 5);
{
setState(288);
match(STATIC);
}
break;
case ABSTRACT:
enterOuterAlt(_localctx, 6);
{
setState(289);
match(ABSTRACT);
}
break;
case FINAL:
enterOuterAlt(_localctx, 7);
{
setState(290);
match(FINAL);
}
break;
case STRICTFP:
enterOuterAlt(_localctx, 8);
{
setState(291);
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;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterVariableModifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitVariableModifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitVariableModifier(this);
else return visitor.visitChildren(this);
}
}
public final VariableModifierContext variableModifier() throws RecognitionException {
VariableModifierContext _localctx = new VariableModifierContext(_ctx, getState());
enterRule(_localctx, 14, RULE_variableModifier);
try {
setState(296);
_errHandler.sync(this);
switch (_input.LA(1)) {
case FINAL:
enterOuterAlt(_localctx, 1);
{
setState(294);
match(FINAL);
}
break;
case AT:
enterOuterAlt(_localctx, 2);
{
setState(295);
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;
}
@SuppressWarnings("CheckReturnValue")
public static class RecordDeclarationContext extends ParserRuleContext {
public TerminalNode RECORD() { return getToken(JavaParser.RECORD, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public FormalParametersContext formalParameters() {
return getRuleContext(FormalParametersContext.class,0);
}
public ClassBodyContext classBody() {
return getRuleContext(ClassBodyContext.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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterRecordDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitRecordDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitRecordDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final RecordDeclarationContext recordDeclaration() throws RecognitionException {
RecordDeclarationContext _localctx = new RecordDeclarationContext(_ctx, getState());
enterRule(_localctx, 16, RULE_recordDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(298);
match(RECORD);
setState(299);
identifier();
setState(300);
formalParameters();
setState(303);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IMPLEMENTS) {
{
setState(301);
match(IMPLEMENTS);
setState(302);
typeList();
}
}
setState(305);
classBody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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 TypeListContext typeList() {
return getRuleContext(TypeListContext.class,0);
}
public ClassDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterClassDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitClassDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitClassDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final ClassDeclarationContext classDeclaration() throws RecognitionException {
ClassDeclarationContext _localctx = new ClassDeclarationContext(_ctx, getState());
enterRule(_localctx, 18, RULE_classDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(307);
match(CLASS);
setState(308);
identifier();
setState(310);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(309);
typeParameters();
}
}
setState(314);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXTENDS) {
{
setState(312);
match(EXTENDS);
setState(313);
typeType();
}
}
setState(318);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IMPLEMENTS) {
{
setState(316);
match(IMPLEMENTS);
setState(317);
typeList();
}
}
setState(320);
classBody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterTypeParameters(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitTypeParameters(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitTypeParameters(this);
else return visitor.visitChildren(this);
}
}
public final TypeParametersContext typeParameters() throws RecognitionException {
TypeParametersContext _localctx = new TypeParametersContext(_ctx, getState());
enterRule(_localctx, 20, RULE_typeParameters);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(322);
match(LT);
setState(323);
typeParameter();
setState(328);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(324);
match(COMMA);
setState(325);
typeParameter();
}
}
setState(330);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(331);
match(GT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterTypeParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitTypeParameter(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitTypeParameter(this);
else return visitor.visitChildren(this);
}
}
public final TypeParameterContext typeParameter() throws RecognitionException {
TypeParameterContext _localctx = new TypeParameterContext(_ctx, getState());
enterRule(_localctx, 22, RULE_typeParameter);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(336);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(333);
annotation();
}
}
setState(338);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(339);
identifier();
setState(342);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXTENDS) {
{
setState(340);
match(EXTENDS);
setState(341);
typeBound();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterTypeBound(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitTypeBound(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitTypeBound(this);
else return visitor.visitChildren(this);
}
}
public final TypeBoundContext typeBound() throws RecognitionException {
TypeBoundContext _localctx = new TypeBoundContext(_ctx, getState());
enterRule(_localctx, 24, RULE_typeBound);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(344);
typeType();
setState(349);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==BITAND) {
{
{
setState(345);
match(BITAND);
setState(346);
typeType();
}
}
setState(351);
_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;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterEnumDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitEnumDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitEnumDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final EnumDeclarationContext enumDeclaration() throws RecognitionException {
EnumDeclarationContext _localctx = new EnumDeclarationContext(_ctx, getState());
enterRule(_localctx, 26, RULE_enumDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(352);
match(ENUM);
setState(353);
identifier();
setState(356);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IMPLEMENTS) {
{
setState(354);
match(IMPLEMENTS);
setState(355);
typeList();
}
}
setState(358);
match(LBRACE);
setState(360);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RECORD || _la==AT || _la==IDENTIFIER) {
{
setState(359);
enumConstants();
}
}
setState(363);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(362);
match(COMMA);
}
}
setState(366);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SEMI) {
{
setState(365);
enumBodyDeclarations();
}
}
setState(368);
match(RBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterEnumConstants(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitEnumConstants(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitEnumConstants(this);
else return visitor.visitChildren(this);
}
}
public final EnumConstantsContext enumConstants() throws RecognitionException {
EnumConstantsContext _localctx = new EnumConstantsContext(_ctx, getState());
enterRule(_localctx, 28, RULE_enumConstants);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(370);
enumConstant();
setState(375);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,25,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(371);
match(COMMA);
setState(372);
enumConstant();
}
}
}
setState(377);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,25,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterEnumConstant(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitEnumConstant(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitEnumConstant(this);
else return visitor.visitChildren(this);
}
}
public final EnumConstantContext enumConstant() throws RecognitionException {
EnumConstantContext _localctx = new EnumConstantContext(_ctx, getState());
enterRule(_localctx, 30, RULE_enumConstant);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(381);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(378);
annotation();
}
}
setState(383);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(384);
identifier();
setState(386);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(385);
arguments();
}
}
setState(389);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LBRACE) {
{
setState(388);
classBody();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterEnumBodyDeclarations(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitEnumBodyDeclarations(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitEnumBodyDeclarations(this);
else return visitor.visitChildren(this);
}
}
public final EnumBodyDeclarationsContext enumBodyDeclarations() throws RecognitionException {
EnumBodyDeclarationsContext _localctx = new EnumBodyDeclarationsContext(_ctx, getState());
enterRule(_localctx, 32, RULE_enumBodyDeclarations);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(391);
match(SEMI);
setState(395);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1840438450668330L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 360639813911057L) != 0)) {
{
{
setState(392);
classBodyDeclaration();
}
}
setState(397);
_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;
}
@SuppressWarnings("CheckReturnValue")
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 TypeListContext typeList() {
return getRuleContext(TypeListContext.class,0);
}
public InterfaceDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_interfaceDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterInterfaceDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitInterfaceDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitInterfaceDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final InterfaceDeclarationContext interfaceDeclaration() throws RecognitionException {
InterfaceDeclarationContext _localctx = new InterfaceDeclarationContext(_ctx, getState());
enterRule(_localctx, 34, RULE_interfaceDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(398);
match(INTERFACE);
setState(399);
identifier();
setState(401);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(400);
typeParameters();
}
}
setState(405);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXTENDS) {
{
setState(403);
match(EXTENDS);
setState(404);
typeList();
}
}
setState(407);
interfaceBody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterClassBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitClassBody(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitClassBody(this);
else return visitor.visitChildren(this);
}
}
public final ClassBodyContext classBody() throws RecognitionException {
ClassBodyContext _localctx = new ClassBodyContext(_ctx, getState());
enterRule(_localctx, 36, RULE_classBody);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(409);
match(LBRACE);
setState(413);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1840438450668330L) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & 360639813911057L) != 0)) {
{
{
setState(410);
classBodyDeclaration();
}
}
setState(415);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(416);
match(RBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterInterfaceBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitInterfaceBody(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitInterfaceBody(this);
else return visitor.visitChildren(this);
}
}
public final InterfaceBodyContext interfaceBody() throws RecognitionException {
InterfaceBodyContext _localctx = new InterfaceBodyContext(_ctx, getState());
enterRule(_localctx, 38, RULE_interfaceBody);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(418);
match(LBRACE);
setState(422);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1840438450672426L) != 0) || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & 18141941858337L) != 0)) {
{
{
setState(419);
interfaceBodyDeclaration();
}
}
setState(424);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(425);
match(RBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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 TerminalNode COMMENT() { return getToken(JavaParser.COMMENT, 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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterClassBodyDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitClassBodyDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitClassBodyDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final ClassBodyDeclarationContext classBodyDeclaration() throws RecognitionException {
ClassBodyDeclarationContext _localctx = new ClassBodyDeclarationContext(_ctx, getState());
enterRule(_localctx, 40, RULE_classBodyDeclaration);
int _la;
try {
int _alt;
setState(442);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(427);
match(SEMI);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(429);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==STATIC) {
{
setState(428);
match(STATIC);
}
}
setState(431);
block();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(433);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMENT) {
{
setState(432);
match(COMMENT);
}
}
setState(438);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,36,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(435);
modifier();
}
}
}
setState(440);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,36,_ctx);
}
setState(441);
memberDeclaration();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MemberDeclarationContext extends ParserRuleContext {
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 RecordConstructorDeclarationContext recordConstructorDeclaration() {
return getRuleContext(RecordConstructorDeclarationContext.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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterMemberDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitMemberDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitMemberDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final MemberDeclarationContext memberDeclaration() throws RecognitionException {
MemberDeclarationContext _localctx = new MemberDeclarationContext(_ctx, getState());
enterRule(_localctx, 42, RULE_memberDeclaration);
try {
setState(454);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,38,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(444);
methodDeclaration();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(445);
genericMethodDeclaration();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(446);
fieldDeclaration();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(447);
constructorDeclaration();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(448);
genericConstructorDeclaration();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(449);
recordConstructorDeclaration();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(450);
interfaceDeclaration();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(451);
annotationTypeDeclaration();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(452);
classDeclaration();
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(453);
enumDeclaration();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterMethodDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitMethodDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitMethodDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final MethodDeclarationContext methodDeclaration() throws RecognitionException {
MethodDeclarationContext _localctx = new MethodDeclarationContext(_ctx, getState());
enterRule(_localctx, 44, RULE_methodDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(456);
typeTypeOrVoid();
setState(457);
identifier();
setState(458);
formalParameters();
setState(463);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACK) {
{
{
setState(459);
match(LBRACK);
setState(460);
match(RBRACK);
}
}
setState(465);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(468);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==THROWS) {
{
setState(466);
match(THROWS);
setState(467);
qualifiedNameList();
}
}
setState(470);
methodBody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterMethodBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitMethodBody(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitMethodBody(this);
else return visitor.visitChildren(this);
}
}
public final MethodBodyContext methodBody() throws RecognitionException {
MethodBodyContext _localctx = new MethodBodyContext(_ctx, getState());
enterRule(_localctx, 46, RULE_methodBody);
try {
setState(474);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LBRACE:
enterOuterAlt(_localctx, 1);
{
setState(472);
block();
}
break;
case SEMI:
enterOuterAlt(_localctx, 2);
{
setState(473);
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;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterTypeTypeOrVoid(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitTypeTypeOrVoid(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitTypeTypeOrVoid(this);
else return visitor.visitChildren(this);
}
}
public final TypeTypeOrVoidContext typeTypeOrVoid() throws RecognitionException {
TypeTypeOrVoidContext _localctx = new TypeTypeOrVoidContext(_ctx, getState());
enterRule(_localctx, 48, RULE_typeTypeOrVoid);
try {
setState(478);
_errHandler.sync(this);
switch (_input.LA(1)) {
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case RECORD:
case SHORT:
case AT:
case IDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(476);
typeType();
}
break;
case VOID:
enterOuterAlt(_localctx, 2);
{
setState(477);
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;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterGenericMethodDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitGenericMethodDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitGenericMethodDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final GenericMethodDeclarationContext genericMethodDeclaration() throws RecognitionException {
GenericMethodDeclarationContext _localctx = new GenericMethodDeclarationContext(_ctx, getState());
enterRule(_localctx, 50, RULE_genericMethodDeclaration);
try {
enterOuterAlt(_localctx, 1);
{
setState(480);
typeParameters();
setState(481);
methodDeclaration();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterGenericConstructorDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitGenericConstructorDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitGenericConstructorDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final GenericConstructorDeclarationContext genericConstructorDeclaration() throws RecognitionException {
GenericConstructorDeclarationContext _localctx = new GenericConstructorDeclarationContext(_ctx, getState());
enterRule(_localctx, 52, RULE_genericConstructorDeclaration);
try {
enterOuterAlt(_localctx, 1);
{
setState(483);
typeParameters();
setState(484);
constructorDeclaration();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterConstructorDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitConstructorDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitConstructorDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final ConstructorDeclarationContext constructorDeclaration() throws RecognitionException {
ConstructorDeclarationContext _localctx = new ConstructorDeclarationContext(_ctx, getState());
enterRule(_localctx, 54, RULE_constructorDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(486);
identifier();
setState(487);
formalParameters();
setState(490);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==THROWS) {
{
setState(488);
match(THROWS);
setState(489);
qualifiedNameList();
}
}
setState(492);
((ConstructorDeclarationContext)_localctx).constructorBody = block();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RecordConstructorDeclarationContext extends ParserRuleContext {
public BlockContext constructorBody;
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.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 RecordConstructorDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_recordConstructorDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterRecordConstructorDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitRecordConstructorDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitRecordConstructorDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final RecordConstructorDeclarationContext recordConstructorDeclaration() throws RecognitionException {
RecordConstructorDeclarationContext _localctx = new RecordConstructorDeclarationContext(_ctx, getState());
enterRule(_localctx, 56, RULE_recordConstructorDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(494);
identifier();
setState(497);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==THROWS) {
{
setState(495);
match(THROWS);
setState(496);
qualifiedNameList();
}
}
setState(499);
((RecordConstructorDeclarationContext)_localctx).constructorBody = block();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterFieldDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitFieldDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitFieldDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final FieldDeclarationContext fieldDeclaration() throws RecognitionException {
FieldDeclarationContext _localctx = new FieldDeclarationContext(_ctx, getState());
enterRule(_localctx, 58, RULE_fieldDeclaration);
try {
enterOuterAlt(_localctx, 1);
{
setState(501);
typeType();
setState(502);
variableDeclarators();
setState(503);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterInterfaceBodyDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitInterfaceBodyDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitInterfaceBodyDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final InterfaceBodyDeclarationContext interfaceBodyDeclaration() throws RecognitionException {
InterfaceBodyDeclarationContext _localctx = new InterfaceBodyDeclarationContext(_ctx, getState());
enterRule(_localctx, 60, RULE_interfaceBodyDeclaration);
try {
int _alt;
setState(513);
_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 RECORD:
case SHORT:
case STATIC:
case STRICTFP:
case SYNCHRONIZED:
case TRANSIENT:
case VOID:
case VOLATILE:
case LT:
case AT:
case IDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(508);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,45,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(505);
modifier();
}
}
}
setState(510);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,45,_ctx);
}
setState(511);
interfaceMemberDeclaration();
}
break;
case SEMI:
enterOuterAlt(_localctx, 2);
{
setState(512);
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;
}
@SuppressWarnings("CheckReturnValue")
public static class InterfaceMemberDeclarationContext extends ParserRuleContext {
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterInterfaceMemberDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitInterfaceMemberDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitInterfaceMemberDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final InterfaceMemberDeclarationContext interfaceMemberDeclaration() throws RecognitionException {
InterfaceMemberDeclarationContext _localctx = new InterfaceMemberDeclarationContext(_ctx, getState());
enterRule(_localctx, 62, RULE_interfaceMemberDeclaration);
try {
setState(522);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,47,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(515);
constDeclaration();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(516);
interfaceMethodDeclaration();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(517);
genericInterfaceMethodDeclaration();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(518);
interfaceDeclaration();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(519);
annotationTypeDeclaration();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(520);
classDeclaration();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(521);
enumDeclaration();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterConstDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitConstDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitConstDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final ConstDeclarationContext constDeclaration() throws RecognitionException {
ConstDeclarationContext _localctx = new ConstDeclarationContext(_ctx, getState());
enterRule(_localctx, 64, RULE_constDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(524);
typeType();
setState(525);
constantDeclarator();
setState(530);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(526);
match(COMMA);
setState(527);
constantDeclarator();
}
}
setState(532);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(533);
match(SEMI);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterConstantDeclarator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitConstantDeclarator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitConstantDeclarator(this);
else return visitor.visitChildren(this);
}
}
public final ConstantDeclaratorContext constantDeclarator() throws RecognitionException {
ConstantDeclaratorContext _localctx = new ConstantDeclaratorContext(_ctx, getState());
enterRule(_localctx, 66, RULE_constantDeclarator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(535);
identifier();
setState(540);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACK) {
{
{
setState(536);
match(LBRACK);
setState(537);
match(RBRACK);
}
}
setState(542);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(543);
match(ASSIGN);
setState(544);
variableInitializer();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class InterfaceMethodDeclarationContext extends ParserRuleContext {
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 TypeTypeOrVoidContext typeTypeOrVoid() {
return getRuleContext(TypeTypeOrVoidContext.class,0);
}
public TypeParametersContext typeParameters() {
return getRuleContext(TypeParametersContext.class,0);
}
public List interfaceMethodModifier() {
return getRuleContexts(InterfaceMethodModifierContext.class);
}
public InterfaceMethodModifierContext interfaceMethodModifier(int i) {
return getRuleContext(InterfaceMethodModifierContext.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 List annotation() {
return getRuleContexts(AnnotationContext.class);
}
public AnnotationContext annotation(int i) {
return getRuleContext(AnnotationContext.class,i);
}
public InterfaceMethodDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_interfaceMethodDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterInterfaceMethodDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitInterfaceMethodDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitInterfaceMethodDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final InterfaceMethodDeclarationContext interfaceMethodDeclaration() throws RecognitionException {
InterfaceMethodDeclarationContext _localctx = new InterfaceMethodDeclarationContext(_ctx, getState());
enterRule(_localctx, 68, RULE_interfaceMethodDeclaration);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(549);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,50,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(546);
interfaceMethodModifier();
}
}
}
setState(551);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,50,_ctx);
}
setState(562);
_errHandler.sync(this);
switch (_input.LA(1)) {
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case RECORD:
case SHORT:
case VOID:
case AT:
case IDENTIFIER:
{
setState(552);
typeTypeOrVoid();
}
break;
case LT:
{
setState(553);
typeParameters();
setState(557);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,51,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(554);
annotation();
}
}
}
setState(559);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,51,_ctx);
}
setState(560);
typeTypeOrVoid();
}
break;
default:
throw new NoViableAltException(this);
}
setState(564);
identifier();
setState(565);
formalParameters();
setState(570);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACK) {
{
{
setState(566);
match(LBRACK);
setState(567);
match(RBRACK);
}
}
setState(572);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(575);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==THROWS) {
{
setState(573);
match(THROWS);
setState(574);
qualifiedNameList();
}
}
setState(577);
methodBody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterInterfaceMethodModifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitInterfaceMethodModifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitInterfaceMethodModifier(this);
else return visitor.visitChildren(this);
}
}
public final InterfaceMethodModifierContext interfaceMethodModifier() throws RecognitionException {
InterfaceMethodModifierContext _localctx = new InterfaceMethodModifierContext(_ctx, getState());
enterRule(_localctx, 70, RULE_interfaceMethodModifier);
try {
setState(585);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AT:
enterOuterAlt(_localctx, 1);
{
setState(579);
annotation();
}
break;
case PUBLIC:
enterOuterAlt(_localctx, 2);
{
setState(580);
match(PUBLIC);
}
break;
case ABSTRACT:
enterOuterAlt(_localctx, 3);
{
setState(581);
match(ABSTRACT);
}
break;
case DEFAULT:
enterOuterAlt(_localctx, 4);
{
setState(582);
match(DEFAULT);
}
break;
case STATIC:
enterOuterAlt(_localctx, 5);
{
setState(583);
match(STATIC);
}
break;
case STRICTFP:
enterOuterAlt(_localctx, 6);
{
setState(584);
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;
}
@SuppressWarnings("CheckReturnValue")
public static class GenericInterfaceMethodDeclarationContext extends ParserRuleContext {
public TypeParametersContext typeParameters() {
return getRuleContext(TypeParametersContext.class,0);
}
public InterfaceMethodDeclarationContext interfaceMethodDeclaration() {
return getRuleContext(InterfaceMethodDeclarationContext.class,0);
}
public GenericInterfaceMethodDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_genericInterfaceMethodDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterGenericInterfaceMethodDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitGenericInterfaceMethodDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitGenericInterfaceMethodDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final GenericInterfaceMethodDeclarationContext genericInterfaceMethodDeclaration() throws RecognitionException {
GenericInterfaceMethodDeclarationContext _localctx = new GenericInterfaceMethodDeclarationContext(_ctx, getState());
enterRule(_localctx, 72, RULE_genericInterfaceMethodDeclaration);
try {
enterOuterAlt(_localctx, 1);
{
setState(587);
typeParameters();
setState(588);
interfaceMethodDeclaration();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterVariableDeclarators(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitVariableDeclarators(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitVariableDeclarators(this);
else return visitor.visitChildren(this);
}
}
public final VariableDeclaratorsContext variableDeclarators() throws RecognitionException {
VariableDeclaratorsContext _localctx = new VariableDeclaratorsContext(_ctx, getState());
enterRule(_localctx, 74, RULE_variableDeclarators);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(590);
variableDeclarator();
setState(595);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(591);
match(COMMA);
setState(592);
variableDeclarator();
}
}
setState(597);
_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;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterVariableDeclarator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitVariableDeclarator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitVariableDeclarator(this);
else return visitor.visitChildren(this);
}
}
public final VariableDeclaratorContext variableDeclarator() throws RecognitionException {
VariableDeclaratorContext _localctx = new VariableDeclaratorContext(_ctx, getState());
enterRule(_localctx, 76, RULE_variableDeclarator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(598);
variableDeclaratorId();
setState(601);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ASSIGN) {
{
setState(599);
match(ASSIGN);
setState(600);
variableInitializer();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterVariableDeclaratorId(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitVariableDeclaratorId(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitVariableDeclaratorId(this);
else return visitor.visitChildren(this);
}
}
public final VariableDeclaratorIdContext variableDeclaratorId() throws RecognitionException {
VariableDeclaratorIdContext _localctx = new VariableDeclaratorIdContext(_ctx, getState());
enterRule(_localctx, 78, RULE_variableDeclaratorId);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(603);
identifier();
setState(608);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACK) {
{
{
setState(604);
match(LBRACK);
setState(605);
match(RBRACK);
}
}
setState(610);
_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;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterVariableInitializer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitVariableInitializer(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitVariableInitializer(this);
else return visitor.visitChildren(this);
}
}
public final VariableInitializerContext variableInitializer() throws RecognitionException {
VariableInitializerContext _localctx = new VariableInitializerContext(_ctx, getState());
enterRule(_localctx, 80, RULE_variableInitializer);
try {
setState(613);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LBRACE:
enterOuterAlt(_localctx, 1);
{
setState(611);
arrayInitializer();
}
break;
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case NEW:
case RECORD:
case SHORT:
case SUPER:
case SWITCH:
case THIS:
case VOID:
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_LITERAL:
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(612);
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;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterArrayInitializer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitArrayInitializer(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitArrayInitializer(this);
else return visitor.visitChildren(this);
}
}
public final ArrayInitializerContext arrayInitializer() throws RecognitionException {
ArrayInitializerContext _localctx = new ArrayInitializerContext(_ctx, getState());
enterRule(_localctx, 82, RULE_arrayInitializer);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(615);
match(LBRACE);
setState(627);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -8419713628487384L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1161084341860357L) != 0)) {
{
setState(616);
variableInitializer();
setState(621);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,60,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(617);
match(COMMA);
setState(618);
variableInitializer();
}
}
}
setState(623);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,60,_ctx);
}
setState(625);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(624);
match(COMMA);
}
}
}
}
setState(629);
match(RBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ClassOrInterfaceTypeContext extends ParserRuleContext {
public List identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public List typeArguments() {
return getRuleContexts(TypeArgumentsContext.class);
}
public TypeArgumentsContext typeArguments(int i) {
return getRuleContext(TypeArgumentsContext.class,i);
}
public List DOT() { return getTokens(JavaParser.DOT); }
public TerminalNode DOT(int i) {
return getToken(JavaParser.DOT, i);
}
public ClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classOrInterfaceType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterClassOrInterfaceType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitClassOrInterfaceType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitClassOrInterfaceType(this);
else return visitor.visitChildren(this);
}
}
public final ClassOrInterfaceTypeContext classOrInterfaceType() throws RecognitionException {
ClassOrInterfaceTypeContext _localctx = new ClassOrInterfaceTypeContext(_ctx, getState());
enterRule(_localctx, 84, RULE_classOrInterfaceType);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(631);
identifier();
setState(633);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,63,_ctx) ) {
case 1:
{
setState(632);
typeArguments();
}
break;
}
setState(642);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,65,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(635);
match(DOT);
setState(636);
identifier();
setState(638);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,64,_ctx) ) {
case 1:
{
setState(637);
typeArguments();
}
break;
}
}
}
}
setState(644);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,65,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TypeArgumentContext extends ParserRuleContext {
public TypeTypeContext typeType() {
return getRuleContext(TypeTypeContext.class,0);
}
public TerminalNode QUESTION() { return getToken(JavaParser.QUESTION, 0); }
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterTypeArgument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitTypeArgument(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitTypeArgument(this);
else return visitor.visitChildren(this);
}
}
public final TypeArgumentContext typeArgument() throws RecognitionException {
TypeArgumentContext _localctx = new TypeArgumentContext(_ctx, getState());
enterRule(_localctx, 86, RULE_typeArgument);
int _la;
try {
setState(651);
_errHandler.sync(this);
switch (_input.LA(1)) {
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case RECORD:
case SHORT:
case AT:
case IDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(645);
typeType();
}
break;
case QUESTION:
enterOuterAlt(_localctx, 2);
{
setState(646);
match(QUESTION);
setState(649);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXTENDS || _la==SUPER) {
{
setState(647);
_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(648);
typeType();
}
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterQualifiedNameList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitQualifiedNameList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitQualifiedNameList(this);
else return visitor.visitChildren(this);
}
}
public final QualifiedNameListContext qualifiedNameList() throws RecognitionException {
QualifiedNameListContext _localctx = new QualifiedNameListContext(_ctx, getState());
enterRule(_localctx, 88, RULE_qualifiedNameList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(653);
qualifiedName();
setState(658);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(654);
match(COMMA);
setState(655);
qualifiedName();
}
}
setState(660);
_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;
}
@SuppressWarnings("CheckReturnValue")
public static class FormalParametersContext extends ParserRuleContext {
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 FormalParametersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_formalParameters; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterFormalParameters(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitFormalParameters(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitFormalParameters(this);
else return visitor.visitChildren(this);
}
}
public final FormalParametersContext formalParameters() throws RecognitionException {
FormalParametersContext _localctx = new FormalParametersContext(_ctx, getState());
enterRule(_localctx, 90, RULE_formalParameters);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(661);
match(LPAREN);
setState(663);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 344269799720L) != 0) || _la==AT || _la==IDENTIFIER) {
{
setState(662);
formalParameterList();
}
}
setState(665);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterFormalParameterList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitFormalParameterList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitFormalParameterList(this);
else return visitor.visitChildren(this);
}
}
public final FormalParameterListContext formalParameterList() throws RecognitionException {
FormalParameterListContext _localctx = new FormalParameterListContext(_ctx, getState());
enterRule(_localctx, 92, RULE_formalParameterList);
int _la;
try {
int _alt;
setState(680);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,72,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(667);
formalParameter();
setState(672);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,70,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(668);
match(COMMA);
setState(669);
formalParameter();
}
}
}
setState(674);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,70,_ctx);
}
setState(677);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(675);
match(COMMA);
setState(676);
lastFormalParameter();
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(679);
lastFormalParameter();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterFormalParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitFormalParameter(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitFormalParameter(this);
else return visitor.visitChildren(this);
}
}
public final FormalParameterContext formalParameter() throws RecognitionException {
FormalParameterContext _localctx = new FormalParameterContext(_ctx, getState());
enterRule(_localctx, 94, RULE_formalParameter);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(685);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,73,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(682);
variableModifier();
}
}
}
setState(687);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,73,_ctx);
}
setState(688);
typeType();
setState(689);
variableDeclaratorId();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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 LastFormalParameterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lastFormalParameter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterLastFormalParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitLastFormalParameter(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitLastFormalParameter(this);
else return visitor.visitChildren(this);
}
}
public final LastFormalParameterContext lastFormalParameter() throws RecognitionException {
LastFormalParameterContext _localctx = new LastFormalParameterContext(_ctx, getState());
enterRule(_localctx, 96, RULE_lastFormalParameter);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(694);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,74,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(691);
variableModifier();
}
}
}
setState(696);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,74,_ctx);
}
setState(697);
typeType();
setState(698);
match(ELLIPSIS);
setState(699);
variableDeclaratorId();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterQualifiedName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitQualifiedName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitQualifiedName(this);
else return visitor.visitChildren(this);
}
}
public final QualifiedNameContext qualifiedName() throws RecognitionException {
QualifiedNameContext _localctx = new QualifiedNameContext(_ctx, getState());
enterRule(_localctx, 98, RULE_qualifiedName);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(701);
identifier();
setState(706);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,75,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(702);
match(DOT);
setState(703);
identifier();
}
}
}
setState(708);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,75,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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 TEXT_BLOCK_LITERAL() { return getToken(JavaParser.TEXT_BLOCK_LITERAL, 0); }
public TerminalNode BOOL_LITERAL() { return getToken(JavaParser.BOOL_LITERAL, 0); }
public TerminalNode NULL_LITERAL() { return getToken(JavaParser.NULL_LITERAL, 0); }
public LiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_literal; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitLiteral(this);
else return visitor.visitChildren(this);
}
}
public final LiteralContext literal() throws RecognitionException {
LiteralContext _localctx = new LiteralContext(_ctx, getState());
enterRule(_localctx, 100, RULE_literal);
try {
setState(716);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DECIMAL_LITERAL:
case HEX_LITERAL:
case OCT_LITERAL:
case BINARY_LITERAL:
enterOuterAlt(_localctx, 1);
{
setState(709);
integerLiteral();
}
break;
case FLOAT_LITERAL:
case HEX_FLOAT_LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(710);
floatLiteral();
}
break;
case CHAR_LITERAL:
enterOuterAlt(_localctx, 3);
{
setState(711);
match(CHAR_LITERAL);
}
break;
case STRING_LITERAL:
enterOuterAlt(_localctx, 4);
{
setState(712);
match(STRING_LITERAL);
}
break;
case TEXT_BLOCK_LITERAL:
enterOuterAlt(_localctx, 5);
{
setState(713);
match(TEXT_BLOCK_LITERAL);
}
break;
case BOOL_LITERAL:
enterOuterAlt(_localctx, 6);
{
setState(714);
match(BOOL_LITERAL);
}
break;
case NULL_LITERAL:
enterOuterAlt(_localctx, 7);
{
setState(715);
match(NULL_LITERAL);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterIntegerLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitIntegerLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitIntegerLiteral(this);
else return visitor.visitChildren(this);
}
}
public final IntegerLiteralContext integerLiteral() throws RecognitionException {
IntegerLiteralContext _localctx = new IntegerLiteralContext(_ctx, getState());
enterRule(_localctx, 102, RULE_integerLiteral);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(718);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 135107988821114880L) != 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;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterFloatLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitFloatLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitFloatLiteral(this);
else return visitor.visitChildren(this);
}
}
public final FloatLiteralContext floatLiteral() throws RecognitionException {
FloatLiteralContext _localctx = new FloatLiteralContext(_ctx, getState());
enterRule(_localctx, 104, RULE_floatLiteral);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(720);
_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;
}
@SuppressWarnings("CheckReturnValue")
public static class AnnotationContext extends ParserRuleContext {
public TerminalNode AT() { return getToken(JavaParser.AT, 0); }
public QualifiedNameContext qualifiedName() {
return getRuleContext(QualifiedNameContext.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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterAnnotation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitAnnotation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitAnnotation(this);
else return visitor.visitChildren(this);
}
}
public final AnnotationContext annotation() throws RecognitionException {
AnnotationContext _localctx = new AnnotationContext(_ctx, getState());
enterRule(_localctx, 106, RULE_annotation);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(722);
match(AT);
setState(723);
qualifiedName();
setState(730);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(724);
match(LPAREN);
setState(727);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) {
case 1:
{
setState(725);
elementValuePairs();
}
break;
case 2:
{
setState(726);
elementValue();
}
break;
}
setState(729);
match(RPAREN);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterElementValuePairs(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitElementValuePairs(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitElementValuePairs(this);
else return visitor.visitChildren(this);
}
}
public final ElementValuePairsContext elementValuePairs() throws RecognitionException {
ElementValuePairsContext _localctx = new ElementValuePairsContext(_ctx, getState());
enterRule(_localctx, 108, RULE_elementValuePairs);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(732);
elementValuePair();
setState(737);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(733);
match(COMMA);
setState(734);
elementValuePair();
}
}
setState(739);
_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;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterElementValuePair(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitElementValuePair(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitElementValuePair(this);
else return visitor.visitChildren(this);
}
}
public final ElementValuePairContext elementValuePair() throws RecognitionException {
ElementValuePairContext _localctx = new ElementValuePairContext(_ctx, getState());
enterRule(_localctx, 110, RULE_elementValuePair);
try {
enterOuterAlt(_localctx, 1);
{
setState(740);
identifier();
setState(741);
match(ASSIGN);
setState(742);
elementValue();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterElementValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitElementValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitElementValue(this);
else return visitor.visitChildren(this);
}
}
public final ElementValueContext elementValue() throws RecognitionException {
ElementValueContext _localctx = new ElementValueContext(_ctx, getState());
enterRule(_localctx, 112, RULE_elementValue);
try {
setState(747);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(744);
expression(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(745);
annotation();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(746);
elementValueArrayInitializer();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterElementValueArrayInitializer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitElementValueArrayInitializer(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitElementValueArrayInitializer(this);
else return visitor.visitChildren(this);
}
}
public final ElementValueArrayInitializerContext elementValueArrayInitializer() throws RecognitionException {
ElementValueArrayInitializerContext _localctx = new ElementValueArrayInitializerContext(_ctx, getState());
enterRule(_localctx, 114, RULE_elementValueArrayInitializer);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(749);
match(LBRACE);
setState(758);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -8419713628487384L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1161084341860357L) != 0)) {
{
setState(750);
elementValue();
setState(755);
_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(751);
match(COMMA);
setState(752);
elementValue();
}
}
}
setState(757);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,81,_ctx);
}
}
}
setState(761);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(760);
match(COMMA);
}
}
setState(763);
match(RBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterAnnotationTypeDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitAnnotationTypeDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitAnnotationTypeDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final AnnotationTypeDeclarationContext annotationTypeDeclaration() throws RecognitionException {
AnnotationTypeDeclarationContext _localctx = new AnnotationTypeDeclarationContext(_ctx, getState());
enterRule(_localctx, 116, RULE_annotationTypeDeclaration);
try {
enterOuterAlt(_localctx, 1);
{
setState(765);
match(AT);
setState(766);
match(INTERFACE);
setState(767);
identifier();
setState(768);
annotationTypeBody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterAnnotationTypeBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitAnnotationTypeBody(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitAnnotationTypeBody(this);
else return visitor.visitChildren(this);
}
}
public final AnnotationTypeBodyContext annotationTypeBody() throws RecognitionException {
AnnotationTypeBodyContext _localctx = new AnnotationTypeBodyContext(_ctx, getState());
enterRule(_localctx, 118, RULE_annotationTypeBody);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(770);
match(LBRACE);
setState(774);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1277488497247018L) != 0) || ((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & 18141941858305L) != 0)) {
{
{
setState(771);
annotationTypeElementDeclaration();
}
}
setState(776);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(777);
match(RBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterAnnotationTypeElementDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitAnnotationTypeElementDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitAnnotationTypeElementDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final AnnotationTypeElementDeclarationContext annotationTypeElementDeclaration() throws RecognitionException {
AnnotationTypeElementDeclarationContext _localctx = new AnnotationTypeElementDeclarationContext(_ctx, getState());
enterRule(_localctx, 120, RULE_annotationTypeElementDeclaration);
try {
int _alt;
setState(787);
_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 RECORD:
case SHORT:
case STATIC:
case STRICTFP:
case SYNCHRONIZED:
case TRANSIENT:
case VOLATILE:
case AT:
case IDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(782);
_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(779);
modifier();
}
}
}
setState(784);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,85,_ctx);
}
setState(785);
annotationTypeElementRest();
}
break;
case SEMI:
enterOuterAlt(_localctx, 2);
{
setState(786);
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;
}
@SuppressWarnings("CheckReturnValue")
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 AnnotationTypeElementRestContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotationTypeElementRest; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterAnnotationTypeElementRest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitAnnotationTypeElementRest(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitAnnotationTypeElementRest(this);
else return visitor.visitChildren(this);
}
}
public final AnnotationTypeElementRestContext annotationTypeElementRest() throws RecognitionException {
AnnotationTypeElementRestContext _localctx = new AnnotationTypeElementRestContext(_ctx, getState());
enterRule(_localctx, 122, RULE_annotationTypeElementRest);
try {
setState(809);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,91,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(789);
typeType();
setState(790);
annotationMethodOrConstantRest();
setState(791);
match(SEMI);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(793);
classDeclaration();
setState(795);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) {
case 1:
{
setState(794);
match(SEMI);
}
break;
}
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(797);
interfaceDeclaration();
setState(799);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,88,_ctx) ) {
case 1:
{
setState(798);
match(SEMI);
}
break;
}
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(801);
enumDeclaration();
setState(803);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,89,_ctx) ) {
case 1:
{
setState(802);
match(SEMI);
}
break;
}
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(805);
annotationTypeDeclaration();
setState(807);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) {
case 1:
{
setState(806);
match(SEMI);
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterAnnotationMethodOrConstantRest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitAnnotationMethodOrConstantRest(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitAnnotationMethodOrConstantRest(this);
else return visitor.visitChildren(this);
}
}
public final AnnotationMethodOrConstantRestContext annotationMethodOrConstantRest() throws RecognitionException {
AnnotationMethodOrConstantRestContext _localctx = new AnnotationMethodOrConstantRestContext(_ctx, getState());
enterRule(_localctx, 124, RULE_annotationMethodOrConstantRest);
try {
setState(813);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,92,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(811);
annotationMethodRest();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(812);
annotationConstantRest();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterAnnotationMethodRest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitAnnotationMethodRest(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitAnnotationMethodRest(this);
else return visitor.visitChildren(this);
}
}
public final AnnotationMethodRestContext annotationMethodRest() throws RecognitionException {
AnnotationMethodRestContext _localctx = new AnnotationMethodRestContext(_ctx, getState());
enterRule(_localctx, 126, RULE_annotationMethodRest);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(815);
identifier();
setState(816);
match(LPAREN);
setState(817);
match(RPAREN);
setState(819);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DEFAULT) {
{
setState(818);
defaultValue();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterAnnotationConstantRest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitAnnotationConstantRest(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitAnnotationConstantRest(this);
else return visitor.visitChildren(this);
}
}
public final AnnotationConstantRestContext annotationConstantRest() throws RecognitionException {
AnnotationConstantRestContext _localctx = new AnnotationConstantRestContext(_ctx, getState());
enterRule(_localctx, 128, RULE_annotationConstantRest);
try {
enterOuterAlt(_localctx, 1);
{
setState(821);
variableDeclarators();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterDefaultValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitDefaultValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitDefaultValue(this);
else return visitor.visitChildren(this);
}
}
public final DefaultValueContext defaultValue() throws RecognitionException {
DefaultValueContext _localctx = new DefaultValueContext(_ctx, getState());
enterRule(_localctx, 130, RULE_defaultValue);
try {
enterOuterAlt(_localctx, 1);
{
setState(823);
match(DEFAULT);
setState(824);
elementValue();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitBlock(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitBlock(this);
else return visitor.visitChildren(this);
}
}
public final BlockContext block() throws RecognitionException {
BlockContext _localctx = new BlockContext(_ctx, getState());
enterRule(_localctx, 132, RULE_block);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(826);
match(LBRACE);
setState(830);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & -1337011634672834L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1161084341860421L) != 0)) {
{
{
setState(827);
blockStatement();
}
}
setState(832);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(833);
match(RBRACE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class BlockStatementContext extends ParserRuleContext {
public LocalVariableDeclarationContext localVariableDeclaration() {
return getRuleContext(LocalVariableDeclarationContext.class,0);
}
public TerminalNode SEMI() { return getToken(JavaParser.SEMI, 0); }
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public LocalTypeDeclarationContext localTypeDeclaration() {
return getRuleContext(LocalTypeDeclarationContext.class,0);
}
public BlockStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_blockStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterBlockStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitBlockStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitBlockStatement(this);
else return visitor.visitChildren(this);
}
}
public final BlockStatementContext blockStatement() throws RecognitionException {
BlockStatementContext _localctx = new BlockStatementContext(_ctx, getState());
enterRule(_localctx, 134, RULE_blockStatement);
try {
setState(840);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,95,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(835);
localVariableDeclaration();
setState(836);
match(SEMI);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(838);
statement();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(839);
localTypeDeclaration();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LocalVariableDeclarationContext extends ParserRuleContext {
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterLocalVariableDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitLocalVariableDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitLocalVariableDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final LocalVariableDeclarationContext localVariableDeclaration() throws RecognitionException {
LocalVariableDeclarationContext _localctx = new LocalVariableDeclarationContext(_ctx, getState());
enterRule(_localctx, 136, RULE_localVariableDeclaration);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(845);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,96,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(842);
variableModifier();
}
}
}
setState(847);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,96,_ctx);
}
setState(848);
typeType();
setState(849);
variableDeclarators();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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 TerminalNode SEMI() { return getToken(JavaParser.SEMI, 0); }
public LocalTypeDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_localTypeDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterLocalTypeDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitLocalTypeDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitLocalTypeDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final LocalTypeDeclarationContext localTypeDeclaration() throws RecognitionException {
LocalTypeDeclarationContext _localctx = new LocalTypeDeclarationContext(_ctx, getState());
enterRule(_localctx, 138, RULE_localTypeDeclaration);
int _la;
try {
setState(863);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ABSTRACT:
case CLASS:
case FINAL:
case INTERFACE:
case PRIVATE:
case PROTECTED:
case PUBLIC:
case RECORD:
case STATIC:
case STRICTFP:
case AT:
enterOuterAlt(_localctx, 1);
{
setState(854);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1709397245954L) != 0) || _la==AT) {
{
{
setState(851);
classOrInterfaceModifier();
}
}
setState(856);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(860);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CLASS:
{
setState(857);
classDeclaration();
}
break;
case INTERFACE:
{
setState(858);
interfaceDeclaration();
}
break;
case RECORD:
{
setState(859);
recordDeclaration();
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case SEMI:
enterOuterAlt(_localctx, 2);
{
setState(862);
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;
}
@SuppressWarnings("CheckReturnValue")
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 List switchExpressionBlockStatementGroup() {
return getRuleContexts(SwitchExpressionBlockStatementGroupContext.class);
}
public SwitchExpressionBlockStatementGroupContext switchExpressionBlockStatementGroup(int i) {
return getRuleContext(SwitchExpressionBlockStatementGroupContext.class,i);
}
public TerminalNode SYNCHRONIZED() { return getToken(JavaParser.SYNCHRONIZED, 0); }
public TerminalNode RETURN() { return getToken(JavaParser.RETURN, 0); }
public TerminalNode YIELD() { return getToken(JavaParser.YIELD, 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 StatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_statement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitStatement(this);
else return visitor.visitChildren(this);
}
}
public final StatementContext statement() throws RecognitionException {
StatementContext _localctx = new StatementContext(_ctx, getState());
enterRule(_localctx, 140, RULE_statement);
int _la;
try {
int _alt;
setState(991);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,114,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(865);
((StatementContext)_localctx).blockLabel = block();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(866);
match(ASSERT);
setState(867);
expression(0);
setState(870);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLON) {
{
setState(868);
match(COLON);
setState(869);
expression(0);
}
}
setState(872);
match(SEMI);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(874);
match(IF);
setState(875);
parExpression();
setState(876);
statement();
setState(879);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,101,_ctx) ) {
case 1:
{
setState(877);
match(ELSE);
setState(878);
statement();
}
break;
}
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(881);
match(FOR);
setState(882);
match(LPAREN);
setState(883);
forControl();
setState(884);
match(RPAREN);
setState(885);
statement();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(887);
match(WHILE);
setState(888);
parExpression();
setState(889);
statement();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(891);
match(DO);
setState(892);
statement();
setState(893);
match(WHILE);
setState(894);
parExpression();
setState(895);
match(SEMI);
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(897);
match(TRY);
setState(898);
block();
setState(908);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CATCH:
{
setState(900);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(899);
catchClause();
}
}
setState(902);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==CATCH );
setState(905);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FINALLY) {
{
setState(904);
finallyBlock();
}
}
}
break;
case FINALLY:
{
setState(907);
finallyBlock();
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(910);
match(TRY);
setState(911);
resourceSpecification();
setState(912);
block();
setState(916);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==CATCH) {
{
{
setState(913);
catchClause();
}
}
setState(918);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(920);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FINALLY) {
{
setState(919);
finallyBlock();
}
}
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(922);
match(SWITCH);
setState(923);
parExpression();
setState(924);
match(LBRACE);
setState(928);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,107,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(925);
switchBlockStatementGroup();
}
}
}
setState(930);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,107,_ctx);
}
setState(934);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==CASE || _la==DEFAULT) {
{
{
setState(931);
switchLabel();
}
}
setState(936);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(937);
match(RBRACE);
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(939);
match(SWITCH);
setState(940);
parExpression();
setState(941);
match(LBRACE);
setState(945);
_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(942);
switchExpressionBlockStatementGroup();
}
}
}
setState(947);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,109,_ctx);
}
setState(951);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==CASE || _la==DEFAULT) {
{
{
setState(948);
switchLabel();
}
}
setState(953);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(954);
match(RBRACE);
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(956);
match(SYNCHRONIZED);
setState(957);
parExpression();
setState(958);
block();
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(960);
match(RETURN);
setState(962);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -8419713628487384L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1161084341860353L) != 0)) {
{
setState(961);
expression(0);
}
}
setState(964);
match(SEMI);
}
break;
case 13:
enterOuterAlt(_localctx, 13);
{
setState(965);
match(YIELD);
setState(966);
expression(0);
setState(967);
match(SEMI);
}
break;
case 14:
enterOuterAlt(_localctx, 14);
{
setState(969);
match(THROW);
setState(970);
expression(0);
setState(971);
match(SEMI);
}
break;
case 15:
enterOuterAlt(_localctx, 15);
{
setState(973);
match(BREAK);
setState(975);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RECORD || _la==IDENTIFIER) {
{
setState(974);
identifier();
}
}
setState(977);
match(SEMI);
}
break;
case 16:
enterOuterAlt(_localctx, 16);
{
setState(978);
match(CONTINUE);
setState(980);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RECORD || _la==IDENTIFIER) {
{
setState(979);
identifier();
}
}
setState(982);
match(SEMI);
}
break;
case 17:
enterOuterAlt(_localctx, 17);
{
setState(983);
match(SEMI);
}
break;
case 18:
enterOuterAlt(_localctx, 18);
{
setState(984);
((StatementContext)_localctx).statementExpression = expression(0);
setState(985);
match(SEMI);
}
break;
case 19:
enterOuterAlt(_localctx, 19);
{
setState(987);
((StatementContext)_localctx).identifierLabel = identifier();
setState(988);
match(COLON);
setState(989);
statement();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterCatchClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitCatchClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitCatchClause(this);
else return visitor.visitChildren(this);
}
}
public final CatchClauseContext catchClause() throws RecognitionException {
CatchClauseContext _localctx = new CatchClauseContext(_ctx, getState());
enterRule(_localctx, 142, RULE_catchClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(993);
match(CATCH);
setState(994);
match(LPAREN);
setState(998);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==FINAL || _la==AT) {
{
{
setState(995);
variableModifier();
}
}
setState(1000);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1001);
catchType();
setState(1002);
identifier();
setState(1003);
match(RPAREN);
setState(1004);
block();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterCatchType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitCatchType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitCatchType(this);
else return visitor.visitChildren(this);
}
}
public final CatchTypeContext catchType() throws RecognitionException {
CatchTypeContext _localctx = new CatchTypeContext(_ctx, getState());
enterRule(_localctx, 144, RULE_catchType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1006);
qualifiedName();
setState(1011);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==BITOR) {
{
{
setState(1007);
match(BITOR);
setState(1008);
qualifiedName();
}
}
setState(1013);
_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;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterFinallyBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitFinallyBlock(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitFinallyBlock(this);
else return visitor.visitChildren(this);
}
}
public final FinallyBlockContext finallyBlock() throws RecognitionException {
FinallyBlockContext _localctx = new FinallyBlockContext(_ctx, getState());
enterRule(_localctx, 146, RULE_finallyBlock);
try {
enterOuterAlt(_localctx, 1);
{
setState(1014);
match(FINALLY);
setState(1015);
block();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterResourceSpecification(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitResourceSpecification(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitResourceSpecification(this);
else return visitor.visitChildren(this);
}
}
public final ResourceSpecificationContext resourceSpecification() throws RecognitionException {
ResourceSpecificationContext _localctx = new ResourceSpecificationContext(_ctx, getState());
enterRule(_localctx, 148, RULE_resourceSpecification);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1017);
match(LPAREN);
setState(1018);
resources();
setState(1020);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SEMI) {
{
setState(1019);
match(SEMI);
}
}
setState(1022);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterResources(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitResources(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitResources(this);
else return visitor.visitChildren(this);
}
}
public final ResourcesContext resources() throws RecognitionException {
ResourcesContext _localctx = new ResourcesContext(_ctx, getState());
enterRule(_localctx, 150, RULE_resources);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1024);
resource();
setState(1029);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,118,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1025);
match(SEMI);
setState(1026);
resource();
}
}
}
setState(1031);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,118,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ResourceContext extends ParserRuleContext {
public ClassOrInterfaceTypeContext classOrInterfaceType() {
return getRuleContext(ClassOrInterfaceTypeContext.class,0);
}
public VariableDeclaratorIdContext variableDeclaratorId() {
return getRuleContext(VariableDeclaratorIdContext.class,0);
}
public TerminalNode ASSIGN() { return getToken(JavaParser.ASSIGN, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public List variableModifier() {
return getRuleContexts(VariableModifierContext.class);
}
public VariableModifierContext variableModifier(int i) {
return getRuleContext(VariableModifierContext.class,i);
}
public ResourceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_resource; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterResource(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitResource(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitResource(this);
else return visitor.visitChildren(this);
}
}
public final ResourceContext resource() throws RecognitionException {
ResourceContext _localctx = new ResourceContext(_ctx, getState());
enterRule(_localctx, 152, RULE_resource);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1035);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==FINAL || _la==AT) {
{
{
setState(1032);
variableModifier();
}
}
setState(1037);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1038);
classOrInterfaceType();
setState(1039);
variableDeclaratorId();
setState(1040);
match(ASSIGN);
setState(1041);
expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterSwitchBlockStatementGroup(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitSwitchBlockStatementGroup(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitSwitchBlockStatementGroup(this);
else return visitor.visitChildren(this);
}
}
public final SwitchBlockStatementGroupContext switchBlockStatementGroup() throws RecognitionException {
SwitchBlockStatementGroupContext _localctx = new SwitchBlockStatementGroupContext(_ctx, getState());
enterRule(_localctx, 154, RULE_switchBlockStatementGroup);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1044);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(1043);
switchLabel();
}
}
setState(1046);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==CASE || _la==DEFAULT );
setState(1049);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(1048);
blockStatement();
}
}
setState(1051);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & -1337011634672834L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1161084341860421L) != 0) );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SwitchLabelContext extends ParserRuleContext {
public ExpressionContext constantExpression;
public IdentifierContext enumConstantName;
public TerminalNode CASE() { return getToken(JavaParser.CASE, 0); }
public TerminalNode COLON() { return getToken(JavaParser.COLON, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterSwitchLabel(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitSwitchLabel(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitSwitchLabel(this);
else return visitor.visitChildren(this);
}
}
public final SwitchLabelContext switchLabel() throws RecognitionException {
SwitchLabelContext _localctx = new SwitchLabelContext(_ctx, getState());
enterRule(_localctx, 156, RULE_switchLabel);
try {
setState(1062);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CASE:
enterOuterAlt(_localctx, 1);
{
setState(1053);
match(CASE);
setState(1056);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,122,_ctx) ) {
case 1:
{
setState(1054);
((SwitchLabelContext)_localctx).constantExpression = expression(0);
}
break;
case 2:
{
setState(1055);
((SwitchLabelContext)_localctx).enumConstantName = identifier();
}
break;
}
setState(1058);
match(COLON);
}
break;
case DEFAULT:
enterOuterAlt(_localctx, 2);
{
setState(1060);
match(DEFAULT);
setState(1061);
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;
}
@SuppressWarnings("CheckReturnValue")
public static class SwitchExpressionBlockStatementGroupContext extends ParserRuleContext {
public List switchExpressionLabel() {
return getRuleContexts(SwitchExpressionLabelContext.class);
}
public SwitchExpressionLabelContext switchExpressionLabel(int i) {
return getRuleContext(SwitchExpressionLabelContext.class,i);
}
public List blockStatement() {
return getRuleContexts(BlockStatementContext.class);
}
public BlockStatementContext blockStatement(int i) {
return getRuleContext(BlockStatementContext.class,i);
}
public SwitchExpressionBlockStatementGroupContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_switchExpressionBlockStatementGroup; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterSwitchExpressionBlockStatementGroup(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitSwitchExpressionBlockStatementGroup(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitSwitchExpressionBlockStatementGroup(this);
else return visitor.visitChildren(this);
}
}
public final SwitchExpressionBlockStatementGroupContext switchExpressionBlockStatementGroup() throws RecognitionException {
SwitchExpressionBlockStatementGroupContext _localctx = new SwitchExpressionBlockStatementGroupContext(_ctx, getState());
enterRule(_localctx, 158, RULE_switchExpressionBlockStatementGroup);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1065);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(1064);
switchExpressionLabel();
}
}
setState(1067);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==CASE || _la==DEFAULT );
setState(1070);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(1069);
blockStatement();
}
}
setState(1072);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & -1337011634672834L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1161084341860421L) != 0) );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SwitchExpressionLabelContext extends ParserRuleContext {
public ExpressionContext constantExpression;
public IdentifierContext enumConstantName;
public TerminalNode CASE() { return getToken(JavaParser.CASE, 0); }
public TerminalNode COLON() { return getToken(JavaParser.COLON, 0); }
public TerminalNode ARROW() { return getToken(JavaParser.ARROW, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
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 TerminalNode DEFAULT() { return getToken(JavaParser.DEFAULT, 0); }
public SwitchExpressionLabelContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_switchExpressionLabel; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterSwitchExpressionLabel(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitSwitchExpressionLabel(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitSwitchExpressionLabel(this);
else return visitor.visitChildren(this);
}
}
public final SwitchExpressionLabelContext switchExpressionLabel() throws RecognitionException {
SwitchExpressionLabelContext _localctx = new SwitchExpressionLabelContext(_ctx, getState());
enterRule(_localctx, 160, RULE_switchExpressionLabel);
int _la;
try {
setState(1090);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CASE:
enterOuterAlt(_localctx, 1);
{
setState(1074);
match(CASE);
setState(1084);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,127,_ctx) ) {
case 1:
{
{
setState(1075);
((SwitchExpressionLabelContext)_localctx).constantExpression = expression(0);
setState(1080);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1076);
match(COMMA);
setState(1077);
((SwitchExpressionLabelContext)_localctx).constantExpression = expression(0);
}
}
setState(1082);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
break;
case 2:
{
setState(1083);
((SwitchExpressionLabelContext)_localctx).enumConstantName = identifier();
}
break;
}
setState(1086);
_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();
}
}
break;
case DEFAULT:
enterOuterAlt(_localctx, 2);
{
setState(1088);
match(DEFAULT);
setState(1089);
_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();
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterForControl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitForControl(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitForControl(this);
else return visitor.visitChildren(this);
}
}
public final ForControlContext forControl() throws RecognitionException {
ForControlContext _localctx = new ForControlContext(_ctx, getState());
enterRule(_localctx, 162, RULE_forControl);
int _la;
try {
setState(1104);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1092);
enhancedForControl();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1094);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -8419713628225240L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1161084341860353L) != 0)) {
{
setState(1093);
forInit();
}
}
setState(1096);
match(SEMI);
setState(1098);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -8419713628487384L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1161084341860353L) != 0)) {
{
setState(1097);
expression(0);
}
}
setState(1100);
match(SEMI);
setState(1102);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -8419713628487384L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1161084341860353L) != 0)) {
{
setState(1101);
((ForControlContext)_localctx).forUpdate = expressionList();
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterForInit(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitForInit(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitForInit(this);
else return visitor.visitChildren(this);
}
}
public final ForInitContext forInit() throws RecognitionException {
ForInitContext _localctx = new ForInitContext(_ctx, getState());
enterRule(_localctx, 164, RULE_forInit);
try {
setState(1108);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,133,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1106);
localVariableDeclaration();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1107);
expressionList();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class EnhancedForControlContext extends ParserRuleContext {
public TypeTypeContext typeType() {
return getRuleContext(TypeTypeContext.class,0);
}
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 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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterEnhancedForControl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitEnhancedForControl(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitEnhancedForControl(this);
else return visitor.visitChildren(this);
}
}
public final EnhancedForControlContext enhancedForControl() throws RecognitionException {
EnhancedForControlContext _localctx = new EnhancedForControlContext(_ctx, getState());
enterRule(_localctx, 166, RULE_enhancedForControl);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1113);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,134,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1110);
variableModifier();
}
}
}
setState(1115);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,134,_ctx);
}
setState(1116);
typeType();
setState(1117);
variableDeclaratorId();
setState(1118);
match(COLON);
setState(1119);
expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterParExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitParExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitParExpression(this);
else return visitor.visitChildren(this);
}
}
public final ParExpressionContext parExpression() throws RecognitionException {
ParExpressionContext _localctx = new ParExpressionContext(_ctx, getState());
enterRule(_localctx, 168, RULE_parExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(1121);
match(LPAREN);
setState(1122);
expression(0);
setState(1123);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterExpressionList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitExpressionList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitExpressionList(this);
else return visitor.visitChildren(this);
}
}
public final ExpressionListContext expressionList() throws RecognitionException {
ExpressionListContext _localctx = new ExpressionListContext(_ctx, getState());
enterRule(_localctx, 170, RULE_expressionList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1125);
expression(0);
setState(1130);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1126);
match(COMMA);
setState(1127);
expression(0);
}
}
setState(1132);
_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;
}
@SuppressWarnings("CheckReturnValue")
public static class MethodCallContext 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 ExpressionListContext expressionList() {
return getRuleContext(ExpressionListContext.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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterMethodCall(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitMethodCall(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitMethodCall(this);
else return visitor.visitChildren(this);
}
}
public final MethodCallContext methodCall() throws RecognitionException {
MethodCallContext _localctx = new MethodCallContext(_ctx, getState());
enterRule(_localctx, 172, RULE_methodCall);
int _la;
try {
setState(1152);
_errHandler.sync(this);
switch (_input.LA(1)) {
case RECORD:
case IDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(1133);
identifier();
setState(1134);
match(LPAREN);
setState(1136);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -8419713628487384L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1161084341860353L) != 0)) {
{
setState(1135);
expressionList();
}
}
setState(1138);
match(RPAREN);
}
break;
case THIS:
enterOuterAlt(_localctx, 2);
{
setState(1140);
match(THIS);
setState(1141);
match(LPAREN);
setState(1143);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -8419713628487384L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1161084341860353L) != 0)) {
{
setState(1142);
expressionList();
}
}
setState(1145);
match(RPAREN);
}
break;
case SUPER:
enterOuterAlt(_localctx, 3);
{
setState(1146);
match(SUPER);
setState(1147);
match(LPAREN);
setState(1149);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -8419713628487384L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1161084341860353L) != 0)) {
{
setState(1148);
expressionList();
}
}
setState(1151);
match(RPAREN);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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 TerminalNode NEW() { return getToken(JavaParser.NEW, 0); }
public CreatorContext creator() {
return getRuleContext(CreatorContext.class,0);
}
public TerminalNode LPAREN() { return getToken(JavaParser.LPAREN, 0); }
public TypeTypeContext typeType() {
return getRuleContext(TypeTypeContext.class,0);
}
public TerminalNode RPAREN() { return getToken(JavaParser.RPAREN, 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 LambdaExpressionContext lambdaExpression() {
return getRuleContext(LambdaExpressionContext.class,0);
}
public TerminalNode COLONCOLON() { return getToken(JavaParser.COLONCOLON, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TypeArgumentsContext typeArguments() {
return getRuleContext(TypeArgumentsContext.class,0);
}
public ClassTypeContext classType() {
return getRuleContext(ClassTypeContext.class,0);
}
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 switchExpressionBlockStatementGroup() {
return getRuleContexts(SwitchExpressionBlockStatementGroupContext.class);
}
public SwitchExpressionBlockStatementGroupContext switchExpressionBlockStatementGroup(int i) {
return getRuleContext(SwitchExpressionBlockStatementGroupContext.class,i);
}
public List switchLabel() {
return getRuleContexts(SwitchLabelContext.class);
}
public SwitchLabelContext switchLabel(int i) {
return getRuleContext(SwitchLabelContext.class,i);
}
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 BITAND() { return getToken(JavaParser.BITAND, 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 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 LBRACK() { return getToken(JavaParser.LBRACK, 0); }
public TerminalNode RBRACK() { return getToken(JavaParser.RBRACK, 0); }
public TerminalNode INSTANCEOF() { return getToken(JavaParser.INSTANCEOF, 0); }
public ExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitExpression(this);
else return visitor.visitChildren(this);
}
}
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 = 174;
enterRecursionRule(_localctx, 174, RULE_expression, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1202);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,145,_ctx) ) {
case 1:
{
setState(1155);
primary();
}
break;
case 2:
{
setState(1156);
methodCall();
}
break;
case 3:
{
setState(1157);
match(NEW);
setState(1158);
creator();
}
break;
case 4:
{
setState(1159);
match(LPAREN);
setState(1160);
typeType();
setState(1161);
match(RPAREN);
setState(1162);
expression(22);
}
break;
case 5:
{
setState(1164);
((ExpressionContext)_localctx).prefix = _input.LT(1);
_la = _input.LA(1);
if ( !(((((_la - 86)) & ~0x3f) == 0 && ((1L << (_la - 86)) & 15L) != 0)) ) {
((ExpressionContext)_localctx).prefix = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1165);
expression(20);
}
break;
case 6:
{
setState(1166);
((ExpressionContext)_localctx).prefix = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==BANG || _la==TILDE) ) {
((ExpressionContext)_localctx).prefix = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1167);
expression(19);
}
break;
case 7:
{
setState(1168);
lambdaExpression();
}
break;
case 8:
{
setState(1169);
typeType();
setState(1170);
match(COLONCOLON);
setState(1176);
_errHandler.sync(this);
switch (_input.LA(1)) {
case RECORD:
case LT:
case IDENTIFIER:
{
setState(1172);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1171);
typeArguments();
}
}
setState(1174);
identifier();
}
break;
case NEW:
{
setState(1175);
match(NEW);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 9:
{
setState(1178);
classType();
setState(1179);
match(COLONCOLON);
setState(1181);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1180);
typeArguments();
}
}
setState(1183);
match(NEW);
}
break;
case 10:
{
setState(1185);
match(SWITCH);
setState(1186);
parExpression();
setState(1187);
match(LBRACE);
setState(1191);
_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(1188);
switchExpressionBlockStatementGroup();
}
}
}
setState(1193);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,143,_ctx);
}
setState(1197);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==CASE || _la==DEFAULT) {
{
{
setState(1194);
switchLabel();
}
}
setState(1199);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1200);
match(RBRACE);
}
break;
}
_ctx.stop = _input.LT(-1);
setState(1287);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,152,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(1285);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,151,_ctx) ) {
case 1:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1204);
if (!(precpred(_ctx, 18))) throw new FailedPredicateException(this, "precpred(_ctx, 18)");
setState(1205);
((ExpressionContext)_localctx).bop = _input.LT(1);
_la = _input.LA(1);
if ( !(((((_la - 90)) & ~0x3f) == 0 && ((1L << (_la - 90)) & 35L) != 0)) ) {
((ExpressionContext)_localctx).bop = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1206);
expression(19);
}
break;
case 2:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1207);
if (!(precpred(_ctx, 17))) throw new FailedPredicateException(this, "precpred(_ctx, 17)");
setState(1208);
((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(1209);
expression(18);
}
break;
case 3:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1210);
if (!(precpred(_ctx, 16))) throw new FailedPredicateException(this, "precpred(_ctx, 16)");
setState(1218);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) {
case 1:
{
setState(1211);
match(LT);
setState(1212);
match(LT);
}
break;
case 2:
{
setState(1213);
match(GT);
setState(1214);
match(GT);
setState(1215);
match(GT);
}
break;
case 3:
{
setState(1216);
match(GT);
setState(1217);
match(GT);
}
break;
}
setState(1220);
expression(17);
}
break;
case 4:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1221);
if (!(precpred(_ctx, 15))) throw new FailedPredicateException(this, "precpred(_ctx, 15)");
setState(1222);
((ExpressionContext)_localctx).bop = _input.LT(1);
_la = _input.LA(1);
if ( !(((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & 387L) != 0)) ) {
((ExpressionContext)_localctx).bop = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1223);
expression(16);
}
break;
case 5:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1224);
if (!(precpred(_ctx, 13))) throw new FailedPredicateException(this, "precpred(_ctx, 13)");
setState(1225);
((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(1226);
expression(14);
}
break;
case 6:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1227);
if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)");
setState(1228);
((ExpressionContext)_localctx).bop = match(BITAND);
setState(1229);
expression(13);
}
break;
case 7:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1230);
if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)");
setState(1231);
((ExpressionContext)_localctx).bop = match(CARET);
setState(1232);
expression(12);
}
break;
case 8:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1233);
if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)");
setState(1234);
((ExpressionContext)_localctx).bop = match(BITOR);
setState(1235);
expression(11);
}
break;
case 9:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1236);
if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)");
setState(1237);
((ExpressionContext)_localctx).bop = match(AND);
setState(1238);
expression(10);
}
break;
case 10:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1239);
if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)");
setState(1240);
((ExpressionContext)_localctx).bop = match(OR);
setState(1241);
expression(9);
}
break;
case 11:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1242);
if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)");
setState(1243);
((ExpressionContext)_localctx).bop = match(QUESTION);
setState(1244);
expression(0);
setState(1245);
match(COLON);
setState(1246);
expression(8);
}
break;
case 12:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1248);
if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
setState(1249);
((ExpressionContext)_localctx).bop = _input.LT(1);
_la = _input.LA(1);
if ( !(((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 17171480577L) != 0)) ) {
((ExpressionContext)_localctx).bop = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1250);
expression(6);
}
break;
case 13:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1251);
if (!(precpred(_ctx, 26))) throw new FailedPredicateException(this, "precpred(_ctx, 26)");
setState(1252);
((ExpressionContext)_localctx).bop = match(DOT);
setState(1264);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) {
case 1:
{
setState(1253);
identifier();
}
break;
case 2:
{
setState(1254);
methodCall();
}
break;
case 3:
{
setState(1255);
match(THIS);
}
break;
case 4:
{
setState(1256);
match(NEW);
setState(1258);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1257);
nonWildcardTypeArguments();
}
}
setState(1260);
innerCreator();
}
break;
case 5:
{
setState(1261);
match(SUPER);
setState(1262);
superSuffix();
}
break;
case 6:
{
setState(1263);
explicitGenericInvocation();
}
break;
}
}
break;
case 14:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1266);
if (!(precpred(_ctx, 25))) throw new FailedPredicateException(this, "precpred(_ctx, 25)");
setState(1267);
match(LBRACK);
setState(1268);
expression(0);
setState(1269);
match(RBRACK);
}
break;
case 15:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1271);
if (!(precpred(_ctx, 21))) throw new FailedPredicateException(this, "precpred(_ctx, 21)");
setState(1272);
((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 16:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1273);
if (!(precpred(_ctx, 14))) throw new FailedPredicateException(this, "precpred(_ctx, 14)");
setState(1274);
((ExpressionContext)_localctx).bop = match(INSTANCEOF);
setState(1275);
typeType();
setState(1277);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,149,_ctx) ) {
case 1:
{
setState(1276);
identifier();
}
break;
}
}
break;
case 17:
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(1279);
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
setState(1280);
match(COLONCOLON);
setState(1282);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1281);
typeArguments();
}
}
setState(1284);
identifier();
}
break;
}
}
}
setState(1289);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,152,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterLambdaExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitLambdaExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitLambdaExpression(this);
else return visitor.visitChildren(this);
}
}
public final LambdaExpressionContext lambdaExpression() throws RecognitionException {
LambdaExpressionContext _localctx = new LambdaExpressionContext(_ctx, getState());
enterRule(_localctx, 176, RULE_lambdaExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(1290);
lambdaParameters();
setState(1291);
match(ARROW);
setState(1292);
lambdaBody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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 LambdaParametersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lambdaParameters; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterLambdaParameters(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitLambdaParameters(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitLambdaParameters(this);
else return visitor.visitChildren(this);
}
}
public final LambdaParametersContext lambdaParameters() throws RecognitionException {
LambdaParametersContext _localctx = new LambdaParametersContext(_ctx, getState());
enterRule(_localctx, 178, RULE_lambdaParameters);
int _la;
try {
setState(1311);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,155,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1294);
identifier();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1295);
match(LPAREN);
setState(1297);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 344269799720L) != 0) || _la==AT || _la==IDENTIFIER) {
{
setState(1296);
formalParameterList();
}
}
setState(1299);
match(RPAREN);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1300);
match(LPAREN);
setState(1301);
identifier();
setState(1306);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1302);
match(COMMA);
setState(1303);
identifier();
}
}
setState(1308);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1309);
match(RPAREN);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LambdaBodyContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public LambdaBodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lambdaBody; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterLambdaBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitLambdaBody(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitLambdaBody(this);
else return visitor.visitChildren(this);
}
}
public final LambdaBodyContext lambdaBody() throws RecognitionException {
LambdaBodyContext _localctx = new LambdaBodyContext(_ctx, getState());
enterRule(_localctx, 180, RULE_lambdaBody);
try {
setState(1315);
_errHandler.sync(this);
switch (_input.LA(1)) {
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case NEW:
case RECORD:
case SHORT:
case SUPER:
case SWITCH:
case THIS:
case VOID:
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_LITERAL:
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(1313);
expression(0);
}
break;
case LBRACE:
enterOuterAlt(_localctx, 2);
{
setState(1314);
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;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterPrimary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitPrimary(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitPrimary(this);
else return visitor.visitChildren(this);
}
}
public final PrimaryContext primary() throws RecognitionException {
PrimaryContext _localctx = new PrimaryContext(_ctx, getState());
enterRule(_localctx, 182, RULE_primary);
try {
setState(1335);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,158,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1317);
match(LPAREN);
setState(1318);
expression(0);
setState(1319);
match(RPAREN);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1321);
match(THIS);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1322);
match(SUPER);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1323);
literal();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1324);
identifier();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(1325);
typeTypeOrVoid();
setState(1326);
match(DOT);
setState(1327);
match(CLASS);
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(1329);
nonWildcardTypeArguments();
setState(1333);
_errHandler.sync(this);
switch (_input.LA(1)) {
case RECORD:
case SUPER:
case IDENTIFIER:
{
setState(1330);
explicitGenericInvocationSuffix();
}
break;
case THIS:
{
setState(1331);
match(THIS);
setState(1332);
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;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterClassType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitClassType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitClassType(this);
else return visitor.visitChildren(this);
}
}
public final ClassTypeContext classType() throws RecognitionException {
ClassTypeContext _localctx = new ClassTypeContext(_ctx, getState());
enterRule(_localctx, 184, RULE_classType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1340);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) {
case 1:
{
setState(1337);
classOrInterfaceType();
setState(1338);
match(DOT);
}
break;
}
setState(1345);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AT) {
{
{
setState(1342);
annotation();
}
}
setState(1347);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1348);
identifier();
setState(1350);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1349);
typeArguments();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CreatorContext extends ParserRuleContext {
public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() {
return getRuleContext(NonWildcardTypeArgumentsContext.class,0);
}
public CreatedNameContext createdName() {
return getRuleContext(CreatedNameContext.class,0);
}
public ClassCreatorRestContext classCreatorRest() {
return getRuleContext(ClassCreatorRestContext.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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterCreator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitCreator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitCreator(this);
else return visitor.visitChildren(this);
}
}
public final CreatorContext creator() throws RecognitionException {
CreatorContext _localctx = new CreatorContext(_ctx, getState());
enterRule(_localctx, 186, RULE_creator);
try {
setState(1361);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LT:
enterOuterAlt(_localctx, 1);
{
setState(1352);
nonWildcardTypeArguments();
setState(1353);
createdName();
setState(1354);
classCreatorRest();
}
break;
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case RECORD:
case SHORT:
case IDENTIFIER:
enterOuterAlt(_localctx, 2);
{
setState(1356);
createdName();
setState(1359);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LBRACK:
{
setState(1357);
arrayCreatorRest();
}
break;
case LPAREN:
{
setState(1358);
classCreatorRest();
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterCreatedName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitCreatedName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitCreatedName(this);
else return visitor.visitChildren(this);
}
}
public final CreatedNameContext createdName() throws RecognitionException {
CreatedNameContext _localctx = new CreatedNameContext(_ctx, getState());
enterRule(_localctx, 188, RULE_createdName);
int _la;
try {
setState(1378);
_errHandler.sync(this);
switch (_input.LA(1)) {
case RECORD:
case IDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(1363);
identifier();
setState(1365);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1364);
typeArgumentsOrDiamond();
}
}
setState(1374);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DOT) {
{
{
setState(1367);
match(DOT);
setState(1368);
identifier();
setState(1370);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1369);
typeArgumentsOrDiamond();
}
}
}
}
setState(1376);
_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(1377);
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;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterInnerCreator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitInnerCreator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitInnerCreator(this);
else return visitor.visitChildren(this);
}
}
public final InnerCreatorContext innerCreator() throws RecognitionException {
InnerCreatorContext _localctx = new InnerCreatorContext(_ctx, getState());
enterRule(_localctx, 190, RULE_innerCreator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1380);
identifier();
setState(1382);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(1381);
nonWildcardTypeArgumentsOrDiamond();
}
}
setState(1384);
classCreatorRest();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ArrayCreatorRestContext extends ParserRuleContext {
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 ArrayInitializerContext arrayInitializer() {
return getRuleContext(ArrayInitializerContext.class,0);
}
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterArrayCreatorRest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitArrayCreatorRest(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitArrayCreatorRest(this);
else return visitor.visitChildren(this);
}
}
public final ArrayCreatorRestContext arrayCreatorRest() throws RecognitionException {
ArrayCreatorRestContext _localctx = new ArrayCreatorRestContext(_ctx, getState());
enterRule(_localctx, 192, RULE_arrayCreatorRest);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1386);
match(LBRACK);
setState(1414);
_errHandler.sync(this);
switch (_input.LA(1)) {
case RBRACK:
{
setState(1387);
match(RBRACK);
setState(1392);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LBRACK) {
{
{
setState(1388);
match(LBRACK);
setState(1389);
match(RBRACK);
}
}
setState(1394);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1395);
arrayInitializer();
}
break;
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case NEW:
case RECORD:
case SHORT:
case SUPER:
case SWITCH:
case THIS:
case VOID:
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_LITERAL:
case NULL_LITERAL:
case LPAREN:
case LT:
case BANG:
case TILDE:
case INC:
case DEC:
case ADD:
case SUB:
case AT:
case IDENTIFIER:
{
setState(1396);
expression(0);
setState(1397);
match(RBRACK);
setState(1404);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,170,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1398);
match(LBRACK);
setState(1399);
expression(0);
setState(1400);
match(RBRACK);
}
}
}
setState(1406);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,170,_ctx);
}
setState(1411);
_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 ) {
{
{
setState(1407);
match(LBRACK);
setState(1408);
match(RBRACK);
}
}
}
setState(1413);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,171,_ctx);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterClassCreatorRest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitClassCreatorRest(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitClassCreatorRest(this);
else return visitor.visitChildren(this);
}
}
public final ClassCreatorRestContext classCreatorRest() throws RecognitionException {
ClassCreatorRestContext _localctx = new ClassCreatorRestContext(_ctx, getState());
enterRule(_localctx, 194, RULE_classCreatorRest);
try {
enterOuterAlt(_localctx, 1);
{
setState(1416);
arguments();
setState(1418);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,173,_ctx) ) {
case 1:
{
setState(1417);
classBody();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterExplicitGenericInvocation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitExplicitGenericInvocation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitExplicitGenericInvocation(this);
else return visitor.visitChildren(this);
}
}
public final ExplicitGenericInvocationContext explicitGenericInvocation() throws RecognitionException {
ExplicitGenericInvocationContext _localctx = new ExplicitGenericInvocationContext(_ctx, getState());
enterRule(_localctx, 196, RULE_explicitGenericInvocation);
try {
enterOuterAlt(_localctx, 1);
{
setState(1420);
nonWildcardTypeArguments();
setState(1421);
explicitGenericInvocationSuffix();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterTypeArgumentsOrDiamond(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitTypeArgumentsOrDiamond(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitTypeArgumentsOrDiamond(this);
else return visitor.visitChildren(this);
}
}
public final TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() throws RecognitionException {
TypeArgumentsOrDiamondContext _localctx = new TypeArgumentsOrDiamondContext(_ctx, getState());
enterRule(_localctx, 198, RULE_typeArgumentsOrDiamond);
try {
setState(1426);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,174,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1423);
match(LT);
setState(1424);
match(GT);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1425);
typeArguments();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterNonWildcardTypeArgumentsOrDiamond(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitNonWildcardTypeArgumentsOrDiamond(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitNonWildcardTypeArgumentsOrDiamond(this);
else return visitor.visitChildren(this);
}
}
public final NonWildcardTypeArgumentsOrDiamondContext nonWildcardTypeArgumentsOrDiamond() throws RecognitionException {
NonWildcardTypeArgumentsOrDiamondContext _localctx = new NonWildcardTypeArgumentsOrDiamondContext(_ctx, getState());
enterRule(_localctx, 200, RULE_nonWildcardTypeArgumentsOrDiamond);
try {
setState(1431);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,175,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1428);
match(LT);
setState(1429);
match(GT);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1430);
nonWildcardTypeArguments();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterNonWildcardTypeArguments(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitNonWildcardTypeArguments(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitNonWildcardTypeArguments(this);
else return visitor.visitChildren(this);
}
}
public final NonWildcardTypeArgumentsContext nonWildcardTypeArguments() throws RecognitionException {
NonWildcardTypeArgumentsContext _localctx = new NonWildcardTypeArgumentsContext(_ctx, getState());
enterRule(_localctx, 202, RULE_nonWildcardTypeArguments);
try {
enterOuterAlt(_localctx, 1);
{
setState(1433);
match(LT);
setState(1434);
typeList();
setState(1435);
match(GT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterTypeList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitTypeList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitTypeList(this);
else return visitor.visitChildren(this);
}
}
public final TypeListContext typeList() throws RecognitionException {
TypeListContext _localctx = new TypeListContext(_ctx, getState());
enterRule(_localctx, 204, RULE_typeList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1437);
typeType();
setState(1442);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1438);
match(COMMA);
setState(1439);
typeType();
}
}
setState(1444);
_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;
}
@SuppressWarnings("CheckReturnValue")
public static class TypeTypeContext extends ParserRuleContext {
public ClassOrInterfaceTypeContext classOrInterfaceType() {
return getRuleContext(ClassOrInterfaceTypeContext.class,0);
}
public PrimitiveTypeContext primitiveType() {
return getRuleContext(PrimitiveTypeContext.class,0);
}
public AnnotationContext annotation() {
return getRuleContext(AnnotationContext.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 TypeTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterTypeType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitTypeType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitTypeType(this);
else return visitor.visitChildren(this);
}
}
public final TypeTypeContext typeType() throws RecognitionException {
TypeTypeContext _localctx = new TypeTypeContext(_ctx, getState());
enterRule(_localctx, 206, RULE_typeType);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1446);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AT) {
{
setState(1445);
annotation();
}
}
setState(1450);
_errHandler.sync(this);
switch (_input.LA(1)) {
case RECORD:
case IDENTIFIER:
{
setState(1448);
classOrInterfaceType();
}
break;
case BOOLEAN:
case BYTE:
case CHAR:
case DOUBLE:
case FLOAT:
case INT:
case LONG:
case SHORT:
{
setState(1449);
primitiveType();
}
break;
default:
throw new NoViableAltException(this);
}
setState(1456);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,179,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1452);
match(LBRACK);
setState(1453);
match(RBRACK);
}
}
}
setState(1458);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,179,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterPrimitiveType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitPrimitiveType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitPrimitiveType(this);
else return visitor.visitChildren(this);
}
}
public final PrimitiveTypeContext primitiveType() throws RecognitionException {
PrimitiveTypeContext _localctx = new PrimitiveTypeContext(_ctx, getState());
enterRule(_localctx, 208, RULE_primitiveType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1459);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 275550060840L) != 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;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterTypeArguments(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitTypeArguments(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitTypeArguments(this);
else return visitor.visitChildren(this);
}
}
public final TypeArgumentsContext typeArguments() throws RecognitionException {
TypeArgumentsContext _localctx = new TypeArgumentsContext(_ctx, getState());
enterRule(_localctx, 210, RULE_typeArguments);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1461);
match(LT);
setState(1462);
typeArgument();
setState(1467);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1463);
match(COMMA);
setState(1464);
typeArgument();
}
}
setState(1469);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1470);
match(GT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
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 SuperSuffixContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_superSuffix; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterSuperSuffix(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitSuperSuffix(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitSuperSuffix(this);
else return visitor.visitChildren(this);
}
}
public final SuperSuffixContext superSuffix() throws RecognitionException {
SuperSuffixContext _localctx = new SuperSuffixContext(_ctx, getState());
enterRule(_localctx, 212, RULE_superSuffix);
try {
setState(1478);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LPAREN:
enterOuterAlt(_localctx, 1);
{
setState(1472);
arguments();
}
break;
case DOT:
enterOuterAlt(_localctx, 2);
{
setState(1473);
match(DOT);
setState(1474);
identifier();
setState(1476);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,181,_ctx) ) {
case 1:
{
setState(1475);
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;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterExplicitGenericInvocationSuffix(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitExplicitGenericInvocationSuffix(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitExplicitGenericInvocationSuffix(this);
else return visitor.visitChildren(this);
}
}
public final ExplicitGenericInvocationSuffixContext explicitGenericInvocationSuffix() throws RecognitionException {
ExplicitGenericInvocationSuffixContext _localctx = new ExplicitGenericInvocationSuffixContext(_ctx, getState());
enterRule(_localctx, 214, RULE_explicitGenericInvocationSuffix);
try {
setState(1485);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SUPER:
enterOuterAlt(_localctx, 1);
{
setState(1480);
match(SUPER);
setState(1481);
superSuffix();
}
break;
case RECORD:
case IDENTIFIER:
enterOuterAlt(_localctx, 2);
{
setState(1482);
identifier();
setState(1483);
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;
}
@SuppressWarnings("CheckReturnValue")
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; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterArguments(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitArguments(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitArguments(this);
else return visitor.visitChildren(this);
}
}
public final ArgumentsContext arguments() throws RecognitionException {
ArgumentsContext _localctx = new ArgumentsContext(_ctx, getState());
enterRule(_localctx, 216, RULE_arguments);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1487);
match(LPAREN);
setState(1489);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -8419713628487384L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1161084341860353L) != 0)) {
{
setState(1488);
expressionList();
}
}
setState(1491);
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 87:
return expression_sempred((ExpressionContext)_localctx, predIndex);
}
return true;
}
private boolean expression_sempred(ExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 0:
return precpred(_ctx, 18);
case 1:
return precpred(_ctx, 17);
case 2:
return precpred(_ctx, 16);
case 3:
return precpred(_ctx, 15);
case 4:
return precpred(_ctx, 13);
case 5:
return precpred(_ctx, 12);
case 6:
return precpred(_ctx, 11);
case 7:
return precpred(_ctx, 10);
case 8:
return precpred(_ctx, 9);
case 9:
return precpred(_ctx, 8);
case 10:
return precpred(_ctx, 7);
case 11:
return precpred(_ctx, 6);
case 12:
return precpred(_ctx, 26);
case 13:
return precpred(_ctx, 25);
case 14:
return precpred(_ctx, 21);
case 15:
return precpred(_ctx, 14);
case 16:
return precpred(_ctx, 4);
}
return true;
}
public static final String _serializedATN =
"\u0004\u0001r\u05d6\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001\u0002"+
"\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004\u0002"+
"\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007\u0002"+
"\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b\u0002"+
"\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002\u000f\u0007\u000f"+
"\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002\u0012\u0007\u0012"+
"\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002\u0015\u0007\u0015"+
"\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002\u0018\u0007\u0018"+
"\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0002\u001b\u0007\u001b"+
"\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d\u0002\u001e\u0007\u001e"+
"\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!\u0007!\u0002\"\u0007\"\u0002"+
"#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002&\u0007&\u0002\'\u0007\'\u0002"+
"(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002+\u0007+\u0002,\u0007,\u0002"+
"-\u0007-\u0002.\u0007.\u0002/\u0007/\u00020\u00070\u00021\u00071\u0002"+
"2\u00072\u00023\u00073\u00024\u00074\u00025\u00075\u00026\u00076\u0002"+
"7\u00077\u00028\u00078\u00029\u00079\u0002:\u0007:\u0002;\u0007;\u0002"+
"<\u0007<\u0002=\u0007=\u0002>\u0007>\u0002?\u0007?\u0002@\u0007@\u0002"+
"A\u0007A\u0002B\u0007B\u0002C\u0007C\u0002D\u0007D\u0002E\u0007E\u0002"+
"F\u0007F\u0002G\u0007G\u0002H\u0007H\u0002I\u0007I\u0002J\u0007J\u0002"+
"K\u0007K\u0002L\u0007L\u0002M\u0007M\u0002N\u0007N\u0002O\u0007O\u0002"+
"P\u0007P\u0002Q\u0007Q\u0002R\u0007R\u0002S\u0007S\u0002T\u0007T\u0002"+
"U\u0007U\u0002V\u0007V\u0002W\u0007W\u0002X\u0007X\u0002Y\u0007Y\u0002"+
"Z\u0007Z\u0002[\u0007[\u0002\\\u0007\\\u0002]\u0007]\u0002^\u0007^\u0002"+
"_\u0007_\u0002`\u0007`\u0002a\u0007a\u0002b\u0007b\u0002c\u0007c\u0002"+
"d\u0007d\u0002e\u0007e\u0002f\u0007f\u0002g\u0007g\u0002h\u0007h\u0002"+
"i\u0007i\u0002j\u0007j\u0002k\u0007k\u0002l\u0007l\u0001\u0000\u0001\u0000"+
"\u0001\u0001\u0003\u0001\u00de\b\u0001\u0001\u0001\u0005\u0001\u00e1\b"+
"\u0001\n\u0001\f\u0001\u00e4\t\u0001\u0001\u0001\u0005\u0001\u00e7\b\u0001"+
"\n\u0001\f\u0001\u00ea\t\u0001\u0001\u0001\u0001\u0001\u0001\u0002\u0005"+
"\u0002\u00ef\b\u0002\n\u0002\f\u0002\u00f2\t\u0002\u0001\u0002\u0001\u0002"+
"\u0001\u0002\u0001\u0002\u0001\u0003\u0001\u0003\u0003\u0003\u00fa\b\u0003"+
"\u0001\u0003\u0001\u0003\u0001\u0003\u0003\u0003\u00ff\b\u0003\u0001\u0003"+
"\u0001\u0003\u0001\u0004\u0003\u0004\u0104\b\u0004\u0001\u0004\u0005\u0004"+
"\u0107\b\u0004\n\u0004\f\u0004\u010a\t\u0004\u0001\u0004\u0001\u0004\u0001"+
"\u0004\u0001\u0004\u0001\u0004\u0003\u0004\u0111\b\u0004\u0001\u0004\u0003"+
"\u0004\u0114\b\u0004\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001"+
"\u0005\u0003\u0005\u011b\b\u0005\u0001\u0006\u0001\u0006\u0001\u0006\u0001"+
"\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0003\u0006\u0125"+
"\b\u0006\u0001\u0007\u0001\u0007\u0003\u0007\u0129\b\u0007\u0001\b\u0001"+
"\b\u0001\b\u0001\b\u0001\b\u0003\b\u0130\b\b\u0001\b\u0001\b\u0001\t\u0001"+
"\t\u0001\t\u0003\t\u0137\b\t\u0001\t\u0001\t\u0003\t\u013b\b\t\u0001\t"+
"\u0001\t\u0003\t\u013f\b\t\u0001\t\u0001\t\u0001\n\u0001\n\u0001\n\u0001"+
"\n\u0005\n\u0147\b\n\n\n\f\n\u014a\t\n\u0001\n\u0001\n\u0001\u000b\u0005"+
"\u000b\u014f\b\u000b\n\u000b\f\u000b\u0152\t\u000b\u0001\u000b\u0001\u000b"+
"\u0001\u000b\u0003\u000b\u0157\b\u000b\u0001\f\u0001\f\u0001\f\u0005\f"+
"\u015c\b\f\n\f\f\f\u015f\t\f\u0001\r\u0001\r\u0001\r\u0001\r\u0003\r\u0165"+
"\b\r\u0001\r\u0001\r\u0003\r\u0169\b\r\u0001\r\u0003\r\u016c\b\r\u0001"+
"\r\u0003\r\u016f\b\r\u0001\r\u0001\r\u0001\u000e\u0001\u000e\u0001\u000e"+
"\u0005\u000e\u0176\b\u000e\n\u000e\f\u000e\u0179\t\u000e\u0001\u000f\u0005"+
"\u000f\u017c\b\u000f\n\u000f\f\u000f\u017f\t\u000f\u0001\u000f\u0001\u000f"+
"\u0003\u000f\u0183\b\u000f\u0001\u000f\u0003\u000f\u0186\b\u000f\u0001"+
"\u0010\u0001\u0010\u0005\u0010\u018a\b\u0010\n\u0010\f\u0010\u018d\t\u0010"+
"\u0001\u0011\u0001\u0011\u0001\u0011\u0003\u0011\u0192\b\u0011\u0001\u0011"+
"\u0001\u0011\u0003\u0011\u0196\b\u0011\u0001\u0011\u0001\u0011\u0001\u0012"+
"\u0001\u0012\u0005\u0012\u019c\b\u0012\n\u0012\f\u0012\u019f\t\u0012\u0001"+
"\u0012\u0001\u0012\u0001\u0013\u0001\u0013\u0005\u0013\u01a5\b\u0013\n"+
"\u0013\f\u0013\u01a8\t\u0013\u0001\u0013\u0001\u0013\u0001\u0014\u0001"+
"\u0014\u0003\u0014\u01ae\b\u0014\u0001\u0014\u0001\u0014\u0003\u0014\u01b2"+
"\b\u0014\u0001\u0014\u0005\u0014\u01b5\b\u0014\n\u0014\f\u0014\u01b8\t"+
"\u0014\u0001\u0014\u0003\u0014\u01bb\b\u0014\u0001\u0015\u0001\u0015\u0001"+
"\u0015\u0001\u0015\u0001\u0015\u0001\u0015\u0001\u0015\u0001\u0015\u0001"+
"\u0015\u0001\u0015\u0003\u0015\u01c7\b\u0015\u0001\u0016\u0001\u0016\u0001"+
"\u0016\u0001\u0016\u0001\u0016\u0005\u0016\u01ce\b\u0016\n\u0016\f\u0016"+
"\u01d1\t\u0016\u0001\u0016\u0001\u0016\u0003\u0016\u01d5\b\u0016\u0001"+
"\u0016\u0001\u0016\u0001\u0017\u0001\u0017\u0003\u0017\u01db\b\u0017\u0001"+
"\u0018\u0001\u0018\u0003\u0018\u01df\b\u0018\u0001\u0019\u0001\u0019\u0001"+
"\u0019\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001b\u0001\u001b\u0001"+
"\u001b\u0001\u001b\u0003\u001b\u01eb\b\u001b\u0001\u001b\u0001\u001b\u0001"+
"\u001c\u0001\u001c\u0001\u001c\u0003\u001c\u01f2\b\u001c\u0001\u001c\u0001"+
"\u001c\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001e\u0005"+
"\u001e\u01fb\b\u001e\n\u001e\f\u001e\u01fe\t\u001e\u0001\u001e\u0001\u001e"+
"\u0003\u001e\u0202\b\u001e\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f"+
"\u0001\u001f\u0001\u001f\u0001\u001f\u0003\u001f\u020b\b\u001f\u0001 "+
"\u0001 \u0001 \u0001 \u0005 \u0211\b \n \f \u0214\t \u0001 \u0001 \u0001"+
"!\u0001!\u0001!\u0005!\u021b\b!\n!\f!\u021e\t!\u0001!\u0001!\u0001!\u0001"+
"\"\u0005\"\u0224\b\"\n\"\f\"\u0227\t\"\u0001\"\u0001\"\u0001\"\u0005\""+
"\u022c\b\"\n\"\f\"\u022f\t\"\u0001\"\u0001\"\u0003\"\u0233\b\"\u0001\""+
"\u0001\"\u0001\"\u0001\"\u0005\"\u0239\b\"\n\"\f\"\u023c\t\"\u0001\"\u0001"+
"\"\u0003\"\u0240\b\"\u0001\"\u0001\"\u0001#\u0001#\u0001#\u0001#\u0001"+
"#\u0001#\u0003#\u024a\b#\u0001$\u0001$\u0001$\u0001%\u0001%\u0001%\u0005"+
"%\u0252\b%\n%\f%\u0255\t%\u0001&\u0001&\u0001&\u0003&\u025a\b&\u0001\'"+
"\u0001\'\u0001\'\u0005\'\u025f\b\'\n\'\f\'\u0262\t\'\u0001(\u0001(\u0003"+
"(\u0266\b(\u0001)\u0001)\u0001)\u0001)\u0005)\u026c\b)\n)\f)\u026f\t)"+
"\u0001)\u0003)\u0272\b)\u0003)\u0274\b)\u0001)\u0001)\u0001*\u0001*\u0003"+
"*\u027a\b*\u0001*\u0001*\u0001*\u0003*\u027f\b*\u0005*\u0281\b*\n*\f*"+
"\u0284\t*\u0001+\u0001+\u0001+\u0001+\u0003+\u028a\b+\u0003+\u028c\b+"+
"\u0001,\u0001,\u0001,\u0005,\u0291\b,\n,\f,\u0294\t,\u0001-\u0001-\u0003"+
"-\u0298\b-\u0001-\u0001-\u0001.\u0001.\u0001.\u0005.\u029f\b.\n.\f.\u02a2"+
"\t.\u0001.\u0001.\u0003.\u02a6\b.\u0001.\u0003.\u02a9\b.\u0001/\u0005"+
"/\u02ac\b/\n/\f/\u02af\t/\u0001/\u0001/\u0001/\u00010\u00050\u02b5\b0"+
"\n0\f0\u02b8\t0\u00010\u00010\u00010\u00010\u00011\u00011\u00011\u0005"+
"1\u02c1\b1\n1\f1\u02c4\t1\u00012\u00012\u00012\u00012\u00012\u00012\u0001"+
"2\u00032\u02cd\b2\u00013\u00013\u00014\u00014\u00015\u00015\u00015\u0001"+
"5\u00015\u00035\u02d8\b5\u00015\u00035\u02db\b5\u00016\u00016\u00016\u0005"+
"6\u02e0\b6\n6\f6\u02e3\t6\u00017\u00017\u00017\u00017\u00018\u00018\u0001"+
"8\u00038\u02ec\b8\u00019\u00019\u00019\u00019\u00059\u02f2\b9\n9\f9\u02f5"+
"\t9\u00039\u02f7\b9\u00019\u00039\u02fa\b9\u00019\u00019\u0001:\u0001"+
":\u0001:\u0001:\u0001:\u0001;\u0001;\u0005;\u0305\b;\n;\f;\u0308\t;\u0001"+
";\u0001;\u0001<\u0005<\u030d\b<\n<\f<\u0310\t<\u0001<\u0001<\u0003<\u0314"+
"\b<\u0001=\u0001=\u0001=\u0001=\u0001=\u0001=\u0003=\u031c\b=\u0001=\u0001"+
"=\u0003=\u0320\b=\u0001=\u0001=\u0003=\u0324\b=\u0001=\u0001=\u0003=\u0328"+
"\b=\u0003=\u032a\b=\u0001>\u0001>\u0003>\u032e\b>\u0001?\u0001?\u0001"+
"?\u0001?\u0003?\u0334\b?\u0001@\u0001@\u0001A\u0001A\u0001A\u0001B\u0001"+
"B\u0005B\u033d\bB\nB\fB\u0340\tB\u0001B\u0001B\u0001C\u0001C\u0001C\u0001"+
"C\u0001C\u0003C\u0349\bC\u0001D\u0005D\u034c\bD\nD\fD\u034f\tD\u0001D"+
"\u0001D\u0001D\u0001E\u0005E\u0355\bE\nE\fE\u0358\tE\u0001E\u0001E\u0001"+
"E\u0003E\u035d\bE\u0001E\u0003E\u0360\bE\u0001F\u0001F\u0001F\u0001F\u0001"+
"F\u0003F\u0367\bF\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0003"+
"F\u0370\bF\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001"+
"F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001"+
"F\u0004F\u0385\bF\u000bF\fF\u0386\u0001F\u0003F\u038a\bF\u0001F\u0003"+
"F\u038d\bF\u0001F\u0001F\u0001F\u0001F\u0005F\u0393\bF\nF\fF\u0396\tF"+
"\u0001F\u0003F\u0399\bF\u0001F\u0001F\u0001F\u0001F\u0005F\u039f\bF\n"+
"F\fF\u03a2\tF\u0001F\u0005F\u03a5\bF\nF\fF\u03a8\tF\u0001F\u0001F\u0001"+
"F\u0001F\u0001F\u0001F\u0005F\u03b0\bF\nF\fF\u03b3\tF\u0001F\u0005F\u03b6"+
"\bF\nF\fF\u03b9\tF\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001"+
"F\u0003F\u03c3\bF\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001"+
"F\u0001F\u0001F\u0001F\u0003F\u03d0\bF\u0001F\u0001F\u0001F\u0003F\u03d5"+
"\bF\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0003"+
"F\u03e0\bF\u0001G\u0001G\u0001G\u0005G\u03e5\bG\nG\fG\u03e8\tG\u0001G"+
"\u0001G\u0001G\u0001G\u0001G\u0001H\u0001H\u0001H\u0005H\u03f2\bH\nH\f"+
"H\u03f5\tH\u0001I\u0001I\u0001I\u0001J\u0001J\u0001J\u0003J\u03fd\bJ\u0001"+
"J\u0001J\u0001K\u0001K\u0001K\u0005K\u0404\bK\nK\fK\u0407\tK\u0001L\u0005"+
"L\u040a\bL\nL\fL\u040d\tL\u0001L\u0001L\u0001L\u0001L\u0001L\u0001M\u0004"+
"M\u0415\bM\u000bM\fM\u0416\u0001M\u0004M\u041a\bM\u000bM\fM\u041b\u0001"+
"N\u0001N\u0001N\u0003N\u0421\bN\u0001N\u0001N\u0001N\u0001N\u0003N\u0427"+
"\bN\u0001O\u0004O\u042a\bO\u000bO\fO\u042b\u0001O\u0004O\u042f\bO\u000b"+
"O\fO\u0430\u0001P\u0001P\u0001P\u0001P\u0005P\u0437\bP\nP\fP\u043a\tP"+
"\u0001P\u0003P\u043d\bP\u0001P\u0001P\u0001P\u0001P\u0003P\u0443\bP\u0001"+
"Q\u0001Q\u0003Q\u0447\bQ\u0001Q\u0001Q\u0003Q\u044b\bQ\u0001Q\u0001Q\u0003"+
"Q\u044f\bQ\u0003Q\u0451\bQ\u0001R\u0001R\u0003R\u0455\bR\u0001S\u0005"+
"S\u0458\bS\nS\fS\u045b\tS\u0001S\u0001S\u0001S\u0001S\u0001S\u0001T\u0001"+
"T\u0001T\u0001T\u0001U\u0001U\u0001U\u0005U\u0469\bU\nU\fU\u046c\tU\u0001"+
"V\u0001V\u0001V\u0003V\u0471\bV\u0001V\u0001V\u0001V\u0001V\u0001V\u0003"+
"V\u0478\bV\u0001V\u0001V\u0001V\u0001V\u0003V\u047e\bV\u0001V\u0003V\u0481"+
"\bV\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001"+
"W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0003W\u0495"+
"\bW\u0001W\u0001W\u0003W\u0499\bW\u0001W\u0001W\u0001W\u0003W\u049e\b"+
"W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0005W\u04a6\bW\nW\fW\u04a9"+
"\tW\u0001W\u0005W\u04ac\bW\nW\fW\u04af\tW\u0001W\u0001W\u0003W\u04b3\b"+
"W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001"+
"W\u0001W\u0001W\u0001W\u0001W\u0003W\u04c3\bW\u0001W\u0001W\u0001W\u0001"+
"W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001"+
"W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001"+
"W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001"+
"W\u0001W\u0001W\u0001W\u0001W\u0003W\u04eb\bW\u0001W\u0001W\u0001W\u0001"+
"W\u0003W\u04f1\bW\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001"+
"W\u0001W\u0001W\u0001W\u0003W\u04fe\bW\u0001W\u0001W\u0001W\u0003W\u0503"+
"\bW\u0001W\u0005W\u0506\bW\nW\fW\u0509\tW\u0001X\u0001X\u0001X\u0001X"+
"\u0001Y\u0001Y\u0001Y\u0003Y\u0512\bY\u0001Y\u0001Y\u0001Y\u0001Y\u0001"+
"Y\u0005Y\u0519\bY\nY\fY\u051c\tY\u0001Y\u0001Y\u0003Y\u0520\bY\u0001Z"+
"\u0001Z\u0003Z\u0524\bZ\u0001[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001"+
"[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001[\u0003"+
"[\u0536\b[\u0003[\u0538\b[\u0001\\\u0001\\\u0001\\\u0003\\\u053d\b\\\u0001"+
"\\\u0005\\\u0540\b\\\n\\\f\\\u0543\t\\\u0001\\\u0001\\\u0003\\\u0547\b"+
"\\\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0003]\u0550\b]\u0003"+
"]\u0552\b]\u0001^\u0001^\u0003^\u0556\b^\u0001^\u0001^\u0001^\u0003^\u055b"+
"\b^\u0005^\u055d\b^\n^\f^\u0560\t^\u0001^\u0003^\u0563\b^\u0001_\u0001"+
"_\u0003_\u0567\b_\u0001_\u0001_\u0001`\u0001`\u0001`\u0001`\u0005`\u056f"+
"\b`\n`\f`\u0572\t`\u0001`\u0001`\u0001`\u0001`\u0001`\u0001`\u0001`\u0005"+
"`\u057b\b`\n`\f`\u057e\t`\u0001`\u0001`\u0005`\u0582\b`\n`\f`\u0585\t"+
"`\u0003`\u0587\b`\u0001a\u0001a\u0003a\u058b\ba\u0001b\u0001b\u0001b\u0001"+
"c\u0001c\u0001c\u0003c\u0593\bc\u0001d\u0001d\u0001d\u0003d\u0598\bd\u0001"+
"e\u0001e\u0001e\u0001e\u0001f\u0001f\u0001f\u0005f\u05a1\bf\nf\ff\u05a4"+
"\tf\u0001g\u0003g\u05a7\bg\u0001g\u0001g\u0003g\u05ab\bg\u0001g\u0001"+
"g\u0005g\u05af\bg\ng\fg\u05b2\tg\u0001h\u0001h\u0001i\u0001i\u0001i\u0001"+
"i\u0005i\u05ba\bi\ni\fi\u05bd\ti\u0001i\u0001i\u0001j\u0001j\u0001j\u0001"+
"j\u0003j\u05c5\bj\u0003j\u05c7\bj\u0001k\u0001k\u0001k\u0001k\u0001k\u0003"+
"k\u05ce\bk\u0001l\u0001l\u0003l\u05d2\bl\u0001l\u0001l\u0001l\u0000\u0001"+
"\u00aem\u0000\u0002\u0004\u0006\b\n\f\u000e\u0010\u0012\u0014\u0016\u0018"+
"\u001a\u001c\u001e \"$&(*,.02468:<>@BDFHJLNPRTVXZ\\^`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\u0000\u000e\u0002\u0000"+
"$$rr\u0002\u0000\u0011\u0011))\u0001\u000058\u0001\u00009:\u0002\u0000"+
"OOkk\u0001\u0000VY\u0001\u0000LM\u0002\u0000Z[__\u0001\u0000XY\u0002\u0000"+
"JKQR\u0002\u0000PPSS\u0002\u0000II`j\u0001\u0000VW\b\u0000\u0003\u0003"+
"\u0005\u0005\b\b\u000e\u000e\u0014\u0014\u001b\u001b\u001d\u001d&&\u067f"+
"\u0000\u00da\u0001\u0000\u0000\u0000\u0002\u00dd\u0001\u0000\u0000\u0000"+
"\u0004\u00f0\u0001\u0000\u0000\u0000\u0006\u00f7\u0001\u0000\u0000\u0000"+
"\b\u0113\u0001\u0000\u0000\u0000\n\u011a\u0001\u0000\u0000\u0000\f\u0124"+
"\u0001\u0000\u0000\u0000\u000e\u0128\u0001\u0000\u0000\u0000\u0010\u012a"+
"\u0001\u0000\u0000\u0000\u0012\u0133\u0001\u0000\u0000\u0000\u0014\u0142"+
"\u0001\u0000\u0000\u0000\u0016\u0150\u0001\u0000\u0000\u0000\u0018\u0158"+
"\u0001\u0000\u0000\u0000\u001a\u0160\u0001\u0000\u0000\u0000\u001c\u0172"+
"\u0001\u0000\u0000\u0000\u001e\u017d\u0001\u0000\u0000\u0000 \u0187\u0001"+
"\u0000\u0000\u0000\"\u018e\u0001\u0000\u0000\u0000$\u0199\u0001\u0000"+
"\u0000\u0000&\u01a2\u0001\u0000\u0000\u0000(\u01ba\u0001\u0000\u0000\u0000"+
"*\u01c6\u0001\u0000\u0000\u0000,\u01c8\u0001\u0000\u0000\u0000.\u01da"+
"\u0001\u0000\u0000\u00000\u01de\u0001\u0000\u0000\u00002\u01e0\u0001\u0000"+
"\u0000\u00004\u01e3\u0001\u0000\u0000\u00006\u01e6\u0001\u0000\u0000\u0000"+
"8\u01ee\u0001\u0000\u0000\u0000:\u01f5\u0001\u0000\u0000\u0000<\u0201"+
"\u0001\u0000\u0000\u0000>\u020a\u0001\u0000\u0000\u0000@\u020c\u0001\u0000"+
"\u0000\u0000B\u0217\u0001\u0000\u0000\u0000D\u0225\u0001\u0000\u0000\u0000"+
"F\u0249\u0001\u0000\u0000\u0000H\u024b\u0001\u0000\u0000\u0000J\u024e"+
"\u0001\u0000\u0000\u0000L\u0256\u0001\u0000\u0000\u0000N\u025b\u0001\u0000"+
"\u0000\u0000P\u0265\u0001\u0000\u0000\u0000R\u0267\u0001\u0000\u0000\u0000"+
"T\u0277\u0001\u0000\u0000\u0000V\u028b\u0001\u0000\u0000\u0000X\u028d"+
"\u0001\u0000\u0000\u0000Z\u0295\u0001\u0000\u0000\u0000\\\u02a8\u0001"+
"\u0000\u0000\u0000^\u02ad\u0001\u0000\u0000\u0000`\u02b6\u0001\u0000\u0000"+
"\u0000b\u02bd\u0001\u0000\u0000\u0000d\u02cc\u0001\u0000\u0000\u0000f"+
"\u02ce\u0001\u0000\u0000\u0000h\u02d0\u0001\u0000\u0000\u0000j\u02d2\u0001"+
"\u0000\u0000\u0000l\u02dc\u0001\u0000\u0000\u0000n\u02e4\u0001\u0000\u0000"+
"\u0000p\u02eb\u0001\u0000\u0000\u0000r\u02ed\u0001\u0000\u0000\u0000t"+
"\u02fd\u0001\u0000\u0000\u0000v\u0302\u0001\u0000\u0000\u0000x\u0313\u0001"+
"\u0000\u0000\u0000z\u0329\u0001\u0000\u0000\u0000|\u032d\u0001\u0000\u0000"+
"\u0000~\u032f\u0001\u0000\u0000\u0000\u0080\u0335\u0001\u0000\u0000\u0000"+
"\u0082\u0337\u0001\u0000\u0000\u0000\u0084\u033a\u0001\u0000\u0000\u0000"+
"\u0086\u0348\u0001\u0000\u0000\u0000\u0088\u034d\u0001\u0000\u0000\u0000"+
"\u008a\u035f\u0001\u0000\u0000\u0000\u008c\u03df\u0001\u0000\u0000\u0000"+
"\u008e\u03e1\u0001\u0000\u0000\u0000\u0090\u03ee\u0001\u0000\u0000\u0000"+
"\u0092\u03f6\u0001\u0000\u0000\u0000\u0094\u03f9\u0001\u0000\u0000\u0000"+
"\u0096\u0400\u0001\u0000\u0000\u0000\u0098\u040b\u0001\u0000\u0000\u0000"+
"\u009a\u0414\u0001\u0000\u0000\u0000\u009c\u0426\u0001\u0000\u0000\u0000"+
"\u009e\u0429\u0001\u0000\u0000\u0000\u00a0\u0442\u0001\u0000\u0000\u0000"+
"\u00a2\u0450\u0001\u0000\u0000\u0000\u00a4\u0454\u0001\u0000\u0000\u0000"+
"\u00a6\u0459\u0001\u0000\u0000\u0000\u00a8\u0461\u0001\u0000\u0000\u0000"+
"\u00aa\u0465\u0001\u0000\u0000\u0000\u00ac\u0480\u0001\u0000\u0000\u0000"+
"\u00ae\u04b2\u0001\u0000\u0000\u0000\u00b0\u050a\u0001\u0000\u0000\u0000"+
"\u00b2\u051f\u0001\u0000\u0000\u0000\u00b4\u0523\u0001\u0000\u0000\u0000"+
"\u00b6\u0537\u0001\u0000\u0000\u0000\u00b8\u053c\u0001\u0000\u0000\u0000"+
"\u00ba\u0551\u0001\u0000\u0000\u0000\u00bc\u0562\u0001\u0000\u0000\u0000"+
"\u00be\u0564\u0001\u0000\u0000\u0000\u00c0\u056a\u0001\u0000\u0000\u0000"+
"\u00c2\u0588\u0001\u0000\u0000\u0000\u00c4\u058c\u0001\u0000\u0000\u0000"+
"\u00c6\u0592\u0001\u0000\u0000\u0000\u00c8\u0597\u0001\u0000\u0000\u0000"+
"\u00ca\u0599\u0001\u0000\u0000\u0000\u00cc\u059d\u0001\u0000\u0000\u0000"+
"\u00ce\u05a6\u0001\u0000\u0000\u0000\u00d0\u05b3\u0001\u0000\u0000\u0000"+
"\u00d2\u05b5\u0001\u0000\u0000\u0000\u00d4\u05c6\u0001\u0000\u0000\u0000"+
"\u00d6\u05cd\u0001\u0000\u0000\u0000\u00d8\u05cf\u0001\u0000\u0000\u0000"+
"\u00da\u00db\u0007\u0000\u0000\u0000\u00db\u0001\u0001\u0000\u0000\u0000"+
"\u00dc\u00de\u0003\u0004\u0002\u0000\u00dd\u00dc\u0001\u0000\u0000\u0000"+
"\u00dd\u00de\u0001\u0000\u0000\u0000\u00de\u00e2\u0001\u0000\u0000\u0000"+
"\u00df\u00e1\u0003\u0006\u0003\u0000\u00e0\u00df\u0001\u0000\u0000\u0000"+
"\u00e1\u00e4\u0001\u0000\u0000\u0000\u00e2\u00e0\u0001\u0000\u0000\u0000"+
"\u00e2\u00e3\u0001\u0000\u0000\u0000\u00e3\u00e8\u0001\u0000\u0000\u0000"+
"\u00e4\u00e2\u0001\u0000\u0000\u0000\u00e5\u00e7\u0003\b\u0004\u0000\u00e6"+
"\u00e5\u0001\u0000\u0000\u0000\u00e7\u00ea\u0001\u0000\u0000\u0000\u00e8"+
"\u00e6\u0001\u0000\u0000\u0000\u00e8\u00e9\u0001\u0000\u0000\u0000\u00e9"+
"\u00eb\u0001\u0000\u0000\u0000\u00ea\u00e8\u0001\u0000\u0000\u0000\u00eb"+
"\u00ec\u0005\u0000\u0000\u0001\u00ec\u0003\u0001\u0000\u0000\u0000\u00ed"+
"\u00ef\u0003j5\u0000\u00ee\u00ed\u0001\u0000\u0000\u0000\u00ef\u00f2\u0001"+
"\u0000\u0000\u0000\u00f0\u00ee\u0001\u0000\u0000\u0000\u00f0\u00f1\u0001"+
"\u0000\u0000\u0000\u00f1\u00f3\u0001\u0000\u0000\u0000\u00f2\u00f0\u0001"+
"\u0000\u0000\u0000\u00f3\u00f4\u0005 \u0000\u0000\u00f4\u00f5\u0003b1"+
"\u0000\u00f5\u00f6\u0005F\u0000\u0000\u00f6\u0005\u0001\u0000\u0000\u0000"+
"\u00f7\u00f9\u0005\u0019\u0000\u0000\u00f8\u00fa\u0005\'\u0000\u0000\u00f9"+
"\u00f8\u0001\u0000\u0000\u0000\u00f9\u00fa\u0001\u0000\u0000\u0000\u00fa"+
"\u00fb\u0001\u0000\u0000\u0000\u00fb\u00fe\u0003b1\u0000\u00fc\u00fd\u0005"+
"H\u0000\u0000\u00fd\u00ff\u0005Z\u0000\u0000\u00fe\u00fc\u0001\u0000\u0000"+
"\u0000\u00fe\u00ff\u0001\u0000\u0000\u0000\u00ff\u0100\u0001\u0000\u0000"+
"\u0000\u0100\u0101\u0005F\u0000\u0000\u0101\u0007\u0001\u0000\u0000\u0000"+
"\u0102\u0104\u0005p\u0000\u0000\u0103\u0102\u0001\u0000\u0000\u0000\u0103"+
"\u0104\u0001\u0000\u0000\u0000\u0104\u0108\u0001\u0000\u0000\u0000\u0105"+
"\u0107\u0003\f\u0006\u0000\u0106\u0105\u0001\u0000\u0000\u0000\u0107\u010a"+
"\u0001\u0000\u0000\u0000\u0108\u0106\u0001\u0000\u0000\u0000\u0108\u0109"+
"\u0001\u0000\u0000\u0000\u0109\u0110\u0001\u0000\u0000\u0000\u010a\u0108"+
"\u0001\u0000\u0000\u0000\u010b\u0111\u0003\u0012\t\u0000\u010c\u0111\u0003"+
"\u001a\r\u0000\u010d\u0111\u0003\"\u0011\u0000\u010e\u0111\u0003t:\u0000"+
"\u010f\u0111\u0003\u0010\b\u0000\u0110\u010b\u0001\u0000\u0000\u0000\u0110"+
"\u010c\u0001\u0000\u0000\u0000\u0110\u010d\u0001\u0000\u0000\u0000\u0110"+
"\u010e\u0001\u0000\u0000\u0000\u0110\u010f\u0001\u0000\u0000\u0000\u0111"+
"\u0114\u0001\u0000\u0000\u0000\u0112\u0114\u0005F\u0000\u0000\u0113\u0103"+
"\u0001\u0000\u0000\u0000\u0113\u0112\u0001\u0000\u0000\u0000\u0114\t\u0001"+
"\u0000\u0000\u0000\u0115\u011b\u0003\f\u0006\u0000\u0116\u011b\u0005\u001e"+
"\u0000\u0000\u0117\u011b\u0005+\u0000\u0000\u0118\u011b\u0005/\u0000\u0000"+
"\u0119\u011b\u00052\u0000\u0000\u011a\u0115\u0001\u0000\u0000\u0000\u011a"+
"\u0116\u0001\u0000\u0000\u0000\u011a\u0117\u0001\u0000\u0000\u0000\u011a"+
"\u0118\u0001\u0000\u0000\u0000\u011a\u0119\u0001\u0000\u0000\u0000\u011b"+
"\u000b\u0001\u0000\u0000\u0000\u011c\u0125\u0003j5\u0000\u011d\u0125\u0005"+
"#\u0000\u0000\u011e\u0125\u0005\"\u0000\u0000\u011f\u0125\u0005!\u0000"+
"\u0000\u0120\u0125\u0005\'\u0000\u0000\u0121\u0125\u0005\u0001\u0000\u0000"+
"\u0122\u0125\u0005\u0012\u0000\u0000\u0123\u0125\u0005(\u0000\u0000\u0124"+
"\u011c\u0001\u0000\u0000\u0000\u0124\u011d\u0001\u0000\u0000\u0000\u0124"+
"\u011e\u0001\u0000\u0000\u0000\u0124\u011f\u0001\u0000\u0000\u0000\u0124"+
"\u0120\u0001\u0000\u0000\u0000\u0124\u0121\u0001\u0000\u0000\u0000\u0124"+
"\u0122\u0001\u0000\u0000\u0000\u0124\u0123\u0001\u0000\u0000\u0000\u0125"+
"\r\u0001\u0000\u0000\u0000\u0126\u0129\u0005\u0012\u0000\u0000\u0127\u0129"+
"\u0003j5\u0000\u0128\u0126\u0001\u0000\u0000\u0000\u0128\u0127\u0001\u0000"+
"\u0000\u0000\u0129\u000f\u0001\u0000\u0000\u0000\u012a\u012b\u0005$\u0000"+
"\u0000\u012b\u012c\u0003\u0000\u0000\u0000\u012c\u012f\u0003Z-\u0000\u012d"+
"\u012e\u0005\u0018\u0000\u0000\u012e\u0130\u0003\u00ccf\u0000\u012f\u012d"+
"\u0001\u0000\u0000\u0000\u012f\u0130\u0001\u0000\u0000\u0000\u0130\u0131"+
"\u0001\u0000\u0000\u0000\u0131\u0132\u0003$\u0012\u0000\u0132\u0011\u0001"+
"\u0000\u0000\u0000\u0133\u0134\u0005\t\u0000\u0000\u0134\u0136\u0003\u0000"+
"\u0000\u0000\u0135\u0137\u0003\u0014\n\u0000\u0136\u0135\u0001\u0000\u0000"+
"\u0000\u0136\u0137\u0001\u0000\u0000\u0000\u0137\u013a\u0001\u0000\u0000"+
"\u0000\u0138\u0139\u0005\u0011\u0000\u0000\u0139\u013b\u0003\u00ceg\u0000"+
"\u013a\u0138\u0001\u0000\u0000\u0000\u013a\u013b\u0001\u0000\u0000\u0000"+
"\u013b\u013e\u0001\u0000\u0000\u0000\u013c\u013d\u0005\u0018\u0000\u0000"+
"\u013d\u013f\u0003\u00ccf\u0000\u013e\u013c\u0001\u0000\u0000\u0000\u013e"+
"\u013f\u0001\u0000\u0000\u0000\u013f\u0140\u0001\u0000\u0000\u0000\u0140"+
"\u0141\u0003$\u0012\u0000\u0141\u0013\u0001\u0000\u0000\u0000\u0142\u0143"+
"\u0005K\u0000\u0000\u0143\u0148\u0003\u0016\u000b\u0000\u0144\u0145\u0005"+
"G\u0000\u0000\u0145\u0147\u0003\u0016\u000b\u0000\u0146\u0144\u0001\u0000"+
"\u0000\u0000\u0147\u014a\u0001\u0000\u0000\u0000\u0148\u0146\u0001\u0000"+
"\u0000\u0000\u0148\u0149\u0001\u0000\u0000\u0000\u0149\u014b\u0001\u0000"+
"\u0000\u0000\u014a\u0148\u0001\u0000\u0000\u0000\u014b\u014c\u0005J\u0000"+
"\u0000\u014c\u0015\u0001\u0000\u0000\u0000\u014d\u014f\u0003j5\u0000\u014e"+
"\u014d\u0001\u0000\u0000\u0000\u014f\u0152\u0001\u0000\u0000\u0000\u0150"+
"\u014e\u0001\u0000\u0000\u0000\u0150\u0151\u0001\u0000\u0000\u0000\u0151"+
"\u0153\u0001\u0000\u0000\u0000\u0152\u0150\u0001\u0000\u0000\u0000\u0153"+
"\u0156\u0003\u0000\u0000\u0000\u0154\u0155\u0005\u0011\u0000\u0000\u0155"+
"\u0157\u0003\u0018\f\u0000\u0156\u0154\u0001\u0000\u0000\u0000\u0156\u0157"+
"\u0001\u0000\u0000\u0000\u0157\u0017\u0001\u0000\u0000\u0000\u0158\u015d"+
"\u0003\u00ceg\u0000\u0159\u015a\u0005\\\u0000\u0000\u015a\u015c\u0003"+
"\u00ceg\u0000\u015b\u0159\u0001\u0000\u0000\u0000\u015c\u015f\u0001\u0000"+
"\u0000\u0000\u015d\u015b\u0001\u0000\u0000\u0000\u015d\u015e\u0001\u0000"+
"\u0000\u0000\u015e\u0019\u0001\u0000\u0000\u0000\u015f\u015d\u0001\u0000"+
"\u0000\u0000\u0160\u0161\u0005\u0010\u0000\u0000\u0161\u0164\u0003\u0000"+
"\u0000\u0000\u0162\u0163\u0005\u0018\u0000\u0000\u0163\u0165\u0003\u00cc"+
"f\u0000\u0164\u0162\u0001\u0000\u0000\u0000\u0164\u0165\u0001\u0000\u0000"+
"\u0000\u0165\u0166\u0001\u0000\u0000\u0000\u0166\u0168\u0005B\u0000\u0000"+
"\u0167\u0169\u0003\u001c\u000e\u0000\u0168\u0167\u0001\u0000\u0000\u0000"+
"\u0168\u0169\u0001\u0000\u0000\u0000\u0169\u016b\u0001\u0000\u0000\u0000"+
"\u016a\u016c\u0005G\u0000\u0000\u016b\u016a\u0001\u0000\u0000\u0000\u016b"+
"\u016c\u0001\u0000\u0000\u0000\u016c\u016e\u0001\u0000\u0000\u0000\u016d"+
"\u016f\u0003 \u0010\u0000\u016e\u016d\u0001\u0000\u0000\u0000\u016e\u016f"+
"\u0001\u0000\u0000\u0000\u016f\u0170\u0001\u0000\u0000\u0000\u0170\u0171"+
"\u0005C\u0000\u0000\u0171\u001b\u0001\u0000\u0000\u0000\u0172\u0177\u0003"+
"\u001e\u000f\u0000\u0173\u0174\u0005G\u0000\u0000\u0174\u0176\u0003\u001e"+
"\u000f\u0000\u0175\u0173\u0001\u0000\u0000\u0000\u0176\u0179\u0001\u0000"+
"\u0000\u0000\u0177\u0175\u0001\u0000\u0000\u0000\u0177\u0178\u0001\u0000"+
"\u0000\u0000\u0178\u001d\u0001\u0000\u0000\u0000\u0179\u0177\u0001\u0000"+
"\u0000\u0000\u017a\u017c\u0003j5\u0000\u017b\u017a\u0001\u0000\u0000\u0000"+
"\u017c\u017f\u0001\u0000\u0000\u0000\u017d\u017b\u0001\u0000\u0000\u0000"+
"\u017d\u017e\u0001\u0000\u0000\u0000\u017e\u0180\u0001\u0000\u0000\u0000"+
"\u017f\u017d\u0001\u0000\u0000\u0000\u0180\u0182\u0003\u0000\u0000\u0000"+
"\u0181\u0183\u0003\u00d8l\u0000\u0182\u0181\u0001\u0000\u0000\u0000\u0182"+
"\u0183\u0001\u0000\u0000\u0000\u0183\u0185\u0001\u0000\u0000\u0000\u0184"+
"\u0186\u0003$\u0012\u0000\u0185\u0184\u0001\u0000\u0000\u0000\u0185\u0186"+
"\u0001\u0000\u0000\u0000\u0186\u001f\u0001\u0000\u0000\u0000\u0187\u018b"+
"\u0005F\u0000\u0000\u0188\u018a\u0003(\u0014\u0000\u0189\u0188\u0001\u0000"+
"\u0000\u0000\u018a\u018d\u0001\u0000\u0000\u0000\u018b\u0189\u0001\u0000"+
"\u0000\u0000\u018b\u018c\u0001\u0000\u0000\u0000\u018c!\u0001\u0000\u0000"+
"\u0000\u018d\u018b\u0001\u0000\u0000\u0000\u018e\u018f\u0005\u001c\u0000"+
"\u0000\u018f\u0191\u0003\u0000\u0000\u0000\u0190\u0192\u0003\u0014\n\u0000"+
"\u0191\u0190\u0001\u0000\u0000\u0000\u0191\u0192\u0001\u0000\u0000\u0000"+
"\u0192\u0195\u0001\u0000\u0000\u0000\u0193\u0194\u0005\u0011\u0000\u0000"+
"\u0194\u0196\u0003\u00ccf\u0000\u0195\u0193\u0001\u0000\u0000\u0000\u0195"+
"\u0196\u0001\u0000\u0000\u0000\u0196\u0197\u0001\u0000\u0000\u0000\u0197"+
"\u0198\u0003&\u0013\u0000\u0198#\u0001\u0000\u0000\u0000\u0199\u019d\u0005"+
"B\u0000\u0000\u019a\u019c\u0003(\u0014\u0000\u019b\u019a\u0001\u0000\u0000"+
"\u0000\u019c\u019f\u0001\u0000\u0000\u0000\u019d\u019b\u0001\u0000\u0000"+
"\u0000\u019d\u019e\u0001\u0000\u0000\u0000\u019e\u01a0\u0001\u0000\u0000"+
"\u0000\u019f\u019d\u0001\u0000\u0000\u0000\u01a0\u01a1\u0005C\u0000\u0000"+
"\u01a1%\u0001\u0000\u0000\u0000\u01a2\u01a6\u0005B\u0000\u0000\u01a3\u01a5"+
"\u0003<\u001e\u0000\u01a4\u01a3\u0001\u0000\u0000\u0000\u01a5\u01a8\u0001"+
"\u0000\u0000\u0000\u01a6\u01a4\u0001\u0000\u0000\u0000\u01a6\u01a7\u0001"+
"\u0000\u0000\u0000\u01a7\u01a9\u0001\u0000\u0000\u0000\u01a8\u01a6\u0001"+
"\u0000\u0000\u0000\u01a9\u01aa\u0005C\u0000\u0000\u01aa\'\u0001\u0000"+
"\u0000\u0000\u01ab\u01bb\u0005F\u0000\u0000\u01ac\u01ae\u0005\'\u0000"+
"\u0000\u01ad\u01ac\u0001\u0000\u0000\u0000\u01ad\u01ae\u0001\u0000\u0000"+
"\u0000\u01ae\u01af\u0001\u0000\u0000\u0000\u01af\u01bb\u0003\u0084B\u0000"+
"\u01b0\u01b2\u0005p\u0000\u0000\u01b1\u01b0\u0001\u0000\u0000\u0000\u01b1"+
"\u01b2\u0001\u0000\u0000\u0000\u01b2\u01b6\u0001\u0000\u0000\u0000\u01b3"+
"\u01b5\u0003\n\u0005\u0000\u01b4\u01b3\u0001\u0000\u0000\u0000\u01b5\u01b8"+
"\u0001\u0000\u0000\u0000\u01b6\u01b4\u0001\u0000\u0000\u0000\u01b6\u01b7"+
"\u0001\u0000\u0000\u0000\u01b7\u01b9\u0001\u0000\u0000\u0000\u01b8\u01b6"+
"\u0001\u0000\u0000\u0000\u01b9\u01bb\u0003*\u0015\u0000\u01ba\u01ab\u0001"+
"\u0000\u0000\u0000\u01ba\u01ad\u0001\u0000\u0000\u0000\u01ba\u01b1\u0001"+
"\u0000\u0000\u0000\u01bb)\u0001\u0000\u0000\u0000\u01bc\u01c7\u0003,\u0016"+
"\u0000\u01bd\u01c7\u00032\u0019\u0000\u01be\u01c7\u0003:\u001d\u0000\u01bf"+
"\u01c7\u00036\u001b\u0000\u01c0\u01c7\u00034\u001a\u0000\u01c1\u01c7\u0003"+
"8\u001c\u0000\u01c2\u01c7\u0003\"\u0011\u0000\u01c3\u01c7\u0003t:\u0000"+
"\u01c4\u01c7\u0003\u0012\t\u0000\u01c5\u01c7\u0003\u001a\r\u0000\u01c6"+
"\u01bc\u0001\u0000\u0000\u0000\u01c6\u01bd\u0001\u0000\u0000\u0000\u01c6"+
"\u01be\u0001\u0000\u0000\u0000\u01c6\u01bf\u0001\u0000\u0000\u0000\u01c6"+
"\u01c0\u0001\u0000\u0000\u0000\u01c6\u01c1\u0001\u0000\u0000\u0000\u01c6"+
"\u01c2\u0001\u0000\u0000\u0000\u01c6\u01c3\u0001\u0000\u0000\u0000\u01c6"+
"\u01c4\u0001\u0000\u0000\u0000\u01c6\u01c5\u0001\u0000\u0000\u0000\u01c7"+
"+\u0001\u0000\u0000\u0000\u01c8\u01c9\u00030\u0018\u0000\u01c9\u01ca\u0003"+
"\u0000\u0000\u0000\u01ca\u01cf\u0003Z-\u0000\u01cb\u01cc\u0005D\u0000"+
"\u0000\u01cc\u01ce\u0005E\u0000\u0000\u01cd\u01cb\u0001\u0000\u0000\u0000"+
"\u01ce\u01d1\u0001\u0000\u0000\u0000\u01cf\u01cd\u0001\u0000\u0000\u0000"+
"\u01cf\u01d0\u0001\u0000\u0000\u0000\u01d0\u01d4\u0001\u0000\u0000\u0000"+
"\u01d1\u01cf\u0001\u0000\u0000\u0000\u01d2\u01d3\u0005.\u0000\u0000\u01d3"+
"\u01d5\u0003X,\u0000\u01d4\u01d2\u0001\u0000\u0000\u0000\u01d4\u01d5\u0001"+
"\u0000\u0000\u0000\u01d5\u01d6\u0001\u0000\u0000\u0000\u01d6\u01d7\u0003"+
".\u0017\u0000\u01d7-\u0001\u0000\u0000\u0000\u01d8\u01db\u0003\u0084B"+
"\u0000\u01d9\u01db\u0005F\u0000\u0000\u01da\u01d8\u0001\u0000\u0000\u0000"+
"\u01da\u01d9\u0001\u0000\u0000\u0000\u01db/\u0001\u0000\u0000\u0000\u01dc"+
"\u01df\u0003\u00ceg\u0000\u01dd\u01df\u00051\u0000\u0000\u01de\u01dc\u0001"+
"\u0000\u0000\u0000\u01de\u01dd\u0001\u0000\u0000\u0000\u01df1\u0001\u0000"+
"\u0000\u0000\u01e0\u01e1\u0003\u0014\n\u0000\u01e1\u01e2\u0003,\u0016"+
"\u0000\u01e23\u0001\u0000\u0000\u0000\u01e3\u01e4\u0003\u0014\n\u0000"+
"\u01e4\u01e5\u00036\u001b\u0000\u01e55\u0001\u0000\u0000\u0000\u01e6\u01e7"+
"\u0003\u0000\u0000\u0000\u01e7\u01ea\u0003Z-\u0000\u01e8\u01e9\u0005."+
"\u0000\u0000\u01e9\u01eb\u0003X,\u0000\u01ea\u01e8\u0001\u0000\u0000\u0000"+
"\u01ea\u01eb\u0001\u0000\u0000\u0000\u01eb\u01ec\u0001\u0000\u0000\u0000"+
"\u01ec\u01ed\u0003\u0084B\u0000\u01ed7\u0001\u0000\u0000\u0000\u01ee\u01f1"+
"\u0003\u0000\u0000\u0000\u01ef\u01f0\u0005.\u0000\u0000\u01f0\u01f2\u0003"+
"X,\u0000\u01f1\u01ef\u0001\u0000\u0000\u0000\u01f1\u01f2\u0001\u0000\u0000"+
"\u0000\u01f2\u01f3\u0001\u0000\u0000\u0000\u01f3\u01f4\u0003\u0084B\u0000"+
"\u01f49\u0001\u0000\u0000\u0000\u01f5\u01f6\u0003\u00ceg\u0000\u01f6\u01f7"+
"\u0003J%\u0000\u01f7\u01f8\u0005F\u0000\u0000\u01f8;\u0001\u0000\u0000"+
"\u0000\u01f9\u01fb\u0003\n\u0005\u0000\u01fa\u01f9\u0001\u0000\u0000\u0000"+
"\u01fb\u01fe\u0001\u0000\u0000\u0000\u01fc\u01fa\u0001\u0000\u0000\u0000"+
"\u01fc\u01fd\u0001\u0000\u0000\u0000\u01fd\u01ff\u0001\u0000\u0000\u0000"+
"\u01fe\u01fc\u0001\u0000\u0000\u0000\u01ff\u0202\u0003>\u001f\u0000\u0200"+
"\u0202\u0005F\u0000\u0000\u0201\u01fc\u0001\u0000\u0000\u0000\u0201\u0200"+
"\u0001\u0000\u0000\u0000\u0202=\u0001\u0000\u0000\u0000\u0203\u020b\u0003"+
"@ \u0000\u0204\u020b\u0003D\"\u0000\u0205\u020b\u0003H$\u0000\u0206\u020b"+
"\u0003\"\u0011\u0000\u0207\u020b\u0003t:\u0000\u0208\u020b\u0003\u0012"+
"\t\u0000\u0209\u020b\u0003\u001a\r\u0000\u020a\u0203\u0001\u0000\u0000"+
"\u0000\u020a\u0204\u0001\u0000\u0000\u0000\u020a\u0205\u0001\u0000\u0000"+
"\u0000\u020a\u0206\u0001\u0000\u0000\u0000\u020a\u0207\u0001\u0000\u0000"+
"\u0000\u020a\u0208\u0001\u0000\u0000\u0000\u020a\u0209\u0001\u0000\u0000"+
"\u0000\u020b?\u0001\u0000\u0000\u0000\u020c\u020d\u0003\u00ceg\u0000\u020d"+
"\u0212\u0003B!\u0000\u020e\u020f\u0005G\u0000\u0000\u020f\u0211\u0003"+
"B!\u0000\u0210\u020e\u0001\u0000\u0000\u0000\u0211\u0214\u0001\u0000\u0000"+
"\u0000\u0212\u0210\u0001\u0000\u0000\u0000\u0212\u0213\u0001\u0000\u0000"+
"\u0000\u0213\u0215\u0001\u0000\u0000\u0000\u0214\u0212\u0001\u0000\u0000"+
"\u0000\u0215\u0216\u0005F\u0000\u0000\u0216A\u0001\u0000\u0000\u0000\u0217"+
"\u021c\u0003\u0000\u0000\u0000\u0218\u0219\u0005D\u0000\u0000\u0219\u021b"+
"\u0005E\u0000\u0000\u021a\u0218\u0001\u0000\u0000\u0000\u021b\u021e\u0001"+
"\u0000\u0000\u0000\u021c\u021a\u0001\u0000\u0000\u0000\u021c\u021d\u0001"+
"\u0000\u0000\u0000\u021d\u021f\u0001\u0000\u0000\u0000\u021e\u021c\u0001"+
"\u0000\u0000\u0000\u021f\u0220\u0005I\u0000\u0000\u0220\u0221\u0003P("+
"\u0000\u0221C\u0001\u0000\u0000\u0000\u0222\u0224\u0003F#\u0000\u0223"+
"\u0222\u0001\u0000\u0000\u0000\u0224\u0227\u0001\u0000\u0000\u0000\u0225"+
"\u0223\u0001\u0000\u0000\u0000\u0225\u0226\u0001\u0000\u0000\u0000\u0226"+
"\u0232\u0001\u0000\u0000\u0000\u0227\u0225\u0001\u0000\u0000\u0000\u0228"+
"\u0233\u00030\u0018\u0000\u0229\u022d\u0003\u0014\n\u0000\u022a\u022c"+
"\u0003j5\u0000\u022b\u022a\u0001\u0000\u0000\u0000\u022c\u022f\u0001\u0000"+
"\u0000\u0000\u022d\u022b\u0001\u0000\u0000\u0000\u022d\u022e\u0001\u0000"+
"\u0000\u0000\u022e\u0230\u0001\u0000\u0000\u0000\u022f\u022d\u0001\u0000"+
"\u0000\u0000\u0230\u0231\u00030\u0018\u0000\u0231\u0233\u0001\u0000\u0000"+
"\u0000\u0232\u0228\u0001\u0000\u0000\u0000\u0232\u0229\u0001\u0000\u0000"+
"\u0000\u0233\u0234\u0001\u0000\u0000\u0000\u0234\u0235\u0003\u0000\u0000"+
"\u0000\u0235\u023a\u0003Z-\u0000\u0236\u0237\u0005D\u0000\u0000\u0237"+
"\u0239\u0005E\u0000\u0000\u0238\u0236\u0001\u0000\u0000\u0000\u0239\u023c"+
"\u0001\u0000\u0000\u0000\u023a\u0238\u0001\u0000\u0000\u0000\u023a\u023b"+
"\u0001\u0000\u0000\u0000\u023b\u023f\u0001\u0000\u0000\u0000\u023c\u023a"+
"\u0001\u0000\u0000\u0000\u023d\u023e\u0005.\u0000\u0000\u023e\u0240\u0003"+
"X,\u0000\u023f\u023d\u0001\u0000\u0000\u0000\u023f\u0240\u0001\u0000\u0000"+
"\u0000\u0240\u0241\u0001\u0000\u0000\u0000\u0241\u0242\u0003.\u0017\u0000"+
"\u0242E\u0001\u0000\u0000\u0000\u0243\u024a\u0003j5\u0000\u0244\u024a"+
"\u0005#\u0000\u0000\u0245\u024a\u0005\u0001\u0000\u0000\u0246\u024a\u0005"+
"\f\u0000\u0000\u0247\u024a\u0005\'\u0000\u0000\u0248\u024a\u0005(\u0000"+
"\u0000\u0249\u0243\u0001\u0000\u0000\u0000\u0249\u0244\u0001\u0000\u0000"+
"\u0000\u0249\u0245\u0001\u0000\u0000\u0000\u0249\u0246\u0001\u0000\u0000"+
"\u0000\u0249\u0247\u0001\u0000\u0000\u0000\u0249\u0248\u0001\u0000\u0000"+
"\u0000\u024aG\u0001\u0000\u0000\u0000\u024b\u024c\u0003\u0014\n\u0000"+
"\u024c\u024d\u0003D\"\u0000\u024dI\u0001\u0000\u0000\u0000\u024e\u0253"+
"\u0003L&\u0000\u024f\u0250\u0005G\u0000\u0000\u0250\u0252\u0003L&\u0000"+
"\u0251\u024f\u0001\u0000\u0000\u0000\u0252\u0255\u0001\u0000\u0000\u0000"+
"\u0253\u0251\u0001\u0000\u0000\u0000\u0253\u0254\u0001\u0000\u0000\u0000"+
"\u0254K\u0001\u0000\u0000\u0000\u0255\u0253\u0001\u0000\u0000\u0000\u0256"+
"\u0259\u0003N\'\u0000\u0257\u0258\u0005I\u0000\u0000\u0258\u025a\u0003"+
"P(\u0000\u0259\u0257\u0001\u0000\u0000\u0000\u0259\u025a\u0001\u0000\u0000"+
"\u0000\u025aM\u0001\u0000\u0000\u0000\u025b\u0260\u0003\u0000\u0000\u0000"+
"\u025c\u025d\u0005D\u0000\u0000\u025d\u025f\u0005E\u0000\u0000\u025e\u025c"+
"\u0001\u0000\u0000\u0000\u025f\u0262\u0001\u0000\u0000\u0000\u0260\u025e"+
"\u0001\u0000\u0000\u0000\u0260\u0261\u0001\u0000\u0000\u0000\u0261O\u0001"+
"\u0000\u0000\u0000\u0262\u0260\u0001\u0000\u0000\u0000\u0263\u0266\u0003"+
"R)\u0000\u0264\u0266\u0003\u00aeW\u0000\u0265\u0263\u0001\u0000\u0000"+
"\u0000\u0265\u0264\u0001\u0000\u0000\u0000\u0266Q\u0001\u0000\u0000\u0000"+
"\u0267\u0273\u0005B\u0000\u0000\u0268\u026d\u0003P(\u0000\u0269\u026a"+
"\u0005G\u0000\u0000\u026a\u026c\u0003P(\u0000\u026b\u0269\u0001\u0000"+
"\u0000\u0000\u026c\u026f\u0001\u0000\u0000\u0000\u026d\u026b\u0001\u0000"+
"\u0000\u0000\u026d\u026e\u0001\u0000\u0000\u0000\u026e\u0271\u0001\u0000"+
"\u0000\u0000\u026f\u026d\u0001\u0000\u0000\u0000\u0270\u0272\u0005G\u0000"+
"\u0000\u0271\u0270\u0001\u0000\u0000\u0000\u0271\u0272\u0001\u0000\u0000"+
"\u0000\u0272\u0274\u0001\u0000\u0000\u0000\u0273\u0268\u0001\u0000\u0000"+
"\u0000\u0273\u0274\u0001\u0000\u0000\u0000\u0274\u0275\u0001\u0000\u0000"+
"\u0000\u0275\u0276\u0005C\u0000\u0000\u0276S\u0001\u0000\u0000\u0000\u0277"+
"\u0279\u0003\u0000\u0000\u0000\u0278\u027a\u0003\u00d2i\u0000\u0279\u0278"+
"\u0001\u0000\u0000\u0000\u0279\u027a\u0001\u0000\u0000\u0000\u027a\u0282"+
"\u0001\u0000\u0000\u0000\u027b\u027c\u0005H\u0000\u0000\u027c\u027e\u0003"+
"\u0000\u0000\u0000\u027d\u027f\u0003\u00d2i\u0000\u027e\u027d\u0001\u0000"+
"\u0000\u0000\u027e\u027f\u0001\u0000\u0000\u0000\u027f\u0281\u0001\u0000"+
"\u0000\u0000\u0280\u027b\u0001\u0000\u0000\u0000\u0281\u0284\u0001\u0000"+
"\u0000\u0000\u0282\u0280\u0001\u0000\u0000\u0000\u0282\u0283\u0001\u0000"+
"\u0000\u0000\u0283U\u0001\u0000\u0000\u0000\u0284\u0282\u0001\u0000\u0000"+
"\u0000\u0285\u028c\u0003\u00ceg\u0000\u0286\u0289\u0005N\u0000\u0000\u0287"+
"\u0288\u0007\u0001\u0000\u0000\u0288\u028a\u0003\u00ceg\u0000\u0289\u0287"+
"\u0001\u0000\u0000\u0000\u0289\u028a\u0001\u0000\u0000\u0000\u028a\u028c"+
"\u0001\u0000\u0000\u0000\u028b\u0285\u0001\u0000\u0000\u0000\u028b\u0286"+
"\u0001\u0000\u0000\u0000\u028cW\u0001\u0000\u0000\u0000\u028d\u0292\u0003"+
"b1\u0000\u028e\u028f\u0005G\u0000\u0000\u028f\u0291\u0003b1\u0000\u0290"+
"\u028e\u0001\u0000\u0000\u0000\u0291\u0294\u0001\u0000\u0000\u0000\u0292"+
"\u0290\u0001\u0000\u0000\u0000\u0292\u0293\u0001\u0000\u0000\u0000\u0293"+
"Y\u0001\u0000\u0000\u0000\u0294\u0292\u0001\u0000\u0000\u0000\u0295\u0297"+
"\u0005@\u0000\u0000\u0296\u0298\u0003\\.\u0000\u0297\u0296\u0001\u0000"+
"\u0000\u0000\u0297\u0298\u0001\u0000\u0000\u0000\u0298\u0299\u0001\u0000"+
"\u0000\u0000\u0299\u029a\u0005A\u0000\u0000\u029a[\u0001\u0000\u0000\u0000"+
"\u029b\u02a0\u0003^/\u0000\u029c\u029d\u0005G\u0000\u0000\u029d\u029f"+
"\u0003^/\u0000\u029e\u029c\u0001\u0000\u0000\u0000\u029f\u02a2\u0001\u0000"+
"\u0000\u0000\u02a0\u029e\u0001\u0000\u0000\u0000\u02a0\u02a1\u0001\u0000"+
"\u0000\u0000\u02a1\u02a5\u0001\u0000\u0000\u0000\u02a2\u02a0\u0001\u0000"+
"\u0000\u0000\u02a3\u02a4\u0005G\u0000\u0000\u02a4\u02a6\u0003`0\u0000"+
"\u02a5\u02a3\u0001\u0000\u0000\u0000\u02a5\u02a6\u0001\u0000\u0000\u0000"+
"\u02a6\u02a9\u0001\u0000\u0000\u0000\u02a7\u02a9\u0003`0\u0000\u02a8\u029b"+
"\u0001\u0000\u0000\u0000\u02a8\u02a7\u0001\u0000\u0000\u0000\u02a9]\u0001"+
"\u0000\u0000\u0000\u02aa\u02ac\u0003\u000e\u0007\u0000\u02ab\u02aa\u0001"+
"\u0000\u0000\u0000\u02ac\u02af\u0001\u0000\u0000\u0000\u02ad\u02ab\u0001"+
"\u0000\u0000\u0000\u02ad\u02ae\u0001\u0000\u0000\u0000\u02ae\u02b0\u0001"+
"\u0000\u0000\u0000\u02af\u02ad\u0001\u0000\u0000\u0000\u02b0\u02b1\u0003"+
"\u00ceg\u0000\u02b1\u02b2\u0003N\'\u0000\u02b2_\u0001\u0000\u0000\u0000"+
"\u02b3\u02b5\u0003\u000e\u0007\u0000\u02b4\u02b3\u0001\u0000\u0000\u0000"+
"\u02b5\u02b8\u0001\u0000\u0000\u0000\u02b6\u02b4\u0001\u0000\u0000\u0000"+
"\u02b6\u02b7\u0001\u0000\u0000\u0000\u02b7\u02b9\u0001\u0000\u0000\u0000"+
"\u02b8\u02b6\u0001\u0000\u0000\u0000\u02b9\u02ba\u0003\u00ceg\u0000\u02ba"+
"\u02bb\u0005n\u0000\u0000\u02bb\u02bc\u0003N\'\u0000\u02bca\u0001\u0000"+
"\u0000\u0000\u02bd\u02c2\u0003\u0000\u0000\u0000\u02be\u02bf\u0005H\u0000"+
"\u0000\u02bf\u02c1\u0003\u0000\u0000\u0000\u02c0\u02be\u0001\u0000\u0000"+
"\u0000\u02c1\u02c4\u0001\u0000\u0000\u0000\u02c2\u02c0\u0001\u0000\u0000"+
"\u0000\u02c2\u02c3\u0001\u0000\u0000\u0000\u02c3c\u0001\u0000\u0000\u0000"+
"\u02c4\u02c2\u0001\u0000\u0000\u0000\u02c5\u02cd\u0003f3\u0000\u02c6\u02cd"+
"\u0003h4\u0000\u02c7\u02cd\u0005<\u0000\u0000\u02c8\u02cd\u0005=\u0000"+
"\u0000\u02c9\u02cd\u0005>\u0000\u0000\u02ca\u02cd\u0005;\u0000\u0000\u02cb"+
"\u02cd\u0005?\u0000\u0000\u02cc\u02c5\u0001\u0000\u0000\u0000\u02cc\u02c6"+
"\u0001\u0000\u0000\u0000\u02cc\u02c7\u0001\u0000\u0000\u0000\u02cc\u02c8"+
"\u0001\u0000\u0000\u0000\u02cc\u02c9\u0001\u0000\u0000\u0000\u02cc\u02ca"+
"\u0001\u0000\u0000\u0000\u02cc\u02cb\u0001\u0000\u0000\u0000\u02cde\u0001"+
"\u0000\u0000\u0000\u02ce\u02cf\u0007\u0002\u0000\u0000\u02cfg\u0001\u0000"+
"\u0000\u0000\u02d0\u02d1\u0007\u0003\u0000\u0000\u02d1i\u0001\u0000\u0000"+
"\u0000\u02d2\u02d3\u0005m\u0000\u0000\u02d3\u02da\u0003b1\u0000\u02d4"+
"\u02d7\u0005@\u0000\u0000\u02d5\u02d8\u0003l6\u0000\u02d6\u02d8\u0003"+
"p8\u0000\u02d7\u02d5\u0001\u0000\u0000\u0000\u02d7\u02d6\u0001\u0000\u0000"+
"\u0000\u02d7\u02d8\u0001\u0000\u0000\u0000\u02d8\u02d9\u0001\u0000\u0000"+
"\u0000\u02d9\u02db\u0005A\u0000\u0000\u02da\u02d4\u0001\u0000\u0000\u0000"+
"\u02da\u02db\u0001\u0000\u0000\u0000\u02dbk\u0001\u0000\u0000\u0000\u02dc"+
"\u02e1\u0003n7\u0000\u02dd\u02de\u0005G\u0000\u0000\u02de\u02e0\u0003"+
"n7\u0000\u02df\u02dd\u0001\u0000\u0000\u0000\u02e0\u02e3\u0001\u0000\u0000"+
"\u0000\u02e1\u02df\u0001\u0000\u0000\u0000\u02e1\u02e2\u0001\u0000\u0000"+
"\u0000\u02e2m\u0001\u0000\u0000\u0000\u02e3\u02e1\u0001\u0000\u0000\u0000"+
"\u02e4\u02e5\u0003\u0000\u0000\u0000\u02e5\u02e6\u0005I\u0000\u0000\u02e6"+
"\u02e7\u0003p8\u0000\u02e7o\u0001\u0000\u0000\u0000\u02e8\u02ec\u0003"+
"\u00aeW\u0000\u02e9\u02ec\u0003j5\u0000\u02ea\u02ec\u0003r9\u0000\u02eb"+
"\u02e8\u0001\u0000\u0000\u0000\u02eb\u02e9\u0001\u0000\u0000\u0000\u02eb"+
"\u02ea\u0001\u0000\u0000\u0000\u02ecq\u0001\u0000\u0000\u0000\u02ed\u02f6"+
"\u0005B\u0000\u0000\u02ee\u02f3\u0003p8\u0000\u02ef\u02f0\u0005G\u0000"+
"\u0000\u02f0\u02f2\u0003p8\u0000\u02f1\u02ef\u0001\u0000\u0000\u0000\u02f2"+
"\u02f5\u0001\u0000\u0000\u0000\u02f3\u02f1\u0001\u0000\u0000\u0000\u02f3"+
"\u02f4\u0001\u0000\u0000\u0000\u02f4\u02f7\u0001\u0000\u0000\u0000\u02f5"+
"\u02f3\u0001\u0000\u0000\u0000\u02f6\u02ee\u0001\u0000\u0000\u0000\u02f6"+
"\u02f7\u0001\u0000\u0000\u0000\u02f7\u02f9\u0001\u0000\u0000\u0000\u02f8"+
"\u02fa\u0005G\u0000\u0000\u02f9\u02f8\u0001\u0000\u0000\u0000\u02f9\u02fa"+
"\u0001\u0000\u0000\u0000\u02fa\u02fb\u0001\u0000\u0000\u0000\u02fb\u02fc"+
"\u0005C\u0000\u0000\u02fcs\u0001\u0000\u0000\u0000\u02fd\u02fe\u0005m"+
"\u0000\u0000\u02fe\u02ff\u0005\u001c\u0000\u0000\u02ff\u0300\u0003\u0000"+
"\u0000\u0000\u0300\u0301\u0003v;\u0000\u0301u\u0001\u0000\u0000\u0000"+
"\u0302\u0306\u0005B\u0000\u0000\u0303\u0305\u0003x<\u0000\u0304\u0303"+
"\u0001\u0000\u0000\u0000\u0305\u0308\u0001\u0000\u0000\u0000\u0306\u0304"+
"\u0001\u0000\u0000\u0000\u0306\u0307\u0001\u0000\u0000\u0000\u0307\u0309"+
"\u0001\u0000\u0000\u0000\u0308\u0306\u0001\u0000\u0000\u0000\u0309\u030a"+
"\u0005C\u0000\u0000\u030aw\u0001\u0000\u0000\u0000\u030b\u030d\u0003\n"+
"\u0005\u0000\u030c\u030b\u0001\u0000\u0000\u0000\u030d\u0310\u0001\u0000"+
"\u0000\u0000\u030e\u030c\u0001\u0000\u0000\u0000\u030e\u030f\u0001\u0000"+
"\u0000\u0000\u030f\u0311\u0001\u0000\u0000\u0000\u0310\u030e\u0001\u0000"+
"\u0000\u0000\u0311\u0314\u0003z=\u0000\u0312\u0314\u0005F\u0000\u0000"+
"\u0313\u030e\u0001\u0000\u0000\u0000\u0313\u0312\u0001\u0000\u0000\u0000"+
"\u0314y\u0001\u0000\u0000\u0000\u0315\u0316\u0003\u00ceg\u0000\u0316\u0317"+
"\u0003|>\u0000\u0317\u0318\u0005F\u0000\u0000\u0318\u032a\u0001\u0000"+
"\u0000\u0000\u0319\u031b\u0003\u0012\t\u0000\u031a\u031c\u0005F\u0000"+
"\u0000\u031b\u031a\u0001\u0000\u0000\u0000\u031b\u031c\u0001\u0000\u0000"+
"\u0000\u031c\u032a\u0001\u0000\u0000\u0000\u031d\u031f\u0003\"\u0011\u0000"+
"\u031e\u0320\u0005F\u0000\u0000\u031f\u031e\u0001\u0000\u0000\u0000\u031f"+
"\u0320\u0001\u0000\u0000\u0000\u0320\u032a\u0001\u0000\u0000\u0000\u0321"+
"\u0323\u0003\u001a\r\u0000\u0322\u0324\u0005F\u0000\u0000\u0323\u0322"+
"\u0001\u0000\u0000\u0000\u0323\u0324\u0001\u0000\u0000\u0000\u0324\u032a"+
"\u0001\u0000\u0000\u0000\u0325\u0327\u0003t:\u0000\u0326\u0328\u0005F"+
"\u0000\u0000\u0327\u0326\u0001\u0000\u0000\u0000\u0327\u0328\u0001\u0000"+
"\u0000\u0000\u0328\u032a\u0001\u0000\u0000\u0000\u0329\u0315\u0001\u0000"+
"\u0000\u0000\u0329\u0319\u0001\u0000\u0000\u0000\u0329\u031d\u0001\u0000"+
"\u0000\u0000\u0329\u0321\u0001\u0000\u0000\u0000\u0329\u0325\u0001\u0000"+
"\u0000\u0000\u032a{\u0001\u0000\u0000\u0000\u032b\u032e\u0003~?\u0000"+
"\u032c\u032e\u0003\u0080@\u0000\u032d\u032b\u0001\u0000\u0000\u0000\u032d"+
"\u032c\u0001\u0000\u0000\u0000\u032e}\u0001\u0000\u0000\u0000\u032f\u0330"+
"\u0003\u0000\u0000\u0000\u0330\u0331\u0005@\u0000\u0000\u0331\u0333\u0005"+
"A\u0000\u0000\u0332\u0334\u0003\u0082A\u0000\u0333\u0332\u0001\u0000\u0000"+
"\u0000\u0333\u0334\u0001\u0000\u0000\u0000\u0334\u007f\u0001\u0000\u0000"+
"\u0000\u0335\u0336\u0003J%\u0000\u0336\u0081\u0001\u0000\u0000\u0000\u0337"+
"\u0338\u0005\f\u0000\u0000\u0338\u0339\u0003p8\u0000\u0339\u0083\u0001"+
"\u0000\u0000\u0000\u033a\u033e\u0005B\u0000\u0000\u033b\u033d\u0003\u0086"+
"C\u0000\u033c\u033b\u0001\u0000\u0000\u0000\u033d\u0340\u0001\u0000\u0000"+
"\u0000\u033e\u033c\u0001\u0000\u0000\u0000\u033e\u033f\u0001\u0000\u0000"+
"\u0000\u033f\u0341\u0001\u0000\u0000\u0000\u0340\u033e\u0001\u0000\u0000"+
"\u0000\u0341\u0342\u0005C\u0000\u0000\u0342\u0085\u0001\u0000\u0000\u0000"+
"\u0343\u0344\u0003\u0088D\u0000\u0344\u0345\u0005F\u0000\u0000\u0345\u0349"+
"\u0001\u0000\u0000\u0000\u0346\u0349\u0003\u008cF\u0000\u0347\u0349\u0003"+
"\u008aE\u0000\u0348\u0343\u0001\u0000\u0000\u0000\u0348\u0346\u0001\u0000"+
"\u0000\u0000\u0348\u0347\u0001\u0000\u0000\u0000\u0349\u0087\u0001\u0000"+
"\u0000\u0000\u034a\u034c\u0003\u000e\u0007\u0000\u034b\u034a\u0001\u0000"+
"\u0000\u0000\u034c\u034f\u0001\u0000\u0000\u0000\u034d\u034b\u0001\u0000"+
"\u0000\u0000\u034d\u034e\u0001\u0000\u0000\u0000\u034e\u0350\u0001\u0000"+
"\u0000\u0000\u034f\u034d\u0001\u0000\u0000\u0000\u0350\u0351\u0003\u00ce"+
"g\u0000\u0351\u0352\u0003J%\u0000\u0352\u0089\u0001\u0000\u0000\u0000"+
"\u0353\u0355\u0003\f\u0006\u0000\u0354\u0353\u0001\u0000\u0000\u0000\u0355"+
"\u0358\u0001\u0000\u0000\u0000\u0356\u0354\u0001\u0000\u0000\u0000\u0356"+
"\u0357\u0001\u0000\u0000\u0000\u0357\u035c\u0001\u0000\u0000\u0000\u0358"+
"\u0356\u0001\u0000\u0000\u0000\u0359\u035d\u0003\u0012\t\u0000\u035a\u035d"+
"\u0003\"\u0011\u0000\u035b\u035d\u0003\u0010\b\u0000\u035c\u0359\u0001"+
"\u0000\u0000\u0000\u035c\u035a\u0001\u0000\u0000\u0000\u035c\u035b\u0001"+
"\u0000\u0000\u0000\u035d\u0360\u0001\u0000\u0000\u0000\u035e\u0360\u0005"+
"F\u0000\u0000\u035f\u0356\u0001\u0000\u0000\u0000\u035f\u035e\u0001\u0000"+
"\u0000\u0000\u0360\u008b\u0001\u0000\u0000\u0000\u0361\u03e0\u0003\u0084"+
"B\u0000\u0362\u0363\u0005\u0002\u0000\u0000\u0363\u0366\u0003\u00aeW\u0000"+
"\u0364\u0365\u0005O\u0000\u0000\u0365\u0367\u0003\u00aeW\u0000\u0366\u0364"+
"\u0001\u0000\u0000\u0000\u0366\u0367\u0001\u0000\u0000\u0000\u0367\u0368"+
"\u0001\u0000\u0000\u0000\u0368\u0369\u0005F\u0000\u0000\u0369\u03e0\u0001"+
"\u0000\u0000\u0000\u036a\u036b\u0005\u0016\u0000\u0000\u036b\u036c\u0003"+
"\u00a8T\u0000\u036c\u036f\u0003\u008cF\u0000\u036d\u036e\u0005\u000f\u0000"+
"\u0000\u036e\u0370\u0003\u008cF\u0000\u036f\u036d\u0001\u0000\u0000\u0000"+
"\u036f\u0370\u0001\u0000\u0000\u0000\u0370\u03e0\u0001\u0000\u0000\u0000"+
"\u0371\u0372\u0005\u0015\u0000\u0000\u0372\u0373\u0005@\u0000\u0000\u0373"+
"\u0374\u0003\u00a2Q\u0000\u0374\u0375\u0005A\u0000\u0000\u0375\u0376\u0003"+
"\u008cF\u0000\u0376\u03e0\u0001\u0000\u0000\u0000\u0377\u0378\u00054\u0000"+
"\u0000\u0378\u0379\u0003\u00a8T\u0000\u0379\u037a\u0003\u008cF\u0000\u037a"+
"\u03e0\u0001\u0000\u0000\u0000\u037b\u037c\u0005\r\u0000\u0000\u037c\u037d"+
"\u0003\u008cF\u0000\u037d\u037e\u00054\u0000\u0000\u037e\u037f\u0003\u00a8"+
"T\u0000\u037f\u0380\u0005F\u0000\u0000\u0380\u03e0\u0001\u0000\u0000\u0000"+
"\u0381\u0382\u00050\u0000\u0000\u0382\u038c\u0003\u0084B\u0000\u0383\u0385"+
"\u0003\u008eG\u0000\u0384\u0383\u0001\u0000\u0000\u0000\u0385\u0386\u0001"+
"\u0000\u0000\u0000\u0386\u0384\u0001\u0000\u0000\u0000\u0386\u0387\u0001"+
"\u0000\u0000\u0000\u0387\u0389\u0001\u0000\u0000\u0000\u0388\u038a\u0003"+
"\u0092I\u0000\u0389\u0388\u0001\u0000\u0000\u0000\u0389\u038a\u0001\u0000"+
"\u0000\u0000\u038a\u038d\u0001\u0000\u0000\u0000\u038b\u038d\u0003\u0092"+
"I\u0000\u038c\u0384\u0001\u0000\u0000\u0000\u038c\u038b\u0001\u0000\u0000"+
"\u0000\u038d\u03e0\u0001\u0000\u0000\u0000\u038e\u038f\u00050\u0000\u0000"+
"\u038f\u0390\u0003\u0094J\u0000\u0390\u0394\u0003\u0084B\u0000\u0391\u0393"+
"\u0003\u008eG\u0000\u0392\u0391\u0001\u0000\u0000\u0000\u0393\u0396\u0001"+
"\u0000\u0000\u0000\u0394\u0392\u0001\u0000\u0000\u0000\u0394\u0395\u0001"+
"\u0000\u0000\u0000\u0395\u0398\u0001\u0000\u0000\u0000\u0396\u0394\u0001"+
"\u0000\u0000\u0000\u0397\u0399\u0003\u0092I\u0000\u0398\u0397\u0001\u0000"+
"\u0000\u0000\u0398\u0399\u0001\u0000\u0000\u0000\u0399\u03e0\u0001\u0000"+
"\u0000\u0000\u039a\u039b\u0005*\u0000\u0000\u039b\u039c\u0003\u00a8T\u0000"+
"\u039c\u03a0\u0005B\u0000\u0000\u039d\u039f\u0003\u009aM\u0000\u039e\u039d"+
"\u0001\u0000\u0000\u0000\u039f\u03a2\u0001\u0000\u0000\u0000\u03a0\u039e"+
"\u0001\u0000\u0000\u0000\u03a0\u03a1\u0001\u0000\u0000\u0000\u03a1\u03a6"+
"\u0001\u0000\u0000\u0000\u03a2\u03a0\u0001\u0000\u0000\u0000\u03a3\u03a5"+
"\u0003\u009cN\u0000\u03a4\u03a3\u0001\u0000\u0000\u0000\u03a5\u03a8\u0001"+
"\u0000\u0000\u0000\u03a6\u03a4\u0001\u0000\u0000\u0000\u03a6\u03a7\u0001"+
"\u0000\u0000\u0000\u03a7\u03a9\u0001\u0000\u0000\u0000\u03a8\u03a6\u0001"+
"\u0000\u0000\u0000\u03a9\u03aa\u0005C\u0000\u0000\u03aa\u03e0\u0001\u0000"+
"\u0000\u0000\u03ab\u03ac\u0005*\u0000\u0000\u03ac\u03ad\u0003\u00a8T\u0000"+
"\u03ad\u03b1\u0005B\u0000\u0000\u03ae\u03b0\u0003\u009eO\u0000\u03af\u03ae"+
"\u0001\u0000\u0000\u0000\u03b0\u03b3\u0001\u0000\u0000\u0000\u03b1\u03af"+
"\u0001\u0000\u0000\u0000\u03b1\u03b2\u0001\u0000\u0000\u0000\u03b2\u03b7"+
"\u0001\u0000\u0000\u0000\u03b3\u03b1\u0001\u0000\u0000\u0000\u03b4\u03b6"+
"\u0003\u009cN\u0000\u03b5\u03b4\u0001\u0000\u0000\u0000\u03b6\u03b9\u0001"+
"\u0000\u0000\u0000\u03b7\u03b5\u0001\u0000\u0000\u0000\u03b7\u03b8\u0001"+
"\u0000\u0000\u0000\u03b8\u03ba\u0001\u0000\u0000\u0000\u03b9\u03b7\u0001"+
"\u0000\u0000\u0000\u03ba\u03bb\u0005C\u0000\u0000\u03bb\u03e0\u0001\u0000"+
"\u0000\u0000\u03bc\u03bd\u0005+\u0000\u0000\u03bd\u03be\u0003\u00a8T\u0000"+
"\u03be\u03bf\u0003\u0084B\u0000\u03bf\u03e0\u0001\u0000\u0000\u0000\u03c0"+
"\u03c2\u0005%\u0000\u0000\u03c1\u03c3\u0003\u00aeW\u0000\u03c2\u03c1\u0001"+
"\u0000\u0000\u0000\u03c2\u03c3\u0001\u0000\u0000\u0000\u03c3\u03c4\u0001"+
"\u0000\u0000\u0000\u03c4\u03e0\u0005F\u0000\u0000\u03c5\u03c6\u00053\u0000"+
"\u0000\u03c6\u03c7\u0003\u00aeW\u0000\u03c7\u03c8\u0005F\u0000\u0000\u03c8"+
"\u03e0\u0001\u0000\u0000\u0000\u03c9\u03ca\u0005-\u0000\u0000\u03ca\u03cb"+
"\u0003\u00aeW\u0000\u03cb\u03cc\u0005F\u0000\u0000\u03cc\u03e0\u0001\u0000"+
"\u0000\u0000\u03cd\u03cf\u0005\u0004\u0000\u0000\u03ce\u03d0\u0003\u0000"+
"\u0000\u0000\u03cf\u03ce\u0001\u0000\u0000\u0000\u03cf\u03d0\u0001\u0000"+
"\u0000\u0000\u03d0\u03d1\u0001\u0000\u0000\u0000\u03d1\u03e0\u0005F\u0000"+
"\u0000\u03d2\u03d4\u0005\u000b\u0000\u0000\u03d3\u03d5\u0003\u0000\u0000"+
"\u0000\u03d4\u03d3\u0001\u0000\u0000\u0000\u03d4\u03d5\u0001\u0000\u0000"+
"\u0000\u03d5\u03d6\u0001\u0000\u0000\u0000\u03d6\u03e0\u0005F\u0000\u0000"+
"\u03d7\u03e0\u0005F\u0000\u0000\u03d8\u03d9\u0003\u00aeW\u0000\u03d9\u03da"+
"\u0005F\u0000\u0000\u03da\u03e0\u0001\u0000\u0000\u0000\u03db\u03dc\u0003"+
"\u0000\u0000\u0000\u03dc\u03dd\u0005O\u0000\u0000\u03dd\u03de\u0003\u008c"+
"F\u0000\u03de\u03e0\u0001\u0000\u0000\u0000\u03df\u0361\u0001\u0000\u0000"+
"\u0000\u03df\u0362\u0001\u0000\u0000\u0000\u03df\u036a\u0001\u0000\u0000"+
"\u0000\u03df\u0371\u0001\u0000\u0000\u0000\u03df\u0377\u0001\u0000\u0000"+
"\u0000\u03df\u037b\u0001\u0000\u0000\u0000\u03df\u0381\u0001\u0000\u0000"+
"\u0000\u03df\u038e\u0001\u0000\u0000\u0000\u03df\u039a\u0001\u0000\u0000"+
"\u0000\u03df\u03ab\u0001\u0000\u0000\u0000\u03df\u03bc\u0001\u0000\u0000"+
"\u0000\u03df\u03c0\u0001\u0000\u0000\u0000\u03df\u03c5\u0001\u0000\u0000"+
"\u0000\u03df\u03c9\u0001\u0000\u0000\u0000\u03df\u03cd\u0001\u0000\u0000"+
"\u0000\u03df\u03d2\u0001\u0000\u0000\u0000\u03df\u03d7\u0001\u0000\u0000"+
"\u0000\u03df\u03d8\u0001\u0000\u0000\u0000\u03df\u03db\u0001\u0000\u0000"+
"\u0000\u03e0\u008d\u0001\u0000\u0000\u0000\u03e1\u03e2\u0005\u0007\u0000"+
"\u0000\u03e2\u03e6\u0005@\u0000\u0000\u03e3\u03e5\u0003\u000e\u0007\u0000"+
"\u03e4\u03e3\u0001\u0000\u0000\u0000\u03e5\u03e8\u0001\u0000\u0000\u0000"+
"\u03e6\u03e4\u0001\u0000\u0000\u0000\u03e6\u03e7\u0001\u0000\u0000\u0000"+
"\u03e7\u03e9\u0001\u0000\u0000\u0000\u03e8\u03e6\u0001\u0000\u0000\u0000"+
"\u03e9\u03ea\u0003\u0090H\u0000\u03ea\u03eb\u0003\u0000\u0000\u0000\u03eb"+
"\u03ec\u0005A\u0000\u0000\u03ec\u03ed\u0003\u0084B\u0000\u03ed\u008f\u0001"+
"\u0000\u0000\u0000\u03ee\u03f3\u0003b1\u0000\u03ef\u03f0\u0005]\u0000"+
"\u0000\u03f0\u03f2\u0003b1\u0000\u03f1\u03ef\u0001\u0000\u0000\u0000\u03f2"+
"\u03f5\u0001\u0000\u0000\u0000\u03f3\u03f1\u0001\u0000\u0000\u0000\u03f3"+
"\u03f4\u0001\u0000\u0000\u0000\u03f4\u0091\u0001\u0000\u0000\u0000\u03f5"+
"\u03f3\u0001\u0000\u0000\u0000\u03f6\u03f7\u0005\u0013\u0000\u0000\u03f7"+
"\u03f8\u0003\u0084B\u0000\u03f8\u0093\u0001\u0000\u0000\u0000\u03f9\u03fa"+
"\u0005@\u0000\u0000\u03fa\u03fc\u0003\u0096K\u0000\u03fb\u03fd\u0005F"+
"\u0000\u0000\u03fc\u03fb\u0001\u0000\u0000\u0000\u03fc\u03fd\u0001\u0000"+
"\u0000\u0000\u03fd\u03fe\u0001\u0000\u0000\u0000\u03fe\u03ff\u0005A\u0000"+
"\u0000\u03ff\u0095\u0001\u0000\u0000\u0000\u0400\u0405\u0003\u0098L\u0000"+
"\u0401\u0402\u0005F\u0000\u0000\u0402\u0404\u0003\u0098L\u0000\u0403\u0401"+
"\u0001\u0000\u0000\u0000\u0404\u0407\u0001\u0000\u0000\u0000\u0405\u0403"+
"\u0001\u0000\u0000\u0000\u0405\u0406\u0001\u0000\u0000\u0000\u0406\u0097"+
"\u0001\u0000\u0000\u0000\u0407\u0405\u0001\u0000\u0000\u0000\u0408\u040a"+
"\u0003\u000e\u0007\u0000\u0409\u0408\u0001\u0000\u0000\u0000\u040a\u040d"+
"\u0001\u0000\u0000\u0000\u040b\u0409\u0001\u0000\u0000\u0000\u040b\u040c"+
"\u0001\u0000\u0000\u0000\u040c\u040e\u0001\u0000\u0000\u0000\u040d\u040b"+
"\u0001\u0000\u0000\u0000\u040e\u040f\u0003T*\u0000\u040f\u0410\u0003N"+
"\'\u0000\u0410\u0411\u0005I\u0000\u0000\u0411\u0412\u0003\u00aeW\u0000"+
"\u0412\u0099\u0001\u0000\u0000\u0000\u0413\u0415\u0003\u009cN\u0000\u0414"+
"\u0413\u0001\u0000\u0000\u0000\u0415\u0416\u0001\u0000\u0000\u0000\u0416"+
"\u0414\u0001\u0000\u0000\u0000\u0416\u0417\u0001\u0000\u0000\u0000\u0417"+
"\u0419\u0001\u0000\u0000\u0000\u0418\u041a\u0003\u0086C\u0000\u0419\u0418"+
"\u0001\u0000\u0000\u0000\u041a\u041b\u0001\u0000\u0000\u0000\u041b\u0419"+
"\u0001\u0000\u0000\u0000\u041b\u041c\u0001\u0000\u0000\u0000\u041c\u009b"+
"\u0001\u0000\u0000\u0000\u041d\u0420\u0005\u0006\u0000\u0000\u041e\u0421"+
"\u0003\u00aeW\u0000\u041f\u0421\u0003\u0000\u0000\u0000\u0420\u041e\u0001"+
"\u0000\u0000\u0000\u0420\u041f\u0001\u0000\u0000\u0000\u0421\u0422\u0001"+
"\u0000\u0000\u0000\u0422\u0423\u0005O\u0000\u0000\u0423\u0427\u0001\u0000"+
"\u0000\u0000\u0424\u0425\u0005\f\u0000\u0000\u0425\u0427\u0005O\u0000"+
"\u0000\u0426\u041d\u0001\u0000\u0000\u0000\u0426\u0424\u0001\u0000\u0000"+
"\u0000\u0427\u009d\u0001\u0000\u0000\u0000\u0428\u042a\u0003\u00a0P\u0000"+
"\u0429\u0428\u0001\u0000\u0000\u0000\u042a\u042b\u0001\u0000\u0000\u0000"+
"\u042b\u0429\u0001\u0000\u0000\u0000\u042b\u042c\u0001\u0000\u0000\u0000"+
"\u042c\u042e\u0001\u0000\u0000\u0000\u042d\u042f\u0003\u0086C\u0000\u042e"+
"\u042d\u0001\u0000\u0000\u0000\u042f\u0430\u0001\u0000\u0000\u0000\u0430"+
"\u042e\u0001\u0000\u0000\u0000\u0430\u0431\u0001\u0000\u0000\u0000\u0431"+
"\u009f\u0001\u0000\u0000\u0000\u0432\u043c\u0005\u0006\u0000\u0000\u0433"+
"\u0438\u0003\u00aeW\u0000\u0434\u0435\u0005G\u0000\u0000\u0435\u0437\u0003"+
"\u00aeW\u0000\u0436\u0434\u0001\u0000\u0000\u0000\u0437\u043a\u0001\u0000"+
"\u0000\u0000\u0438\u0436\u0001\u0000\u0000\u0000\u0438\u0439\u0001\u0000"+
"\u0000\u0000\u0439\u043d\u0001\u0000\u0000\u0000\u043a\u0438\u0001\u0000"+
"\u0000\u0000\u043b\u043d\u0003\u0000\u0000\u0000\u043c\u0433\u0001\u0000"+
"\u0000\u0000\u043c\u043b\u0001\u0000\u0000\u0000\u043d\u043e\u0001\u0000"+
"\u0000\u0000\u043e\u043f\u0007\u0004\u0000\u0000\u043f\u0443\u0001\u0000"+
"\u0000\u0000\u0440\u0441\u0005\f\u0000\u0000\u0441\u0443\u0007\u0004\u0000"+
"\u0000\u0442\u0432\u0001\u0000\u0000\u0000\u0442\u0440\u0001\u0000\u0000"+
"\u0000\u0443\u00a1\u0001\u0000\u0000\u0000\u0444\u0451\u0003\u00a6S\u0000"+
"\u0445\u0447\u0003\u00a4R\u0000\u0446\u0445\u0001\u0000\u0000\u0000\u0446"+
"\u0447\u0001\u0000\u0000\u0000\u0447\u0448\u0001\u0000\u0000\u0000\u0448"+
"\u044a\u0005F\u0000\u0000\u0449\u044b\u0003\u00aeW\u0000\u044a\u0449\u0001"+
"\u0000\u0000\u0000\u044a\u044b\u0001\u0000\u0000\u0000\u044b\u044c\u0001"+
"\u0000\u0000\u0000\u044c\u044e\u0005F\u0000\u0000\u044d\u044f\u0003\u00aa"+
"U\u0000\u044e\u044d\u0001\u0000\u0000\u0000\u044e\u044f\u0001\u0000\u0000"+
"\u0000\u044f\u0451\u0001\u0000\u0000\u0000\u0450\u0444\u0001\u0000\u0000"+
"\u0000\u0450\u0446\u0001\u0000\u0000\u0000\u0451\u00a3\u0001\u0000\u0000"+
"\u0000\u0452\u0455\u0003\u0088D\u0000\u0453\u0455\u0003\u00aaU\u0000\u0454"+
"\u0452\u0001\u0000\u0000\u0000\u0454\u0453\u0001\u0000\u0000\u0000\u0455"+
"\u00a5\u0001\u0000\u0000\u0000\u0456\u0458\u0003\u000e\u0007\u0000\u0457"+
"\u0456\u0001\u0000\u0000\u0000\u0458\u045b\u0001\u0000\u0000\u0000\u0459"+
"\u0457\u0001\u0000\u0000\u0000\u0459\u045a\u0001\u0000\u0000\u0000\u045a"+
"\u045c\u0001\u0000\u0000\u0000\u045b\u0459\u0001\u0000\u0000\u0000\u045c"+
"\u045d\u0003\u00ceg\u0000\u045d\u045e\u0003N\'\u0000\u045e\u045f\u0005"+
"O\u0000\u0000\u045f\u0460\u0003\u00aeW\u0000\u0460\u00a7\u0001\u0000\u0000"+
"\u0000\u0461\u0462\u0005@\u0000\u0000\u0462\u0463\u0003\u00aeW\u0000\u0463"+
"\u0464\u0005A\u0000\u0000\u0464\u00a9\u0001\u0000\u0000\u0000\u0465\u046a"+
"\u0003\u00aeW\u0000\u0466\u0467\u0005G\u0000\u0000\u0467\u0469\u0003\u00ae"+
"W\u0000\u0468\u0466\u0001\u0000\u0000\u0000\u0469\u046c\u0001\u0000\u0000"+
"\u0000\u046a\u0468\u0001\u0000\u0000\u0000\u046a\u046b\u0001\u0000\u0000"+
"\u0000\u046b\u00ab\u0001\u0000\u0000\u0000\u046c\u046a\u0001\u0000\u0000"+
"\u0000\u046d\u046e\u0003\u0000\u0000\u0000\u046e\u0470\u0005@\u0000\u0000"+
"\u046f\u0471\u0003\u00aaU\u0000\u0470\u046f\u0001\u0000\u0000\u0000\u0470"+
"\u0471\u0001\u0000\u0000\u0000\u0471\u0472\u0001\u0000\u0000\u0000\u0472"+
"\u0473\u0005A\u0000\u0000\u0473\u0481\u0001\u0000\u0000\u0000\u0474\u0475"+
"\u0005,\u0000\u0000\u0475\u0477\u0005@\u0000\u0000\u0476\u0478\u0003\u00aa"+
"U\u0000\u0477\u0476\u0001\u0000\u0000\u0000\u0477\u0478\u0001\u0000\u0000"+
"\u0000\u0478\u0479\u0001\u0000\u0000\u0000\u0479\u0481\u0005A\u0000\u0000"+
"\u047a\u047b\u0005)\u0000\u0000\u047b\u047d\u0005@\u0000\u0000\u047c\u047e"+
"\u0003\u00aaU\u0000\u047d\u047c\u0001\u0000\u0000\u0000\u047d\u047e\u0001"+
"\u0000\u0000\u0000\u047e\u047f\u0001\u0000\u0000\u0000\u047f\u0481\u0005"+
"A\u0000\u0000\u0480\u046d\u0001\u0000\u0000\u0000\u0480\u0474\u0001\u0000"+
"\u0000\u0000\u0480\u047a\u0001\u0000\u0000\u0000\u0481\u00ad\u0001\u0000"+
"\u0000\u0000\u0482\u0483\u0006W\uffff\uffff\u0000\u0483\u04b3\u0003\u00b6"+
"[\u0000\u0484\u04b3\u0003\u00acV\u0000\u0485\u0486\u0005\u001f\u0000\u0000"+
"\u0486\u04b3\u0003\u00ba]\u0000\u0487\u0488\u0005@\u0000\u0000\u0488\u0489"+
"\u0003\u00ceg\u0000\u0489\u048a\u0005A\u0000\u0000\u048a\u048b\u0003\u00ae"+
"W\u0016\u048b\u04b3\u0001\u0000\u0000\u0000\u048c\u048d\u0007\u0005\u0000"+
"\u0000\u048d\u04b3\u0003\u00aeW\u0014\u048e\u048f\u0007\u0006\u0000\u0000"+
"\u048f\u04b3\u0003\u00aeW\u0013\u0490\u04b3\u0003\u00b0X\u0000\u0491\u0492"+
"\u0003\u00ceg\u0000\u0492\u0498\u0005l\u0000\u0000\u0493\u0495\u0003\u00d2"+
"i\u0000\u0494\u0493\u0001\u0000\u0000\u0000\u0494\u0495\u0001\u0000\u0000"+
"\u0000\u0495\u0496\u0001\u0000\u0000\u0000\u0496\u0499\u0003\u0000\u0000"+
"\u0000\u0497\u0499\u0005\u001f\u0000\u0000\u0498\u0494\u0001\u0000\u0000"+
"\u0000\u0498\u0497\u0001\u0000\u0000\u0000\u0499\u04b3\u0001\u0000\u0000"+
"\u0000\u049a\u049b\u0003\u00b8\\\u0000\u049b\u049d\u0005l\u0000\u0000"+
"\u049c\u049e\u0003\u00d2i\u0000\u049d\u049c\u0001\u0000\u0000\u0000\u049d"+
"\u049e\u0001\u0000\u0000\u0000\u049e\u049f\u0001\u0000\u0000\u0000\u049f"+
"\u04a0\u0005\u001f\u0000\u0000\u04a0\u04b3\u0001\u0000\u0000\u0000\u04a1"+
"\u04a2\u0005*\u0000\u0000\u04a2\u04a3\u0003\u00a8T\u0000\u04a3\u04a7\u0005"+
"B\u0000\u0000\u04a4\u04a6\u0003\u009eO\u0000\u04a5\u04a4\u0001\u0000\u0000"+
"\u0000\u04a6\u04a9\u0001\u0000\u0000\u0000\u04a7\u04a5\u0001\u0000\u0000"+
"\u0000\u04a7\u04a8\u0001\u0000\u0000\u0000\u04a8\u04ad\u0001\u0000\u0000"+
"\u0000\u04a9\u04a7\u0001\u0000\u0000\u0000\u04aa\u04ac\u0003\u009cN\u0000"+
"\u04ab\u04aa\u0001\u0000\u0000\u0000\u04ac\u04af\u0001\u0000\u0000\u0000"+
"\u04ad\u04ab\u0001\u0000\u0000\u0000\u04ad\u04ae\u0001\u0000\u0000\u0000"+
"\u04ae\u04b0\u0001\u0000\u0000\u0000\u04af\u04ad\u0001\u0000\u0000\u0000"+
"\u04b0\u04b1\u0005C\u0000\u0000\u04b1\u04b3\u0001\u0000\u0000\u0000\u04b2"+
"\u0482\u0001\u0000\u0000\u0000\u04b2\u0484\u0001\u0000\u0000\u0000\u04b2"+
"\u0485\u0001\u0000\u0000\u0000\u04b2\u0487\u0001\u0000\u0000\u0000\u04b2"+
"\u048c\u0001\u0000\u0000\u0000\u04b2\u048e\u0001\u0000\u0000\u0000\u04b2"+
"\u0490\u0001\u0000\u0000\u0000\u04b2\u0491\u0001\u0000\u0000\u0000\u04b2"+
"\u049a\u0001\u0000\u0000\u0000\u04b2\u04a1\u0001\u0000\u0000\u0000\u04b3"+
"\u0507\u0001\u0000\u0000\u0000\u04b4\u04b5\n\u0012\u0000\u0000\u04b5\u04b6"+
"\u0007\u0007\u0000\u0000\u04b6\u0506\u0003\u00aeW\u0013\u04b7\u04b8\n"+
"\u0011\u0000\u0000\u04b8\u04b9\u0007\b\u0000\u0000\u04b9\u0506\u0003\u00ae"+
"W\u0012\u04ba\u04c2\n\u0010\u0000\u0000\u04bb\u04bc\u0005K\u0000\u0000"+
"\u04bc\u04c3\u0005K\u0000\u0000\u04bd\u04be\u0005J\u0000\u0000\u04be\u04bf"+
"\u0005J\u0000\u0000\u04bf\u04c3\u0005J\u0000\u0000\u04c0\u04c1\u0005J"+
"\u0000\u0000\u04c1\u04c3\u0005J\u0000\u0000\u04c2\u04bb\u0001\u0000\u0000"+
"\u0000\u04c2\u04bd\u0001\u0000\u0000\u0000\u04c2\u04c0\u0001\u0000\u0000"+
"\u0000\u04c3\u04c4\u0001\u0000\u0000\u0000\u04c4\u0506\u0003\u00aeW\u0011"+
"\u04c5\u04c6\n\u000f\u0000\u0000\u04c6\u04c7\u0007\t\u0000\u0000\u04c7"+
"\u0506\u0003\u00aeW\u0010\u04c8\u04c9\n\r\u0000\u0000\u04c9\u04ca\u0007"+
"\n\u0000\u0000\u04ca\u0506\u0003\u00aeW\u000e\u04cb\u04cc\n\f\u0000\u0000"+
"\u04cc\u04cd\u0005\\\u0000\u0000\u04cd\u0506\u0003\u00aeW\r\u04ce\u04cf"+
"\n\u000b\u0000\u0000\u04cf\u04d0\u0005^\u0000\u0000\u04d0\u0506\u0003"+
"\u00aeW\f\u04d1\u04d2\n\n\u0000\u0000\u04d2\u04d3\u0005]\u0000\u0000\u04d3"+
"\u0506\u0003\u00aeW\u000b\u04d4\u04d5\n\t\u0000\u0000\u04d5\u04d6\u0005"+
"T\u0000\u0000\u04d6\u0506\u0003\u00aeW\n\u04d7\u04d8\n\b\u0000\u0000\u04d8"+
"\u04d9\u0005U\u0000\u0000\u04d9\u0506\u0003\u00aeW\t\u04da\u04db\n\u0007"+
"\u0000\u0000\u04db\u04dc\u0005N\u0000\u0000\u04dc\u04dd\u0003\u00aeW\u0000"+
"\u04dd\u04de\u0005O\u0000\u0000\u04de\u04df\u0003\u00aeW\b\u04df\u0506"+
"\u0001\u0000\u0000\u0000\u04e0\u04e1\n\u0006\u0000\u0000\u04e1\u04e2\u0007"+
"\u000b\u0000\u0000\u04e2\u0506\u0003\u00aeW\u0006\u04e3\u04e4\n\u001a"+
"\u0000\u0000\u04e4\u04f0\u0005H\u0000\u0000\u04e5\u04f1\u0003\u0000\u0000"+
"\u0000\u04e6\u04f1\u0003\u00acV\u0000\u04e7\u04f1\u0005,\u0000\u0000\u04e8"+
"\u04ea\u0005\u001f\u0000\u0000\u04e9\u04eb\u0003\u00cae\u0000\u04ea\u04e9"+
"\u0001\u0000\u0000\u0000\u04ea\u04eb\u0001\u0000\u0000\u0000\u04eb\u04ec"+
"\u0001\u0000\u0000\u0000\u04ec\u04f1\u0003\u00be_\u0000\u04ed\u04ee\u0005"+
")\u0000\u0000\u04ee\u04f1\u0003\u00d4j\u0000\u04ef\u04f1\u0003\u00c4b"+
"\u0000\u04f0\u04e5\u0001\u0000\u0000\u0000\u04f0\u04e6\u0001\u0000\u0000"+
"\u0000\u04f0\u04e7\u0001\u0000\u0000\u0000\u04f0\u04e8\u0001\u0000\u0000"+
"\u0000\u04f0\u04ed\u0001\u0000\u0000\u0000\u04f0\u04ef\u0001\u0000\u0000"+
"\u0000\u04f1\u0506\u0001\u0000\u0000\u0000\u04f2\u04f3\n\u0019\u0000\u0000"+
"\u04f3\u04f4\u0005D\u0000\u0000\u04f4\u04f5\u0003\u00aeW\u0000\u04f5\u04f6"+
"\u0005E\u0000\u0000\u04f6\u0506\u0001\u0000\u0000\u0000\u04f7\u04f8\n"+
"\u0015\u0000\u0000\u04f8\u0506\u0007\f\u0000\u0000\u04f9\u04fa\n\u000e"+
"\u0000\u0000\u04fa\u04fb\u0005\u001a\u0000\u0000\u04fb\u04fd\u0003\u00ce"+
"g\u0000\u04fc\u04fe\u0003\u0000\u0000\u0000\u04fd\u04fc\u0001\u0000\u0000"+
"\u0000\u04fd\u04fe\u0001\u0000\u0000\u0000\u04fe\u0506\u0001\u0000\u0000"+
"\u0000\u04ff\u0500\n\u0004\u0000\u0000\u0500\u0502\u0005l\u0000\u0000"+
"\u0501\u0503\u0003\u00d2i\u0000\u0502\u0501\u0001\u0000\u0000\u0000\u0502"+
"\u0503\u0001\u0000\u0000\u0000\u0503\u0504\u0001\u0000\u0000\u0000\u0504"+
"\u0506\u0003\u0000\u0000\u0000\u0505\u04b4\u0001\u0000\u0000\u0000\u0505"+
"\u04b7\u0001\u0000\u0000\u0000\u0505\u04ba\u0001\u0000\u0000\u0000\u0505"+
"\u04c5\u0001\u0000\u0000\u0000\u0505\u04c8\u0001\u0000\u0000\u0000\u0505"+
"\u04cb\u0001\u0000\u0000\u0000\u0505\u04ce\u0001\u0000\u0000\u0000\u0505"+
"\u04d1\u0001\u0000\u0000\u0000\u0505\u04d4\u0001\u0000\u0000\u0000\u0505"+
"\u04d7\u0001\u0000\u0000\u0000\u0505\u04da\u0001\u0000\u0000\u0000\u0505"+
"\u04e0\u0001\u0000\u0000\u0000\u0505\u04e3\u0001\u0000\u0000\u0000\u0505"+
"\u04f2\u0001\u0000\u0000\u0000\u0505\u04f7\u0001\u0000\u0000\u0000\u0505"+
"\u04f9\u0001\u0000\u0000\u0000\u0505\u04ff\u0001\u0000\u0000\u0000\u0506"+
"\u0509\u0001\u0000\u0000\u0000\u0507\u0505\u0001\u0000\u0000\u0000\u0507"+
"\u0508\u0001\u0000\u0000\u0000\u0508\u00af\u0001\u0000\u0000\u0000\u0509"+
"\u0507\u0001\u0000\u0000\u0000\u050a\u050b\u0003\u00b2Y\u0000\u050b\u050c"+
"\u0005k\u0000\u0000\u050c\u050d\u0003\u00b4Z\u0000\u050d\u00b1\u0001\u0000"+
"\u0000\u0000\u050e\u0520\u0003\u0000\u0000\u0000\u050f\u0511\u0005@\u0000"+
"\u0000\u0510\u0512\u0003\\.\u0000\u0511\u0510\u0001\u0000\u0000\u0000"+
"\u0511\u0512\u0001\u0000\u0000\u0000\u0512\u0513\u0001\u0000\u0000\u0000"+
"\u0513\u0520\u0005A\u0000\u0000\u0514\u0515\u0005@\u0000\u0000\u0515\u051a"+
"\u0003\u0000\u0000\u0000\u0516\u0517\u0005G\u0000\u0000\u0517\u0519\u0003"+
"\u0000\u0000\u0000\u0518\u0516\u0001\u0000\u0000\u0000\u0519\u051c\u0001"+
"\u0000\u0000\u0000\u051a\u0518\u0001\u0000\u0000\u0000\u051a\u051b\u0001"+
"\u0000\u0000\u0000\u051b\u051d\u0001\u0000\u0000\u0000\u051c\u051a\u0001"+
"\u0000\u0000\u0000\u051d\u051e\u0005A\u0000\u0000\u051e\u0520\u0001\u0000"+
"\u0000\u0000\u051f\u050e\u0001\u0000\u0000\u0000\u051f\u050f\u0001\u0000"+
"\u0000\u0000\u051f\u0514\u0001\u0000\u0000\u0000\u0520\u00b3\u0001\u0000"+
"\u0000\u0000\u0521\u0524\u0003\u00aeW\u0000\u0522\u0524\u0003\u0084B\u0000"+
"\u0523\u0521\u0001\u0000\u0000\u0000\u0523\u0522\u0001\u0000\u0000\u0000"+
"\u0524\u00b5\u0001\u0000\u0000\u0000\u0525\u0526\u0005@\u0000\u0000\u0526"+
"\u0527\u0003\u00aeW\u0000\u0527\u0528\u0005A\u0000\u0000\u0528\u0538\u0001"+
"\u0000\u0000\u0000\u0529\u0538\u0005,\u0000\u0000\u052a\u0538\u0005)\u0000"+
"\u0000\u052b\u0538\u0003d2\u0000\u052c\u0538\u0003\u0000\u0000\u0000\u052d"+
"\u052e\u00030\u0018\u0000\u052e\u052f\u0005H\u0000\u0000\u052f\u0530\u0005"+
"\t\u0000\u0000\u0530\u0538\u0001\u0000\u0000\u0000\u0531\u0535\u0003\u00ca"+
"e\u0000\u0532\u0536\u0003\u00d6k\u0000\u0533\u0534\u0005,\u0000\u0000"+
"\u0534\u0536\u0003\u00d8l\u0000\u0535\u0532\u0001\u0000\u0000\u0000\u0535"+
"\u0533\u0001\u0000\u0000\u0000\u0536\u0538\u0001\u0000\u0000\u0000\u0537"+
"\u0525\u0001\u0000\u0000\u0000\u0537\u0529\u0001\u0000\u0000\u0000\u0537"+
"\u052a\u0001\u0000\u0000\u0000\u0537\u052b\u0001\u0000\u0000\u0000\u0537"+
"\u052c\u0001\u0000\u0000\u0000\u0537\u052d\u0001\u0000\u0000\u0000\u0537"+
"\u0531\u0001\u0000\u0000\u0000\u0538\u00b7\u0001\u0000\u0000\u0000\u0539"+
"\u053a\u0003T*\u0000\u053a\u053b\u0005H\u0000\u0000\u053b\u053d\u0001"+
"\u0000\u0000\u0000\u053c\u0539\u0001\u0000\u0000\u0000\u053c\u053d\u0001"+
"\u0000\u0000\u0000\u053d\u0541\u0001\u0000\u0000\u0000\u053e\u0540\u0003"+
"j5\u0000\u053f\u053e\u0001\u0000\u0000\u0000\u0540\u0543\u0001\u0000\u0000"+
"\u0000\u0541\u053f\u0001\u0000\u0000\u0000\u0541\u0542\u0001\u0000\u0000"+
"\u0000\u0542\u0544\u0001\u0000\u0000\u0000\u0543\u0541\u0001\u0000\u0000"+
"\u0000\u0544\u0546\u0003\u0000\u0000\u0000\u0545\u0547\u0003\u00d2i\u0000"+
"\u0546\u0545\u0001\u0000\u0000\u0000\u0546\u0547\u0001\u0000\u0000\u0000"+
"\u0547\u00b9\u0001\u0000\u0000\u0000\u0548\u0549\u0003\u00cae\u0000\u0549"+
"\u054a\u0003\u00bc^\u0000\u054a\u054b\u0003\u00c2a\u0000\u054b\u0552\u0001"+
"\u0000\u0000\u0000\u054c\u054f\u0003\u00bc^\u0000\u054d\u0550\u0003\u00c0"+
"`\u0000\u054e\u0550\u0003\u00c2a\u0000\u054f\u054d\u0001\u0000\u0000\u0000"+
"\u054f\u054e\u0001\u0000\u0000\u0000\u0550\u0552\u0001\u0000\u0000\u0000"+
"\u0551\u0548\u0001\u0000\u0000\u0000\u0551\u054c\u0001\u0000\u0000\u0000"+
"\u0552\u00bb\u0001\u0000\u0000\u0000\u0553\u0555\u0003\u0000\u0000\u0000"+
"\u0554\u0556\u0003\u00c6c\u0000\u0555\u0554\u0001\u0000\u0000\u0000\u0555"+
"\u0556\u0001\u0000\u0000\u0000\u0556\u055e\u0001\u0000\u0000\u0000\u0557"+
"\u0558\u0005H\u0000\u0000\u0558\u055a\u0003\u0000\u0000\u0000\u0559\u055b"+
"\u0003\u00c6c\u0000\u055a\u0559\u0001\u0000\u0000\u0000\u055a\u055b\u0001"+
"\u0000\u0000\u0000\u055b\u055d\u0001\u0000\u0000\u0000\u055c\u0557\u0001"+
"\u0000\u0000\u0000\u055d\u0560\u0001\u0000\u0000\u0000\u055e\u055c\u0001"+
"\u0000\u0000\u0000\u055e\u055f\u0001\u0000\u0000\u0000\u055f\u0563\u0001"+
"\u0000\u0000\u0000\u0560\u055e\u0001\u0000\u0000\u0000\u0561\u0563\u0003"+
"\u00d0h\u0000\u0562\u0553\u0001\u0000\u0000\u0000\u0562\u0561\u0001\u0000"+
"\u0000\u0000\u0563\u00bd\u0001\u0000\u0000\u0000\u0564\u0566\u0003\u0000"+
"\u0000\u0000\u0565\u0567\u0003\u00c8d\u0000\u0566\u0565\u0001\u0000\u0000"+
"\u0000\u0566\u0567\u0001\u0000\u0000\u0000\u0567\u0568\u0001\u0000\u0000"+
"\u0000\u0568\u0569\u0003\u00c2a\u0000\u0569\u00bf\u0001\u0000\u0000\u0000"+
"\u056a\u0586\u0005D\u0000\u0000\u056b\u0570\u0005E\u0000\u0000\u056c\u056d"+
"\u0005D\u0000\u0000\u056d\u056f\u0005E\u0000\u0000\u056e\u056c\u0001\u0000"+
"\u0000\u0000\u056f\u0572\u0001\u0000\u0000\u0000\u0570\u056e\u0001\u0000"+
"\u0000\u0000\u0570\u0571\u0001\u0000\u0000\u0000\u0571\u0573\u0001\u0000"+
"\u0000\u0000\u0572\u0570\u0001\u0000\u0000\u0000\u0573\u0587\u0003R)\u0000"+
"\u0574\u0575\u0003\u00aeW\u0000\u0575\u057c\u0005E\u0000\u0000\u0576\u0577"+
"\u0005D\u0000\u0000\u0577\u0578\u0003\u00aeW\u0000\u0578\u0579\u0005E"+
"\u0000\u0000\u0579\u057b\u0001\u0000\u0000\u0000\u057a\u0576\u0001\u0000"+
"\u0000\u0000\u057b\u057e\u0001\u0000\u0000\u0000\u057c\u057a\u0001\u0000"+
"\u0000\u0000\u057c\u057d\u0001\u0000\u0000\u0000\u057d\u0583\u0001\u0000"+
"\u0000\u0000\u057e\u057c\u0001\u0000\u0000\u0000\u057f\u0580\u0005D\u0000"+
"\u0000\u0580\u0582\u0005E\u0000\u0000\u0581\u057f\u0001\u0000\u0000\u0000"+
"\u0582\u0585\u0001\u0000\u0000\u0000\u0583\u0581\u0001\u0000\u0000\u0000"+
"\u0583\u0584\u0001\u0000\u0000\u0000\u0584\u0587\u0001\u0000\u0000\u0000"+
"\u0585\u0583\u0001\u0000\u0000\u0000\u0586\u056b\u0001\u0000\u0000\u0000"+
"\u0586\u0574\u0001\u0000\u0000\u0000\u0587\u00c1\u0001\u0000\u0000\u0000"+
"\u0588\u058a\u0003\u00d8l\u0000\u0589\u058b\u0003$\u0012\u0000\u058a\u0589"+
"\u0001\u0000\u0000\u0000\u058a\u058b\u0001\u0000\u0000\u0000\u058b\u00c3"+
"\u0001\u0000\u0000\u0000\u058c\u058d\u0003\u00cae\u0000\u058d\u058e\u0003"+
"\u00d6k\u0000\u058e\u00c5\u0001\u0000\u0000\u0000\u058f\u0590\u0005K\u0000"+
"\u0000\u0590\u0593\u0005J\u0000\u0000\u0591\u0593\u0003\u00d2i\u0000\u0592"+
"\u058f\u0001\u0000\u0000\u0000\u0592\u0591\u0001\u0000\u0000\u0000\u0593"+
"\u00c7\u0001\u0000\u0000\u0000\u0594\u0595\u0005K\u0000\u0000\u0595\u0598"+
"\u0005J\u0000\u0000\u0596\u0598\u0003\u00cae\u0000\u0597\u0594\u0001\u0000"+
"\u0000\u0000\u0597\u0596\u0001\u0000\u0000\u0000\u0598\u00c9\u0001\u0000"+
"\u0000\u0000\u0599\u059a\u0005K\u0000\u0000\u059a\u059b\u0003\u00ccf\u0000"+
"\u059b\u059c\u0005J\u0000\u0000\u059c\u00cb\u0001\u0000\u0000\u0000\u059d"+
"\u05a2\u0003\u00ceg\u0000\u059e\u059f\u0005G\u0000\u0000\u059f\u05a1\u0003"+
"\u00ceg\u0000\u05a0\u059e\u0001\u0000\u0000\u0000\u05a1\u05a4\u0001\u0000"+
"\u0000\u0000\u05a2\u05a0\u0001\u0000\u0000\u0000\u05a2\u05a3\u0001\u0000"+
"\u0000\u0000\u05a3\u00cd\u0001\u0000\u0000\u0000\u05a4\u05a2\u0001\u0000"+
"\u0000\u0000\u05a5\u05a7\u0003j5\u0000\u05a6\u05a5\u0001\u0000\u0000\u0000"+
"\u05a6\u05a7\u0001\u0000\u0000\u0000\u05a7\u05aa\u0001\u0000\u0000\u0000"+
"\u05a8\u05ab\u0003T*\u0000\u05a9\u05ab\u0003\u00d0h\u0000\u05aa\u05a8"+
"\u0001\u0000\u0000\u0000\u05aa\u05a9\u0001\u0000\u0000\u0000\u05ab\u05b0"+
"\u0001\u0000\u0000\u0000\u05ac\u05ad\u0005D\u0000\u0000\u05ad\u05af\u0005"+
"E\u0000\u0000\u05ae\u05ac\u0001\u0000\u0000\u0000\u05af\u05b2\u0001\u0000"+
"\u0000\u0000\u05b0\u05ae\u0001\u0000\u0000\u0000\u05b0\u05b1\u0001\u0000"+
"\u0000\u0000\u05b1\u00cf\u0001\u0000\u0000\u0000\u05b2\u05b0\u0001\u0000"+
"\u0000\u0000\u05b3\u05b4\u0007\r\u0000\u0000\u05b4\u00d1\u0001\u0000\u0000"+
"\u0000\u05b5\u05b6\u0005K\u0000\u0000\u05b6\u05bb\u0003V+\u0000\u05b7"+
"\u05b8\u0005G\u0000\u0000\u05b8\u05ba\u0003V+\u0000\u05b9\u05b7\u0001"+
"\u0000\u0000\u0000\u05ba\u05bd\u0001\u0000\u0000\u0000\u05bb\u05b9\u0001"+
"\u0000\u0000\u0000\u05bb\u05bc\u0001\u0000\u0000\u0000\u05bc\u05be\u0001"+
"\u0000\u0000\u0000\u05bd\u05bb\u0001\u0000\u0000\u0000\u05be\u05bf\u0005"+
"J\u0000\u0000\u05bf\u00d3\u0001\u0000\u0000\u0000\u05c0\u05c7\u0003\u00d8"+
"l\u0000\u05c1\u05c2\u0005H\u0000\u0000\u05c2\u05c4\u0003\u0000\u0000\u0000"+
"\u05c3\u05c5\u0003\u00d8l\u0000\u05c4\u05c3\u0001\u0000\u0000\u0000\u05c4"+
"\u05c5\u0001\u0000\u0000\u0000\u05c5\u05c7\u0001\u0000\u0000\u0000\u05c6"+
"\u05c0\u0001\u0000\u0000\u0000\u05c6\u05c1\u0001\u0000\u0000\u0000\u05c7"+
"\u00d5\u0001\u0000\u0000\u0000\u05c8\u05c9\u0005)\u0000\u0000\u05c9\u05ce"+
"\u0003\u00d4j\u0000\u05ca\u05cb\u0003\u0000\u0000\u0000\u05cb\u05cc\u0003"+
"\u00d8l\u0000\u05cc\u05ce\u0001\u0000\u0000\u0000\u05cd\u05c8\u0001\u0000"+
"\u0000\u0000\u05cd\u05ca\u0001\u0000\u0000\u0000\u05ce\u00d7\u0001\u0000"+
"\u0000\u0000\u05cf\u05d1\u0005@\u0000\u0000\u05d0\u05d2\u0003\u00aaU\u0000"+
"\u05d1\u05d0\u0001\u0000\u0000\u0000\u05d1\u05d2\u0001\u0000\u0000\u0000"+
"\u05d2\u05d3\u0001\u0000\u0000\u0000\u05d3\u05d4\u0005A\u0000\u0000\u05d4"+
"\u00d9\u0001\u0000\u0000\u0000\u00b9\u00dd\u00e2\u00e8\u00f0\u00f9\u00fe"+
"\u0103\u0108\u0110\u0113\u011a\u0124\u0128\u012f\u0136\u013a\u013e\u0148"+
"\u0150\u0156\u015d\u0164\u0168\u016b\u016e\u0177\u017d\u0182\u0185\u018b"+
"\u0191\u0195\u019d\u01a6\u01ad\u01b1\u01b6\u01ba\u01c6\u01cf\u01d4\u01da"+
"\u01de\u01ea\u01f1\u01fc\u0201\u020a\u0212\u021c\u0225\u022d\u0232\u023a"+
"\u023f\u0249\u0253\u0259\u0260\u0265\u026d\u0271\u0273\u0279\u027e\u0282"+
"\u0289\u028b\u0292\u0297\u02a0\u02a5\u02a8\u02ad\u02b6\u02c2\u02cc\u02d7"+
"\u02da\u02e1\u02eb\u02f3\u02f6\u02f9\u0306\u030e\u0313\u031b\u031f\u0323"+
"\u0327\u0329\u032d\u0333\u033e\u0348\u034d\u0356\u035c\u035f\u0366\u036f"+
"\u0386\u0389\u038c\u0394\u0398\u03a0\u03a6\u03b1\u03b7\u03c2\u03cf\u03d4"+
"\u03df\u03e6\u03f3\u03fc\u0405\u040b\u0416\u041b\u0420\u0426\u042b\u0430"+
"\u0438\u043c\u0442\u0446\u044a\u044e\u0450\u0454\u0459\u046a\u0470\u0477"+
"\u047d\u0480\u0494\u0498\u049d\u04a7\u04ad\u04b2\u04c2\u04ea\u04f0\u04fd"+
"\u0502\u0505\u0507\u0511\u051a\u051f\u0523\u0535\u0537\u053c\u0541\u0546"+
"\u054f\u0551\u0555\u055a\u055e\u0562\u0566\u0570\u057c\u0583\u0586\u058a"+
"\u0592\u0597\u05a2\u05a6\u05aa\u05b0\u05bb\u05c4\u05c6\u05cd\u05d1";
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);
}
}
}