// Generated from /home/nick/projects/feather2/feather2-grammar/src/dist/FeatherParser.g4 by ANTLR 4.13.2
package uk.co.nickthecoder.feather.grammar;
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 FeatherParser 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
HashBangLine=1, Documentation=2, DelimitedComment=3, LineComment=4, WS=5,
NL=6, DOT=7, COMMA=8, LPAREN=9, RPAREN=10, LSQUARE=11, RSQUARE=12, BARRELOPEN=13,
BARRELCLOSE=14, LCURL=15, RCURL=16, POWER=17, MULT=18, REM=19, DIVIDE=20,
BACKSLASH=21, FLOOR_DIV=22, ARROW=23, ADD=24, SUB=25, INCR=26, DECR=27,
CONJ=28, PIPE=29, DISJ=30, EXCL=31, COLON=32, COLON_COLON=33, CURRIED=34,
SEMICOLON=35, ASSIGNMENT=36, ADD_ASSIGNMENT=37, SUB_ASSIGNMENT=38, MULT_ASSIGNMENT=39,
FLOOR_DIV_ASSIGNMENT=40, DIVIDE_ASSIGNMENT=41, REM_ASSIGNMENT=42, RANGE=43,
RANGE_UNTIL=44, ELVIS=45, LANGLE=46, RANGLE=47, REDIRECT=48, LE=49, GE=50,
EXCL_EQ=51, EXCL_EQEQ=52, AS_SAFE=53, EQEQ=54, EQEQEQ=55, MAP_TO=56, SINGLE_QUOTE=57,
ELIPSIS=58, ABSTRACT=59, APPLY=60, AS=61, BREAK=62, CATCH=63, CLASS=64,
CONSTRUCTOR=65, CONTINUE=66, DO=67, ELSE=68, ENUM=69, FINAL=70, FINALLY=71,
FOR=72, FUN=73, FUNC=74, IF=75, IN=76, NOT_IN=77, IS=78, NOT_IS=79, IMPORT=80,
INCLUDE=81, INTERFACE=82, INIT=83, METH=84, OPEN=85, OVERRIDE=86, PACKAGE=87,
LIBRARY=88, RETURN=89, STATIC=90, SUPER=91, THIS=92, THROW=93, TRY=94,
VAL=95, VAR=96, WHILE=97, WITH=98, QUOTE_OPEN=99, TRIPLE_QUOTE_OPEN=100,
COMMAND_OPEN=101, FloatLiteral=102, DoubleLiteral=103, LongLiteral=104,
ByteLiteral=105, ShortLiteral=106, IntegerLiteral=107, RealLiteral=108,
DecLiteral=109, HexLiteral=110, BinLiteral=111, BooleanLiteral=112, NullLiteral=113,
Identifier=114, LabelReference=115, LabelDefinition=116, FieldIdentifier=117,
CharacterLiteral=118, UNICODE_CLASS_LL=119, UNICODE_CLASS_LM=120, UNICODE_CLASS_LO=121,
UNICODE_CLASS_LT=122, UNICODE_CLASS_LU=123, UNICODE_CLASS_ND=124, UNICODE_CLASS_NL=125,
Path=126, Inside_Comment=127, Inside_WS=128, Inside_NL=129, QUOTE_CLOSE=130,
LineStrRef=131, LineStrText=132, LineStrEscapedChar=133, LineStrExprStart=134,
TRIPLE_QUOTE_CLOSE=135, MultiLineStringQuote=136, MultiLineStrRef=137,
MultiLineStrText=138, MultiLineStrEscapedChar=139, MultiLineStrExprStart=140,
MultiLineNL=141, StrExpr_IN=142, StrExpr_Comment=143, StrExpr_WS=144,
StrExpr_NL=145, COMMAND_CLOSE=146, CommandRef=147, CommandText=148, CommandEscapedChar=149,
CommandExprStart=150;
public static final int
RULE_featherFile = 0, RULE_hashBangLine = 1, RULE_preamble = 2, RULE_packageHeader = 3,
RULE_libraryIncludeImportList = 4, RULE_libraryHeader = 5, RULE_importHeader = 6,
RULE_includeHeader = 7, RULE_importAlias = 8, RULE_topLevelObject = 9,
RULE_classDeclaration = 10, RULE_documentation = 11, RULE_classDetails = 12,
RULE_classModifiersAndName = 13, RULE_primaryConstructorDescription = 14,
RULE_primaryConstructorParameters = 15, RULE_primaryConstructorParameter = 16,
RULE_extendsList = 17, RULE_extendsSpecifier = 18, RULE_constructorInvocation = 19,
RULE_classBody = 20, RULE_enumValues = 21, RULE_enumValue = 22, RULE_enumArguments = 23,
RULE_typeArguments = 24, RULE_typeProjection = 25, RULE_type = 26, RULE_nonFunctionType = 27,
RULE_functionType = 28, RULE_functionTypeReturn = 29, RULE_genericSpec = 30,
RULE_simpleUserType = 31, RULE_classMemberDeclarations = 32, RULE_secondaryConstructor = 33,
RULE_secondaryConstructorDescription = 34, RULE_secondaryConstructorParameters = 35,
RULE_constructorDelegationCall = 36, RULE_fieldDeclaration = 37, RULE_fieldDeclarationDescription = 38,
RULE_annotations = 39, RULE_annotation = 40, RULE_annotationValues = 41,
RULE_annotationValue = 42, RULE_initBlock = 43, RULE_variableDeclaration = 44,
RULE_methodDeclaration = 45, RULE_methodDescription = 46, RULE_methodValueParameters = 47,
RULE_methodParameter = 48, RULE_methodBody = 49, RULE_methodBlock = 50,
RULE_block = 51, RULE_controlStructureBody = 52, RULE_statements = 53,
RULE_statement = 54, RULE_localVariableDeclaration = 55, RULE_throwStatement = 56,
RULE_returnStatement = 57, RULE_continueStatement = 58, RULE_breakStatement = 59,
RULE_expression = 60, RULE_postfixCall = 61, RULE_disjunction = 62, RULE_conjunction = 63,
RULE_equalityComparison = 64, RULE_comparison = 65, RULE_namedInfix = 66,
RULE_elvisExpression = 67, RULE_infixFunctionCall = 68, RULE_mapToExpression = 69,
RULE_rangeExpression = 70, RULE_additiveExpression = 71, RULE_multiplicativeExpression = 72,
RULE_powerExpression = 73, RULE_typeRHS = 74, RULE_prefixUnaryExpression = 75,
RULE_invokableExpression = 76, RULE_postfixUnaryExpression = 77, RULE_receiverMethodCall = 78,
RULE_methodCall = 79, RULE_function = 80, RULE_curriedFunction = 81, RULE_receiverAction = 82,
RULE_receiverDescription = 83, RULE_with = 84, RULE_withDescription = 85,
RULE_fieldAccess = 86, RULE_arrayAccess = 87, RULE_callSuffix = 88, RULE_valueArguments = 89,
RULE_valueArgument = 90, RULE_atomicExpression = 91, RULE_atomicIdentifier = 92,
RULE_thisExpression = 93, RULE_superExpression = 94, RULE_parenthesizedExpression = 95,
RULE_ifExpression = 96, RULE_forStatement = 97, RULE_forSetup = 98, RULE_forBody = 99,
RULE_whileStatement = 100, RULE_doWhileStatement = 101, RULE_tryExpression = 102,
RULE_tryBlock = 103, RULE_catchBlock = 104, RULE_finallyBlock = 105, RULE_literalConstant = 106,
RULE_nullLiteral = 107, RULE_booleanLiteral = 108, RULE_characterLiteral = 109,
RULE_byteLiteral = 110, RULE_shortLiteral = 111, RULE_intLiteral = 112,
RULE_longLiteral = 113, RULE_floatLiteral = 114, RULE_doubleLiteral = 115,
RULE_realLiteral = 116, RULE_stringLiteral = 117, RULE_lineStringLiteral = 118,
RULE_multiLineStringLiteral = 119, RULE_lineStringContent = 120, RULE_lineStringExpression = 121,
RULE_multiLineStringContent = 122, RULE_multiLineStringExpression = 123,
RULE_multiLineStringQuote = 124, RULE_commandLiteral = 125, RULE_commandContent = 126,
RULE_commandExpression = 127, RULE_identifier = 128, RULE_simpleIdentifier = 129,
RULE_semi = 130, RULE_anysemi = 131;
private static String[] makeRuleNames() {
return new String[] {
"featherFile", "hashBangLine", "preamble", "packageHeader", "libraryIncludeImportList",
"libraryHeader", "importHeader", "includeHeader", "importAlias", "topLevelObject",
"classDeclaration", "documentation", "classDetails", "classModifiersAndName",
"primaryConstructorDescription", "primaryConstructorParameters", "primaryConstructorParameter",
"extendsList", "extendsSpecifier", "constructorInvocation", "classBody",
"enumValues", "enumValue", "enumArguments", "typeArguments", "typeProjection",
"type", "nonFunctionType", "functionType", "functionTypeReturn", "genericSpec",
"simpleUserType", "classMemberDeclarations", "secondaryConstructor",
"secondaryConstructorDescription", "secondaryConstructorParameters",
"constructorDelegationCall", "fieldDeclaration", "fieldDeclarationDescription",
"annotations", "annotation", "annotationValues", "annotationValue", "initBlock",
"variableDeclaration", "methodDeclaration", "methodDescription", "methodValueParameters",
"methodParameter", "methodBody", "methodBlock", "block", "controlStructureBody",
"statements", "statement", "localVariableDeclaration", "throwStatement",
"returnStatement", "continueStatement", "breakStatement", "expression",
"postfixCall", "disjunction", "conjunction", "equalityComparison", "comparison",
"namedInfix", "elvisExpression", "infixFunctionCall", "mapToExpression",
"rangeExpression", "additiveExpression", "multiplicativeExpression",
"powerExpression", "typeRHS", "prefixUnaryExpression", "invokableExpression",
"postfixUnaryExpression", "receiverMethodCall", "methodCall", "function",
"curriedFunction", "receiverAction", "receiverDescription", "with", "withDescription",
"fieldAccess", "arrayAccess", "callSuffix", "valueArguments", "valueArgument",
"atomicExpression", "atomicIdentifier", "thisExpression", "superExpression",
"parenthesizedExpression", "ifExpression", "forStatement", "forSetup",
"forBody", "whileStatement", "doWhileStatement", "tryExpression", "tryBlock",
"catchBlock", "finallyBlock", "literalConstant", "nullLiteral", "booleanLiteral",
"characterLiteral", "byteLiteral", "shortLiteral", "intLiteral", "longLiteral",
"floatLiteral", "doubleLiteral", "realLiteral", "stringLiteral", "lineStringLiteral",
"multiLineStringLiteral", "lineStringContent", "lineStringExpression",
"multiLineStringContent", "multiLineStringExpression", "multiLineStringQuote",
"commandLiteral", "commandContent", "commandExpression", "identifier",
"simpleIdentifier", "semi", "anysemi"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, null, null, null, null, null, null, "'.'", "','", "'('", null,
"'['", null, "'[['", null, "'{'", "'}'", "'^'", "'*'", "'%'", "'/'",
"'\\'", "'~/'", "'->'", "'+'", "'-'", "'++'", "'--'", "'&&'", "'|'",
"'||'", "'!'", "':'", "'::'", "':>'", "';'", "'='", "'+='", "'-='", "'*='",
"'~/='", "'/='", "'%='", "'..'", "'..<'", "'?:'", "'<'", "'>'", "'|>'",
"'<='", "'>='", "'!='", "'!=='", "'as?'", "'=='", "'==='", "'=>'", "'''",
"'...'", "'abstract'", "'apply'", "'as'", "'break'", "'catch'", "'class'",
"'constructor'", "'continue'", "'do'", "'else'", "'enum'", "'final'",
"'finally'", "'for'", "'fun'", "'func'", "'if'", "'in'", null, "'is'",
null, "'import'", "'include'", "'interface'", "'init'", "'meth'", "'open'",
"'override'", "'package'", "'library'", "'return'", "'static'", "'super'",
"'this'", "'throw'", "'try'", "'val'", "'var'", "'while'", "'with'",
null, "'\"\"\"'", "'$('", null, 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, "HashBangLine", "Documentation", "DelimitedComment", "LineComment",
"WS", "NL", "DOT", "COMMA", "LPAREN", "RPAREN", "LSQUARE", "RSQUARE",
"BARRELOPEN", "BARRELCLOSE", "LCURL", "RCURL", "POWER", "MULT", "REM",
"DIVIDE", "BACKSLASH", "FLOOR_DIV", "ARROW", "ADD", "SUB", "INCR", "DECR",
"CONJ", "PIPE", "DISJ", "EXCL", "COLON", "COLON_COLON", "CURRIED", "SEMICOLON",
"ASSIGNMENT", "ADD_ASSIGNMENT", "SUB_ASSIGNMENT", "MULT_ASSIGNMENT",
"FLOOR_DIV_ASSIGNMENT", "DIVIDE_ASSIGNMENT", "REM_ASSIGNMENT", "RANGE",
"RANGE_UNTIL", "ELVIS", "LANGLE", "RANGLE", "REDIRECT", "LE", "GE", "EXCL_EQ",
"EXCL_EQEQ", "AS_SAFE", "EQEQ", "EQEQEQ", "MAP_TO", "SINGLE_QUOTE", "ELIPSIS",
"ABSTRACT", "APPLY", "AS", "BREAK", "CATCH", "CLASS", "CONSTRUCTOR",
"CONTINUE", "DO", "ELSE", "ENUM", "FINAL", "FINALLY", "FOR", "FUN", "FUNC",
"IF", "IN", "NOT_IN", "IS", "NOT_IS", "IMPORT", "INCLUDE", "INTERFACE",
"INIT", "METH", "OPEN", "OVERRIDE", "PACKAGE", "LIBRARY", "RETURN", "STATIC",
"SUPER", "THIS", "THROW", "TRY", "VAL", "VAR", "WHILE", "WITH", "QUOTE_OPEN",
"TRIPLE_QUOTE_OPEN", "COMMAND_OPEN", "FloatLiteral", "DoubleLiteral",
"LongLiteral", "ByteLiteral", "ShortLiteral", "IntegerLiteral", "RealLiteral",
"DecLiteral", "HexLiteral", "BinLiteral", "BooleanLiteral", "NullLiteral",
"Identifier", "LabelReference", "LabelDefinition", "FieldIdentifier",
"CharacterLiteral", "UNICODE_CLASS_LL", "UNICODE_CLASS_LM", "UNICODE_CLASS_LO",
"UNICODE_CLASS_LT", "UNICODE_CLASS_LU", "UNICODE_CLASS_ND", "UNICODE_CLASS_NL",
"Path", "Inside_Comment", "Inside_WS", "Inside_NL", "QUOTE_CLOSE", "LineStrRef",
"LineStrText", "LineStrEscapedChar", "LineStrExprStart", "TRIPLE_QUOTE_CLOSE",
"MultiLineStringQuote", "MultiLineStrRef", "MultiLineStrText", "MultiLineStrEscapedChar",
"MultiLineStrExprStart", "MultiLineNL", "StrExpr_IN", "StrExpr_Comment",
"StrExpr_WS", "StrExpr_NL", "COMMAND_CLOSE", "CommandRef", "CommandText",
"CommandEscapedChar", "CommandExprStart"
};
}
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] = "<INVALID>";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
@Override
public String getGrammarFileName() { return "FeatherParser.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public FeatherParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
@SuppressWarnings("CheckReturnValue")
public static class FeatherFileContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(FeatherParser.EOF, 0); }
public PreambleContext preamble() {
return getRuleContext(PreambleContext.class,0);
}
public HashBangLineContext hashBangLine() {
return getRuleContext(HashBangLineContext.class,0);
}
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public List<AnysemiContext> anysemi() {
return getRuleContexts(AnysemiContext.class);
}
public AnysemiContext anysemi(int i) {
return getRuleContext(AnysemiContext.class,i);
}
public List<TopLevelObjectContext> topLevelObject() {
return getRuleContexts(TopLevelObjectContext.class);
}
public TopLevelObjectContext topLevelObject(int i) {
return getRuleContext(TopLevelObjectContext.class,i);
}
public FeatherFileContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_featherFile; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterFeatherFile(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitFeatherFile(this);
}
}
public final FeatherFileContext featherFile() throws RecognitionException {
FeatherFileContext _localctx = new FeatherFileContext(_ctx, getState());
enterRule(_localctx, 0, RULE_featherFile);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(265);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==HashBangLine) {
{
setState(264);
hashBangLine();
}
}
setState(270);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,1,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(267);
match(NL);
}
}
}
setState(272);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,1,_ctx);
}
setState(276);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,2,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(273);
anysemi();
}
}
}
setState(278);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,2,_ctx);
}
{
setState(279);
preamble();
}
setState(283);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,3,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(280);
match(NL);
}
}
}
setState(285);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,3,_ctx);
}
setState(289);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL || _la==SEMICOLON) {
{
{
setState(286);
anysemi();
}
}
setState(291);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(306);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Documentation || _la==ABSTRACT || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 2251806330848865L) != 0)) {
{
setState(292);
topLevelObject();
setState(303);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL || _la==SEMICOLON) {
{
{
setState(294);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(293);
anysemi();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(296);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,5,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
setState(299);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Documentation || _la==ABSTRACT || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 2251806330848865L) != 0)) {
{
setState(298);
topLevelObject();
}
}
}
}
setState(305);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(308);
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 HashBangLineContext extends ParserRuleContext {
public TerminalNode HashBangLine() { return getToken(FeatherParser.HashBangLine, 0); }
public HashBangLineContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_hashBangLine; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterHashBangLine(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitHashBangLine(this);
}
}
public final HashBangLineContext hashBangLine() throws RecognitionException {
HashBangLineContext _localctx = new HashBangLineContext(_ctx, getState());
enterRule(_localctx, 2, RULE_hashBangLine);
try {
enterOuterAlt(_localctx, 1);
{
setState(310);
match(HashBangLine);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PreambleContext extends ParserRuleContext {
public PackageHeaderContext packageHeader() {
return getRuleContext(PackageHeaderContext.class,0);
}
public LibraryIncludeImportListContext libraryIncludeImportList() {
return getRuleContext(LibraryIncludeImportListContext.class,0);
}
public PreambleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_preamble; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterPreamble(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitPreamble(this);
}
}
public final PreambleContext preamble() throws RecognitionException {
PreambleContext _localctx = new PreambleContext(_ctx, getState());
enterRule(_localctx, 4, RULE_preamble);
try {
enterOuterAlt(_localctx, 1);
{
setState(312);
packageHeader();
setState(313);
libraryIncludeImportList();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PackageHeaderContext extends ParserRuleContext {
public IdentifierContext packageName;
public TerminalNode PACKAGE() { return getToken(FeatherParser.PACKAGE, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public SemiContext semi() {
return getRuleContext(SemiContext.class,0);
}
public PackageHeaderContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_packageHeader; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterPackageHeader(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitPackageHeader(this);
}
}
public final PackageHeaderContext packageHeader() throws RecognitionException {
PackageHeaderContext _localctx = new PackageHeaderContext(_ctx, getState());
enterRule(_localctx, 6, RULE_packageHeader);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(320);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PACKAGE) {
{
setState(315);
match(PACKAGE);
setState(316);
((PackageHeaderContext)_localctx).packageName = identifier();
setState(318);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
case 1:
{
setState(317);
semi();
}
break;
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LibraryIncludeImportListContext extends ParserRuleContext {
public List<LibraryHeaderContext> libraryHeader() {
return getRuleContexts(LibraryHeaderContext.class);
}
public LibraryHeaderContext libraryHeader(int i) {
return getRuleContext(LibraryHeaderContext.class,i);
}
public List<IncludeHeaderContext> includeHeader() {
return getRuleContexts(IncludeHeaderContext.class);
}
public IncludeHeaderContext includeHeader(int i) {
return getRuleContext(IncludeHeaderContext.class,i);
}
public List<ImportHeaderContext> importHeader() {
return getRuleContexts(ImportHeaderContext.class);
}
public ImportHeaderContext importHeader(int i) {
return getRuleContext(ImportHeaderContext.class,i);
}
public LibraryIncludeImportListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_libraryIncludeImportList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterLibraryIncludeImportList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitLibraryIncludeImportList(this);
}
}
public final LibraryIncludeImportListContext libraryIncludeImportList() throws RecognitionException {
LibraryIncludeImportListContext _localctx = new LibraryIncludeImportListContext(_ctx, getState());
enterRule(_localctx, 8, RULE_libraryIncludeImportList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(327);
_errHandler.sync(this);
_la = _input.LA(1);
while (((((_la - 80)) & ~0x3f) == 0 && ((1L << (_la - 80)) & 259L) != 0)) {
{
setState(325);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LIBRARY:
{
setState(322);
libraryHeader();
}
break;
case INCLUDE:
{
setState(323);
includeHeader();
}
break;
case IMPORT:
{
setState(324);
importHeader();
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(329);
_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 LibraryHeaderContext extends ParserRuleContext {
public TerminalNode LIBRARY() { return getToken(FeatherParser.LIBRARY, 0); }
public TerminalNode Path() { return getToken(FeatherParser.Path, 0); }
public SemiContext semi() {
return getRuleContext(SemiContext.class,0);
}
public LibraryHeaderContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_libraryHeader; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterLibraryHeader(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitLibraryHeader(this);
}
}
public final LibraryHeaderContext libraryHeader() throws RecognitionException {
LibraryHeaderContext _localctx = new LibraryHeaderContext(_ctx, getState());
enterRule(_localctx, 10, RULE_libraryHeader);
try {
enterOuterAlt(_localctx, 1);
{
setState(330);
match(LIBRARY);
setState(331);
match(Path);
setState(333);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) {
case 1:
{
setState(332);
semi();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ImportHeaderContext extends ParserRuleContext {
public IdentifierContext imported;
public TerminalNode IMPORT() { return getToken(FeatherParser.IMPORT, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode STATIC() { return getToken(FeatherParser.STATIC, 0); }
public TerminalNode DOT() { return getToken(FeatherParser.DOT, 0); }
public TerminalNode MULT() { return getToken(FeatherParser.MULT, 0); }
public ImportAliasContext importAlias() {
return getRuleContext(ImportAliasContext.class,0);
}
public SemiContext semi() {
return getRuleContext(SemiContext.class,0);
}
public ImportHeaderContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_importHeader; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterImportHeader(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitImportHeader(this);
}
}
public final ImportHeaderContext importHeader() throws RecognitionException {
ImportHeaderContext _localctx = new ImportHeaderContext(_ctx, getState());
enterRule(_localctx, 12, RULE_importHeader);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(335);
match(IMPORT);
setState(337);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==STATIC) {
{
setState(336);
match(STATIC);
}
}
setState(339);
((ImportHeaderContext)_localctx).imported = identifier();
setState(343);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DOT:
{
setState(340);
match(DOT);
setState(341);
match(MULT);
}
break;
case AS:
{
setState(342);
importAlias();
}
break;
case EOF:
case Documentation:
case NL:
case SEMICOLON:
case ABSTRACT:
case CLASS:
case ENUM:
case FINAL:
case FUN:
case FUNC:
case IMPORT:
case INCLUDE:
case INTERFACE:
case METH:
case OPEN:
case OVERRIDE:
case LIBRARY:
case STATIC:
case VAL:
case VAR:
case LabelReference:
break;
default:
break;
}
setState(346);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) {
case 1:
{
setState(345);
semi();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class IncludeHeaderContext extends ParserRuleContext {
public TerminalNode INCLUDE() { return getToken(FeatherParser.INCLUDE, 0); }
public TerminalNode Path() { return getToken(FeatherParser.Path, 0); }
public SemiContext semi() {
return getRuleContext(SemiContext.class,0);
}
public IncludeHeaderContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_includeHeader; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterIncludeHeader(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitIncludeHeader(this);
}
}
public final IncludeHeaderContext includeHeader() throws RecognitionException {
IncludeHeaderContext _localctx = new IncludeHeaderContext(_ctx, getState());
enterRule(_localctx, 14, RULE_includeHeader);
try {
enterOuterAlt(_localctx, 1);
{
setState(348);
match(INCLUDE);
setState(349);
match(Path);
setState(351);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
case 1:
{
setState(350);
semi();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ImportAliasContext extends ParserRuleContext {
public TerminalNode AS() { return getToken(FeatherParser.AS, 0); }
public SimpleIdentifierContext simpleIdentifier() {
return getRuleContext(SimpleIdentifierContext.class,0);
}
public ImportAliasContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_importAlias; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterImportAlias(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitImportAlias(this);
}
}
public final ImportAliasContext importAlias() throws RecognitionException {
ImportAliasContext _localctx = new ImportAliasContext(_ctx, getState());
enterRule(_localctx, 16, RULE_importAlias);
try {
enterOuterAlt(_localctx, 1);
{
setState(353);
match(AS);
setState(354);
simpleIdentifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TopLevelObjectContext extends ParserRuleContext {
public ClassDeclarationContext classDeclaration() {
return getRuleContext(ClassDeclarationContext.class,0);
}
public FieldDeclarationContext fieldDeclaration() {
return getRuleContext(FieldDeclarationContext.class,0);
}
public MethodDeclarationContext methodDeclaration() {
return getRuleContext(MethodDeclarationContext.class,0);
}
public TopLevelObjectContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_topLevelObject; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterTopLevelObject(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitTopLevelObject(this);
}
}
public final TopLevelObjectContext topLevelObject() throws RecognitionException {
TopLevelObjectContext _localctx = new TopLevelObjectContext(_ctx, getState());
enterRule(_localctx, 18, RULE_topLevelObject);
try {
setState(359);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(356);
classDeclaration();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(357);
fieldDeclaration();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(358);
methodDeclaration();
}
break;
}
}
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 ClassDetailsContext classDetails() {
return getRuleContext(ClassDetailsContext.class,0);
}
public ClassBodyContext classBody() {
return getRuleContext(ClassBodyContext.class,0);
}
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
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 FeatherParserListener ) ((FeatherParserListener)listener).enterClassDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitClassDeclaration(this);
}
}
public final ClassDeclarationContext classDeclaration() throws RecognitionException {
ClassDeclarationContext _localctx = new ClassDeclarationContext(_ctx, getState());
enterRule(_localctx, 20, RULE_classDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(361);
classDetails();
setState(365);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(362);
match(NL);
}
}
setState(367);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(368);
classBody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DocumentationContext extends ParserRuleContext {
public TerminalNode Documentation() { return getToken(FeatherParser.Documentation, 0); }
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public DocumentationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_documentation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterDocumentation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitDocumentation(this);
}
}
public final DocumentationContext documentation() throws RecognitionException {
DocumentationContext _localctx = new DocumentationContext(_ctx, getState());
enterRule(_localctx, 22, RULE_documentation);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(370);
match(Documentation);
setState(374);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,20,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(371);
match(NL);
}
}
}
setState(376);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,20,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ClassDetailsContext extends ParserRuleContext {
public List<AnnotationsContext> annotations() {
return getRuleContexts(AnnotationsContext.class);
}
public AnnotationsContext annotations(int i) {
return getRuleContext(AnnotationsContext.class,i);
}
public ClassModifiersAndNameContext classModifiersAndName() {
return getRuleContext(ClassModifiersAndNameContext.class,0);
}
public PrimaryConstructorDescriptionContext primaryConstructorDescription() {
return getRuleContext(PrimaryConstructorDescriptionContext.class,0);
}
public DocumentationContext documentation() {
return getRuleContext(DocumentationContext.class,0);
}
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public TerminalNode CONSTRUCTOR() { return getToken(FeatherParser.CONSTRUCTOR, 0); }
public TerminalNode COLON() { return getToken(FeatherParser.COLON, 0); }
public ExtendsListContext extendsList() {
return getRuleContext(ExtendsListContext.class,0);
}
public ClassDetailsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classDetails; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterClassDetails(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitClassDetails(this);
}
}
public final ClassDetailsContext classDetails() throws RecognitionException {
ClassDetailsContext _localctx = new ClassDetailsContext(_ctx, getState());
enterRule(_localctx, 24, RULE_classDetails);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(378);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Documentation) {
{
setState(377);
documentation();
}
}
setState(380);
annotations();
setState(381);
classModifiersAndName();
setState(385);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,22,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(382);
match(NL);
}
}
}
setState(387);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,22,_ctx);
}
setState(391);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==CONSTRUCTOR || _la==LabelReference) {
{
setState(388);
annotations();
setState(389);
match(CONSTRUCTOR);
}
}
setState(393);
primaryConstructorDescription();
setState(402);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLON) {
{
setState(394);
match(COLON);
setState(398);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(395);
match(NL);
}
}
setState(400);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(401);
extendsList();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ClassModifiersAndNameContext extends ParserRuleContext {
public SimpleIdentifierContext className;
public SimpleIdentifierContext simpleIdentifier() {
return getRuleContext(SimpleIdentifierContext.class,0);
}
public TerminalNode INTERFACE() { return getToken(FeatherParser.INTERFACE, 0); }
public TerminalNode CLASS() { return getToken(FeatherParser.CLASS, 0); }
public TerminalNode FINAL() { return getToken(FeatherParser.FINAL, 0); }
public TerminalNode OPEN() { return getToken(FeatherParser.OPEN, 0); }
public TerminalNode ABSTRACT() { return getToken(FeatherParser.ABSTRACT, 0); }
public TerminalNode ENUM() { return getToken(FeatherParser.ENUM, 0); }
public ClassModifiersAndNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classModifiersAndName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterClassModifiersAndName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitClassModifiersAndName(this);
}
}
public final ClassModifiersAndNameContext classModifiersAndName() throws RecognitionException {
ClassModifiersAndNameContext _localctx = new ClassModifiersAndNameContext(_ctx, getState());
enterRule(_localctx, 26, RULE_classModifiersAndName);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(412);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ABSTRACT:
case CLASS:
case ENUM:
case FINAL:
case OPEN:
{
{
setState(405);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FINAL || _la==OPEN) {
{
setState(404);
_la = _input.LA(1);
if ( !(_la==FINAL || _la==OPEN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(408);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ABSTRACT || _la==ENUM) {
{
setState(407);
_la = _input.LA(1);
if ( !(_la==ABSTRACT || _la==ENUM) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(410);
match(CLASS);
}
}
break;
case INTERFACE:
{
setState(411);
match(INTERFACE);
}
break;
default:
throw new NoViableAltException(this);
}
setState(414);
((ClassModifiersAndNameContext)_localctx).className = simpleIdentifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PrimaryConstructorDescriptionContext extends ParserRuleContext {
public DocumentationContext documentation() {
return getRuleContext(DocumentationContext.class,0);
}
public PrimaryConstructorParametersContext primaryConstructorParameters() {
return getRuleContext(PrimaryConstructorParametersContext.class,0);
}
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public PrimaryConstructorDescriptionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primaryConstructorDescription; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterPrimaryConstructorDescription(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitPrimaryConstructorDescription(this);
}
}
public final PrimaryConstructorDescriptionContext primaryConstructorDescription() throws RecognitionException {
PrimaryConstructorDescriptionContext _localctx = new PrimaryConstructorDescriptionContext(_ctx, getState());
enterRule(_localctx, 28, RULE_primaryConstructorDescription);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(417);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Documentation) {
{
setState(416);
documentation();
}
}
setState(420);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(419);
primaryConstructorParameters();
}
}
setState(425);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,31,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(422);
match(NL);
}
}
}
setState(427);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,31,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PrimaryConstructorParametersContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(FeatherParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(FeatherParser.RPAREN, 0); }
public List<PrimaryConstructorParameterContext> primaryConstructorParameter() {
return getRuleContexts(PrimaryConstructorParameterContext.class);
}
public PrimaryConstructorParameterContext primaryConstructorParameter(int i) {
return getRuleContext(PrimaryConstructorParameterContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(FeatherParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(FeatherParser.COMMA, i);
}
public PrimaryConstructorParametersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primaryConstructorParameters; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterPrimaryConstructorParameters(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitPrimaryConstructorParameters(this);
}
}
public final PrimaryConstructorParametersContext primaryConstructorParameters() throws RecognitionException {
PrimaryConstructorParametersContext _localctx = new PrimaryConstructorParametersContext(_ctx, getState());
enterRule(_localctx, 30, RULE_primaryConstructorParameters);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(428);
match(LPAREN);
setState(437);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -9223372036854775740L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 1688853089910865L) != 0)) {
{
setState(429);
primaryConstructorParameter();
setState(434);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(430);
match(COMMA);
setState(431);
primaryConstructorParameter();
}
}
setState(436);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(439);
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 PrimaryConstructorParameterContext extends ParserRuleContext {
public Token valOrVar;
public AnnotationsContext annotations() {
return getRuleContext(AnnotationsContext.class,0);
}
public SimpleIdentifierContext simpleIdentifier() {
return getRuleContext(SimpleIdentifierContext.class,0);
}
public TerminalNode COLON() { return getToken(FeatherParser.COLON, 0); }
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public DocumentationContext documentation() {
return getRuleContext(DocumentationContext.class,0);
}
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public TerminalNode ELIPSIS() { return getToken(FeatherParser.ELIPSIS, 0); }
public TerminalNode VAL() { return getToken(FeatherParser.VAL, 0); }
public TerminalNode VAR() { return getToken(FeatherParser.VAR, 0); }
public PrimaryConstructorParameterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primaryConstructorParameter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterPrimaryConstructorParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitPrimaryConstructorParameter(this);
}
}
public final PrimaryConstructorParameterContext primaryConstructorParameter() throws RecognitionException {
PrimaryConstructorParameterContext _localctx = new PrimaryConstructorParameterContext(_ctx, getState());
enterRule(_localctx, 32, RULE_primaryConstructorParameter);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(442);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Documentation) {
{
setState(441);
documentation();
}
}
setState(444);
annotations();
setState(446);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==VAL || _la==VAR) {
{
setState(445);
((PrimaryConstructorParameterContext)_localctx).valOrVar = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==VAL || _la==VAR) ) {
((PrimaryConstructorParameterContext)_localctx).valOrVar = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(451);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(448);
match(NL);
}
}
setState(453);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(454);
simpleIdentifier();
setState(455);
match(COLON);
setState(456);
type();
setState(458);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ELIPSIS) {
{
setState(457);
match(ELIPSIS);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ExtendsListContext extends ParserRuleContext {
public List<ExtendsSpecifierContext> extendsSpecifier() {
return getRuleContexts(ExtendsSpecifierContext.class);
}
public ExtendsSpecifierContext extendsSpecifier(int i) {
return getRuleContext(ExtendsSpecifierContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(FeatherParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(FeatherParser.COMMA, i);
}
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public ExtendsListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_extendsList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterExtendsList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitExtendsList(this);
}
}
public final ExtendsListContext extendsList() throws RecognitionException {
ExtendsListContext _localctx = new ExtendsListContext(_ctx, getState());
enterRule(_localctx, 34, RULE_extendsList);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(460);
extendsSpecifier();
setState(477);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,40,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(464);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(461);
match(NL);
}
}
setState(466);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(467);
match(COMMA);
setState(471);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(468);
match(NL);
}
}
setState(473);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(474);
extendsSpecifier();
}
}
}
setState(479);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,40,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ExtendsSpecifierContext extends ParserRuleContext {
public ConstructorInvocationContext extends_;
public SimpleIdentifierContext implements_;
public ConstructorInvocationContext constructorInvocation() {
return getRuleContext(ConstructorInvocationContext.class,0);
}
public SimpleIdentifierContext simpleIdentifier() {
return getRuleContext(SimpleIdentifierContext.class,0);
}
public ExtendsSpecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_extendsSpecifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterExtendsSpecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitExtendsSpecifier(this);
}
}
public final ExtendsSpecifierContext extendsSpecifier() throws RecognitionException {
ExtendsSpecifierContext _localctx = new ExtendsSpecifierContext(_ctx, getState());
enterRule(_localctx, 36, RULE_extendsSpecifier);
try {
setState(482);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,41,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(480);
((ExtendsSpecifierContext)_localctx).extends_ = constructorInvocation();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(481);
((ExtendsSpecifierContext)_localctx).implements_ = simpleIdentifier();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ConstructorInvocationContext extends ParserRuleContext {
public SimpleIdentifierContext superclass;
public CallSuffixContext callSuffix() {
return getRuleContext(CallSuffixContext.class,0);
}
public SimpleIdentifierContext simpleIdentifier() {
return getRuleContext(SimpleIdentifierContext.class,0);
}
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public ConstructorInvocationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constructorInvocation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterConstructorInvocation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitConstructorInvocation(this);
}
}
public final ConstructorInvocationContext constructorInvocation() throws RecognitionException {
ConstructorInvocationContext _localctx = new ConstructorInvocationContext(_ctx, getState());
enterRule(_localctx, 38, RULE_constructorInvocation);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(484);
((ConstructorInvocationContext)_localctx).superclass = simpleIdentifier();
setState(488);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(485);
match(NL);
}
}
setState(490);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(491);
callSuffix();
}
}
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 LCURL() { return getToken(FeatherParser.LCURL, 0); }
public TerminalNode RCURL() { return getToken(FeatherParser.RCURL, 0); }
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public EnumValuesContext enumValues() {
return getRuleContext(EnumValuesContext.class,0);
}
public List<ClassMemberDeclarationsContext> classMemberDeclarations() {
return getRuleContexts(ClassMemberDeclarationsContext.class);
}
public ClassMemberDeclarationsContext classMemberDeclarations(int i) {
return getRuleContext(ClassMemberDeclarationsContext.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 FeatherParserListener ) ((FeatherParserListener)listener).enterClassBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitClassBody(this);
}
}
public final ClassBodyContext classBody() throws RecognitionException {
ClassBodyContext _localctx = new ClassBodyContext(_ctx, getState());
enterRule(_localctx, 40, RULE_classBody);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(493);
match(LCURL);
setState(497);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,43,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(494);
match(NL);
}
}
}
setState(499);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,43,_ctx);
}
setState(501);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) {
case 1:
{
setState(500);
enumValues();
}
break;
}
setState(506);
_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(503);
match(NL);
}
}
}
setState(508);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,45,_ctx);
}
setState(512);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==Documentation || _la==ABSTRACT || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 2251806331110979L) != 0)) {
{
{
setState(509);
classMemberDeclarations();
}
}
setState(514);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(518);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(515);
match(NL);
}
}
setState(520);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(521);
match(RCURL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class EnumValuesContext extends ParserRuleContext {
public List<EnumValueContext> enumValue() {
return getRuleContexts(EnumValueContext.class);
}
public EnumValueContext enumValue(int i) {
return getRuleContext(EnumValueContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(FeatherParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(FeatherParser.COMMA, i);
}
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public TerminalNode SEMICOLON() { return getToken(FeatherParser.SEMICOLON, 0); }
public EnumValuesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumValues; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterEnumValues(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitEnumValues(this);
}
}
public final EnumValuesContext enumValues() throws RecognitionException {
EnumValuesContext _localctx = new EnumValuesContext(_ctx, getState());
enterRule(_localctx, 42, RULE_enumValues);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(523);
enumValue();
setState(540);
_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(527);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(524);
match(NL);
}
}
setState(529);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(530);
match(COMMA);
setState(534);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(531);
match(NL);
}
}
setState(536);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(537);
enumValue();
}
}
}
setState(542);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,50,_ctx);
}
setState(546);
_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(543);
match(NL);
}
}
}
setState(548);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,51,_ctx);
}
setState(550);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SEMICOLON) {
{
setState(549);
match(SEMICOLON);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class EnumValueContext extends ParserRuleContext {
public SimpleIdentifierContext name;
public EnumArgumentsContext enumArguments() {
return getRuleContext(EnumArgumentsContext.class,0);
}
public SimpleIdentifierContext simpleIdentifier() {
return getRuleContext(SimpleIdentifierContext.class,0);
}
public EnumValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterEnumValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitEnumValue(this);
}
}
public final EnumValueContext enumValue() throws RecognitionException {
EnumValueContext _localctx = new EnumValueContext(_ctx, getState());
enterRule(_localctx, 44, RULE_enumValue);
try {
enterOuterAlt(_localctx, 1);
{
setState(552);
((EnumValueContext)_localctx).name = simpleIdentifier();
setState(553);
enumArguments();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class EnumArgumentsContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(FeatherParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(FeatherParser.RPAREN, 0); }
public List<ValueArgumentContext> valueArgument() {
return getRuleContexts(ValueArgumentContext.class);
}
public ValueArgumentContext valueArgument(int i) {
return getRuleContext(ValueArgumentContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(FeatherParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(FeatherParser.COMMA, i);
}
public EnumArgumentsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumArguments; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterEnumArguments(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitEnumArguments(this);
}
}
public final EnumArgumentsContext enumArguments() throws RecognitionException {
EnumArgumentsContext _localctx = new EnumArgumentsContext(_ctx, getState());
enterRule(_localctx, 46, RULE_enumArguments);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(567);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(555);
match(LPAREN);
setState(564);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -4611686007438310848L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 10009950596138199L) != 0)) {
{
setState(556);
valueArgument();
setState(561);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(557);
match(COMMA);
setState(558);
valueArgument();
}
}
setState(563);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(566);
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 TypeArgumentsContext extends ParserRuleContext {
public TerminalNode LANGLE() { return getToken(FeatherParser.LANGLE, 0); }
public List<TypeProjectionContext> typeProjection() {
return getRuleContexts(TypeProjectionContext.class);
}
public TypeProjectionContext typeProjection(int i) {
return getRuleContext(TypeProjectionContext.class,i);
}
public TerminalNode RANGLE() { return getToken(FeatherParser.RANGLE, 0); }
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public List<TerminalNode> COMMA() { return getTokens(FeatherParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(FeatherParser.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 FeatherParserListener ) ((FeatherParserListener)listener).enterTypeArguments(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitTypeArguments(this);
}
}
public final TypeArgumentsContext typeArguments() throws RecognitionException {
TypeArgumentsContext _localctx = new TypeArgumentsContext(_ctx, getState());
enterRule(_localctx, 48, RULE_typeArguments);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(569);
match(LANGLE);
setState(573);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(570);
match(NL);
}
}
setState(575);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(576);
typeProjection();
setState(587);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,58,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(580);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(577);
match(NL);
}
}
setState(582);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(583);
match(COMMA);
setState(584);
typeProjection();
}
}
}
setState(589);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,58,_ctx);
}
setState(593);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(590);
match(NL);
}
}
setState(595);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(596);
match(RANGLE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TypeProjectionContext extends ParserRuleContext {
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public TerminalNode MULT() { return getToken(FeatherParser.MULT, 0); }
public TypeProjectionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeProjection; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterTypeProjection(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitTypeProjection(this);
}
}
public final TypeProjectionContext typeProjection() throws RecognitionException {
TypeProjectionContext _localctx = new TypeProjectionContext(_ctx, getState());
enterRule(_localctx, 50, RULE_typeProjection);
try {
setState(600);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LPAREN:
case CATCH:
case CONSTRUCTOR:
case ENUM:
case FINALLY:
case IMPORT:
case LIBRARY:
case Identifier:
enterOuterAlt(_localctx, 1);
{
setState(598);
type();
}
break;
case MULT:
enterOuterAlt(_localctx, 2);
{
setState(599);
match(MULT);
}
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 TypeContext extends ParserRuleContext {
public NonFunctionTypeContext nonFunctionType() {
return getRuleContext(NonFunctionTypeContext.class,0);
}
public FunctionTypeContext functionType() {
return getRuleContext(FunctionTypeContext.class,0);
}
public TypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_type; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitType(this);
}
}
public final TypeContext type() throws RecognitionException {
TypeContext _localctx = new TypeContext(_ctx, getState());
enterRule(_localctx, 52, RULE_type);
try {
setState(604);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CATCH:
case CONSTRUCTOR:
case ENUM:
case FINALLY:
case IMPORT:
case LIBRARY:
case Identifier:
enterOuterAlt(_localctx, 1);
{
setState(602);
nonFunctionType();
}
break;
case LPAREN:
enterOuterAlt(_localctx, 2);
{
setState(603);
functionType();
}
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 NonFunctionTypeContext extends ParserRuleContext {
public SimpleUserTypeContext simpleUserType() {
return getRuleContext(SimpleUserTypeContext.class,0);
}
public GenericSpecContext genericSpec() {
return getRuleContext(GenericSpecContext.class,0);
}
public NonFunctionTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_nonFunctionType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterNonFunctionType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitNonFunctionType(this);
}
}
public final NonFunctionTypeContext nonFunctionType() throws RecognitionException {
NonFunctionTypeContext _localctx = new NonFunctionTypeContext(_ctx, getState());
enterRule(_localctx, 54, RULE_nonFunctionType);
try {
enterOuterAlt(_localctx, 1);
{
setState(606);
simpleUserType();
setState(608);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) {
case 1:
{
setState(607);
genericSpec();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FunctionTypeContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(FeatherParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(FeatherParser.RPAREN, 0); }
public FunctionTypeReturnContext functionTypeReturn() {
return getRuleContext(FunctionTypeReturnContext.class,0);
}
public List<TypeContext> type() {
return getRuleContexts(TypeContext.class);
}
public TypeContext type(int i) {
return getRuleContext(TypeContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(FeatherParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(FeatherParser.COMMA, i);
}
public FunctionTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_functionType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterFunctionType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitFunctionType(this);
}
}
public final FunctionTypeContext functionType() throws RecognitionException {
FunctionTypeContext _localctx = new FunctionTypeContext(_ctx, getState());
enterRule(_localctx, 56, RULE_functionType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(610);
match(LPAREN);
setState(619);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LPAREN || _la==CATCH || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 562949961842769L) != 0)) {
{
setState(611);
type();
setState(616);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(612);
match(COMMA);
setState(613);
type();
}
}
setState(618);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(621);
match(RPAREN);
setState(622);
functionTypeReturn();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FunctionTypeReturnContext extends ParserRuleContext {
public TypeContext returnType;
public TerminalNode ARROW() { return getToken(FeatherParser.ARROW, 0); }
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public FunctionTypeReturnContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_functionTypeReturn; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterFunctionTypeReturn(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitFunctionTypeReturn(this);
}
}
public final FunctionTypeReturnContext functionTypeReturn() throws RecognitionException {
FunctionTypeReturnContext _localctx = new FunctionTypeReturnContext(_ctx, getState());
enterRule(_localctx, 58, RULE_functionTypeReturn);
try {
enterOuterAlt(_localctx, 1);
{
setState(626);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) {
case 1:
{
setState(624);
match(ARROW);
setState(625);
((FunctionTypeReturnContext)_localctx).returnType = type();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GenericSpecContext extends ParserRuleContext {
public TerminalNode LANGLE() { return getToken(FeatherParser.LANGLE, 0); }
public List<NonFunctionTypeContext> nonFunctionType() {
return getRuleContexts(NonFunctionTypeContext.class);
}
public NonFunctionTypeContext nonFunctionType(int i) {
return getRuleContext(NonFunctionTypeContext.class,i);
}
public TerminalNode RANGLE() { return getToken(FeatherParser.RANGLE, 0); }
public List<TerminalNode> COMMA() { return getTokens(FeatherParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(FeatherParser.COMMA, i);
}
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public GenericSpecContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_genericSpec; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterGenericSpec(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitGenericSpec(this);
}
}
public final GenericSpecContext genericSpec() throws RecognitionException {
GenericSpecContext _localctx = new GenericSpecContext(_ctx, getState());
enterRule(_localctx, 60, RULE_genericSpec);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(628);
match(LANGLE);
setState(629);
nonFunctionType();
setState(640);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,67,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(633);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(630);
match(NL);
}
}
setState(635);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(636);
match(COMMA);
setState(637);
nonFunctionType();
}
}
}
setState(642);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,67,_ctx);
}
setState(646);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(643);
match(NL);
}
}
setState(648);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(649);
match(RANGLE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SimpleUserTypeContext extends ParserRuleContext {
public SimpleIdentifierContext simpleIdentifier() {
return getRuleContext(SimpleIdentifierContext.class,0);
}
public SimpleUserTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simpleUserType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterSimpleUserType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitSimpleUserType(this);
}
}
public final SimpleUserTypeContext simpleUserType() throws RecognitionException {
SimpleUserTypeContext _localctx = new SimpleUserTypeContext(_ctx, getState());
enterRule(_localctx, 62, RULE_simpleUserType);
try {
enterOuterAlt(_localctx, 1);
{
setState(651);
simpleIdentifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ClassMemberDeclarationsContext extends ParserRuleContext {
public SecondaryConstructorContext secondaryConstructor() {
return getRuleContext(SecondaryConstructorContext.class,0);
}
public FieldDeclarationContext fieldDeclaration() {
return getRuleContext(FieldDeclarationContext.class,0);
}
public MethodDeclarationContext methodDeclaration() {
return getRuleContext(MethodDeclarationContext.class,0);
}
public InitBlockContext initBlock() {
return getRuleContext(InitBlockContext.class,0);
}
public List<AnysemiContext> anysemi() {
return getRuleContexts(AnysemiContext.class);
}
public AnysemiContext anysemi(int i) {
return getRuleContext(AnysemiContext.class,i);
}
public ClassMemberDeclarationsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classMemberDeclarations; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterClassMemberDeclarations(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitClassMemberDeclarations(this);
}
}
public final ClassMemberDeclarationsContext classMemberDeclarations() throws RecognitionException {
ClassMemberDeclarationsContext _localctx = new ClassMemberDeclarationsContext(_ctx, getState());
enterRule(_localctx, 64, RULE_classMemberDeclarations);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(657);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,69,_ctx) ) {
case 1:
{
setState(653);
secondaryConstructor();
}
break;
case 2:
{
setState(654);
fieldDeclaration();
}
break;
case 3:
{
setState(655);
methodDeclaration();
}
break;
case 4:
{
setState(656);
initBlock();
}
break;
}
setState(662);
_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(659);
anysemi();
}
}
}
setState(664);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,70,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SecondaryConstructorContext extends ParserRuleContext {
public SecondaryConstructorDescriptionContext secondaryConstructorDescription() {
return getRuleContext(SecondaryConstructorDescriptionContext.class,0);
}
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public SecondaryConstructorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_secondaryConstructor; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterSecondaryConstructor(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitSecondaryConstructor(this);
}
}
public final SecondaryConstructorContext secondaryConstructor() throws RecognitionException {
SecondaryConstructorContext _localctx = new SecondaryConstructorContext(_ctx, getState());
enterRule(_localctx, 66, RULE_secondaryConstructor);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(665);
secondaryConstructorDescription();
setState(669);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,71,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(666);
match(NL);
}
}
}
setState(671);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,71,_ctx);
}
setState(673);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LCURL) {
{
setState(672);
block();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SecondaryConstructorDescriptionContext extends ParserRuleContext {
public AnnotationsContext annotations() {
return getRuleContext(AnnotationsContext.class,0);
}
public TerminalNode CONSTRUCTOR() { return getToken(FeatherParser.CONSTRUCTOR, 0); }
public SecondaryConstructorParametersContext secondaryConstructorParameters() {
return getRuleContext(SecondaryConstructorParametersContext.class,0);
}
public DocumentationContext documentation() {
return getRuleContext(DocumentationContext.class,0);
}
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public TerminalNode COLON() { return getToken(FeatherParser.COLON, 0); }
public ConstructorDelegationCallContext constructorDelegationCall() {
return getRuleContext(ConstructorDelegationCallContext.class,0);
}
public SecondaryConstructorDescriptionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_secondaryConstructorDescription; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterSecondaryConstructorDescription(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitSecondaryConstructorDescription(this);
}
}
public final SecondaryConstructorDescriptionContext secondaryConstructorDescription() throws RecognitionException {
SecondaryConstructorDescriptionContext _localctx = new SecondaryConstructorDescriptionContext(_ctx, getState());
enterRule(_localctx, 68, RULE_secondaryConstructorDescription);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(676);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Documentation) {
{
setState(675);
documentation();
}
}
setState(678);
annotations();
setState(679);
match(CONSTRUCTOR);
setState(683);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(680);
match(NL);
}
}
setState(685);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(686);
secondaryConstructorParameters();
setState(701);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) {
case 1:
{
setState(690);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(687);
match(NL);
}
}
setState(692);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(693);
match(COLON);
setState(697);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(694);
match(NL);
}
}
setState(699);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(700);
constructorDelegationCall();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SecondaryConstructorParametersContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(FeatherParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(FeatherParser.RPAREN, 0); }
public List<MethodParameterContext> methodParameter() {
return getRuleContexts(MethodParameterContext.class);
}
public MethodParameterContext methodParameter(int i) {
return getRuleContext(MethodParameterContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(FeatherParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(FeatherParser.COMMA, i);
}
public SecondaryConstructorParametersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_secondaryConstructorParameters; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterSecondaryConstructorParameters(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitSecondaryConstructorParameters(this);
}
}
public final SecondaryConstructorParametersContext secondaryConstructorParameters() throws RecognitionException {
SecondaryConstructorParametersContext _localctx = new SecondaryConstructorParametersContext(_ctx, getState());
enterRule(_localctx, 70, RULE_secondaryConstructorParameters);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(703);
match(LPAREN);
setState(712);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 63)) & ~0x3f) == 0 && ((1L << (_la - 63)) & 2251799847371077L) != 0)) {
{
setState(704);
methodParameter();
setState(709);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(705);
match(COMMA);
setState(706);
methodParameter();
}
}
setState(711);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(714);
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 ConstructorDelegationCallContext extends ParserRuleContext {
public TerminalNode THIS() { return getToken(FeatherParser.THIS, 0); }
public ValueArgumentsContext valueArguments() {
return getRuleContext(ValueArgumentsContext.class,0);
}
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public TerminalNode SUPER() { return getToken(FeatherParser.SUPER, 0); }
public ConstructorDelegationCallContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constructorDelegationCall; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterConstructorDelegationCall(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitConstructorDelegationCall(this);
}
}
public final ConstructorDelegationCallContext constructorDelegationCall() throws RecognitionException {
ConstructorDelegationCallContext _localctx = new ConstructorDelegationCallContext(_ctx, getState());
enterRule(_localctx, 72, RULE_constructorDelegationCall);
int _la;
try {
setState(732);
_errHandler.sync(this);
switch (_input.LA(1)) {
case THIS:
enterOuterAlt(_localctx, 1);
{
setState(716);
match(THIS);
setState(720);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(717);
match(NL);
}
}
setState(722);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(723);
valueArguments();
}
break;
case SUPER:
enterOuterAlt(_localctx, 2);
{
setState(724);
match(SUPER);
setState(728);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(725);
match(NL);
}
}
setState(730);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(731);
valueArguments();
}
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 FieldDeclarationContext extends ParserRuleContext {
public FieldDeclarationDescriptionContext fieldDeclarationDescription() {
return getRuleContext(FieldDeclarationDescriptionContext.class,0);
}
public TerminalNode ASSIGNMENT() { return getToken(FeatherParser.ASSIGNMENT, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public FieldDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fieldDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterFieldDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitFieldDeclaration(this);
}
}
public final FieldDeclarationContext fieldDeclaration() throws RecognitionException {
FieldDeclarationContext _localctx = new FieldDeclarationContext(_ctx, getState());
enterRule(_localctx, 74, RULE_fieldDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(734);
fieldDeclarationDescription();
setState(749);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) {
case 1:
{
setState(738);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(735);
match(NL);
}
}
setState(740);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(741);
match(ASSIGNMENT);
setState(745);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(742);
match(NL);
}
}
setState(747);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(748);
expression();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FieldDeclarationDescriptionContext extends ParserRuleContext {
public Token def;
public AnnotationsContext annotations() {
return getRuleContext(AnnotationsContext.class,0);
}
public TerminalNode VAR() { return getToken(FeatherParser.VAR, 0); }
public TerminalNode VAL() { return getToken(FeatherParser.VAL, 0); }
public VariableDeclarationContext variableDeclaration() {
return getRuleContext(VariableDeclarationContext.class,0);
}
public DocumentationContext documentation() {
return getRuleContext(DocumentationContext.class,0);
}
public TerminalNode STATIC() { return getToken(FeatherParser.STATIC, 0); }
public TerminalNode CLASS() { return getToken(FeatherParser.CLASS, 0); }
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public FieldDeclarationDescriptionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fieldDeclarationDescription; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterFieldDeclarationDescription(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitFieldDeclarationDescription(this);
}
}
public final FieldDeclarationDescriptionContext fieldDeclarationDescription() throws RecognitionException {
FieldDeclarationDescriptionContext _localctx = new FieldDeclarationDescriptionContext(_ctx, getState());
enterRule(_localctx, 76, RULE_fieldDeclarationDescription);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(752);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Documentation) {
{
setState(751);
documentation();
}
}
setState(754);
annotations();
setState(756);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==CLASS || _la==STATIC) {
{
setState(755);
_la = _input.LA(1);
if ( !(_la==CLASS || _la==STATIC) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(758);
((FieldDeclarationDescriptionContext)_localctx).def = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==VAL || _la==VAR) ) {
((FieldDeclarationDescriptionContext)_localctx).def = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
{
setState(762);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(759);
match(NL);
}
}
setState(764);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(765);
variableDeclaration();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AnnotationsContext extends ParserRuleContext {
public List<AnnotationContext> annotation() {
return getRuleContexts(AnnotationContext.class);
}
public AnnotationContext annotation(int i) {
return getRuleContext(AnnotationContext.class,i);
}
public AnnotationsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotations; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterAnnotations(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitAnnotations(this);
}
}
public final AnnotationsContext annotations() throws RecognitionException {
AnnotationsContext _localctx = new AnnotationsContext(_ctx, getState());
enterRule(_localctx, 78, RULE_annotations);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(770);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LabelReference) {
{
{
setState(767);
annotation();
}
}
setState(772);
_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 AnnotationContext extends ParserRuleContext {
public TerminalNode LabelReference() { return getToken(FeatherParser.LabelReference, 0); }
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public AnnotationValuesContext annotationValues() {
return getRuleContext(AnnotationValuesContext.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 FeatherParserListener ) ((FeatherParserListener)listener).enterAnnotation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitAnnotation(this);
}
}
public final AnnotationContext annotation() throws RecognitionException {
AnnotationContext _localctx = new AnnotationContext(_ctx, getState());
enterRule(_localctx, 80, RULE_annotation);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(773);
match(LabelReference);
setState(777);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,90,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(774);
match(NL);
}
}
}
setState(779);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,90,_ctx);
}
setState(781);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(780);
annotationValues();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AnnotationValuesContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(FeatherParser.LPAREN, 0); }
public List<AnnotationValueContext> annotationValue() {
return getRuleContexts(AnnotationValueContext.class);
}
public AnnotationValueContext annotationValue(int i) {
return getRuleContext(AnnotationValueContext.class,i);
}
public TerminalNode RPAREN() { return getToken(FeatherParser.RPAREN, 0); }
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public List<TerminalNode> COMMA() { return getTokens(FeatherParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(FeatherParser.COMMA, i);
}
public AnnotationValuesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotationValues; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterAnnotationValues(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitAnnotationValues(this);
}
}
public final AnnotationValuesContext annotationValues() throws RecognitionException {
AnnotationValuesContext _localctx = new AnnotationValuesContext(_ctx, getState());
enterRule(_localctx, 82, RULE_annotationValues);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(783);
match(LPAREN);
setState(787);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(784);
match(NL);
}
}
setState(789);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(790);
annotationValue();
setState(807);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,95,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(794);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(791);
match(NL);
}
}
setState(796);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(797);
match(COMMA);
setState(801);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(798);
match(NL);
}
}
setState(803);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(804);
annotationValue();
}
}
}
setState(809);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,95,_ctx);
}
setState(813);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(810);
match(NL);
}
}
setState(815);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(816);
match(RPAREN);
setState(820);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,97,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(817);
match(NL);
}
}
}
setState(822);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,97,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AnnotationValueContext extends ParserRuleContext {
public SimpleIdentifierContext simpleIdentifier() {
return getRuleContext(SimpleIdentifierContext.class,0);
}
public TerminalNode ASSIGNMENT() { return getToken(FeatherParser.ASSIGNMENT, 0); }
public LiteralConstantContext literalConstant() {
return getRuleContext(LiteralConstantContext.class,0);
}
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public AnnotationValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotationValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterAnnotationValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitAnnotationValue(this);
}
}
public final AnnotationValueContext annotationValue() throws RecognitionException {
AnnotationValueContext _localctx = new AnnotationValueContext(_ctx, getState());
enterRule(_localctx, 84, RULE_annotationValue);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(823);
simpleIdentifier();
setState(827);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(824);
match(NL);
}
}
setState(829);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(830);
match(ASSIGNMENT);
setState(834);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(831);
match(NL);
}
}
setState(836);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(837);
literalConstant();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class InitBlockContext extends ParserRuleContext {
public TerminalNode INIT() { return getToken(FeatherParser.INIT, 0); }
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public InitBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_initBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterInitBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitInitBlock(this);
}
}
public final InitBlockContext initBlock() throws RecognitionException {
InitBlockContext _localctx = new InitBlockContext(_ctx, getState());
enterRule(_localctx, 86, RULE_initBlock);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(839);
match(INIT);
setState(843);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(840);
match(NL);
}
}
setState(845);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(846);
block();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class VariableDeclarationContext extends ParserRuleContext {
public SimpleIdentifierContext name;
public SimpleIdentifierContext simpleIdentifier() {
return getRuleContext(SimpleIdentifierContext.class,0);
}
public TerminalNode COLON() { return getToken(FeatherParser.COLON, 0); }
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public VariableDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_variableDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterVariableDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitVariableDeclaration(this);
}
}
public final VariableDeclarationContext variableDeclaration() throws RecognitionException {
VariableDeclarationContext _localctx = new VariableDeclarationContext(_ctx, getState());
enterRule(_localctx, 88, RULE_variableDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(848);
((VariableDeclarationContext)_localctx).name = simpleIdentifier();
setState(851);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLON) {
{
setState(849);
match(COLON);
setState(850);
type();
}
}
}
}
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 MethodDescriptionContext methodDescription() {
return getRuleContext(MethodDescriptionContext.class,0);
}
public MethodBodyContext methodBody() {
return getRuleContext(MethodBodyContext.class,0);
}
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public MethodDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_methodDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterMethodDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitMethodDeclaration(this);
}
}
public final MethodDeclarationContext methodDeclaration() throws RecognitionException {
MethodDeclarationContext _localctx = new MethodDeclarationContext(_ctx, getState());
enterRule(_localctx, 90, RULE_methodDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(853);
methodDescription();
setState(861);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,103,_ctx) ) {
case 1:
{
setState(857);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(854);
match(NL);
}
}
setState(859);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(860);
methodBody();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MethodDescriptionContext extends ParserRuleContext {
public SimpleIdentifierContext name;
public AnnotationsContext annotations() {
return getRuleContext(AnnotationsContext.class,0);
}
public MethodValueParametersContext methodValueParameters() {
return getRuleContext(MethodValueParametersContext.class,0);
}
public TerminalNode FUN() { return getToken(FeatherParser.FUN, 0); }
public TerminalNode FUNC() { return getToken(FeatherParser.FUNC, 0); }
public TerminalNode METH() { return getToken(FeatherParser.METH, 0); }
public SimpleIdentifierContext simpleIdentifier() {
return getRuleContext(SimpleIdentifierContext.class,0);
}
public DocumentationContext documentation() {
return getRuleContext(DocumentationContext.class,0);
}
public TerminalNode STATIC() { return getToken(FeatherParser.STATIC, 0); }
public TerminalNode ABSTRACT() { return getToken(FeatherParser.ABSTRACT, 0); }
public TerminalNode OVERRIDE() { return getToken(FeatherParser.OVERRIDE, 0); }
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public TerminalNode COLON() { return getToken(FeatherParser.COLON, 0); }
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public TerminalNode OPEN() { return getToken(FeatherParser.OPEN, 0); }
public TerminalNode FINAL() { return getToken(FeatherParser.FINAL, 0); }
public MethodDescriptionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_methodDescription; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterMethodDescription(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitMethodDescription(this);
}
}
public final MethodDescriptionContext methodDescription() throws RecognitionException {
MethodDescriptionContext _localctx = new MethodDescriptionContext(_ctx, getState());
enterRule(_localctx, 92, RULE_methodDescription);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(864);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Documentation) {
{
setState(863);
documentation();
}
}
setState(866);
annotations();
setState(868);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==STATIC) {
{
setState(867);
match(STATIC);
}
}
setState(871);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FINAL || _la==OPEN) {
{
setState(870);
_la = _input.LA(1);
if ( !(_la==FINAL || _la==OPEN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(874);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ABSTRACT) {
{
setState(873);
match(ABSTRACT);
}
}
setState(877);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OVERRIDE) {
{
setState(876);
match(OVERRIDE);
}
}
setState(879);
_la = _input.LA(1);
if ( !(((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 2051L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(883);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(880);
match(NL);
}
}
setState(885);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(886);
((MethodDescriptionContext)_localctx).name = simpleIdentifier();
setState(890);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(887);
match(NL);
}
}
setState(892);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(893);
methodValueParameters();
setState(908);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,113,_ctx) ) {
case 1:
{
setState(897);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(894);
match(NL);
}
}
setState(899);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(900);
match(COLON);
setState(904);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(901);
match(NL);
}
}
setState(906);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(907);
type();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MethodValueParametersContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(FeatherParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(FeatherParser.RPAREN, 0); }
public List<MethodParameterContext> methodParameter() {
return getRuleContexts(MethodParameterContext.class);
}
public MethodParameterContext methodParameter(int i) {
return getRuleContext(MethodParameterContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(FeatherParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(FeatherParser.COMMA, i);
}
public MethodValueParametersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_methodValueParameters; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterMethodValueParameters(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitMethodValueParameters(this);
}
}
public final MethodValueParametersContext methodValueParameters() throws RecognitionException {
MethodValueParametersContext _localctx = new MethodValueParametersContext(_ctx, getState());
enterRule(_localctx, 94, RULE_methodValueParameters);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(910);
match(LPAREN);
setState(919);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 63)) & ~0x3f) == 0 && ((1L << (_la - 63)) & 2251799847371077L) != 0)) {
{
setState(911);
methodParameter();
setState(916);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(912);
match(COMMA);
setState(913);
methodParameter();
}
}
setState(918);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(921);
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 MethodParameterContext extends ParserRuleContext {
public SimpleIdentifierContext simpleIdentifier() {
return getRuleContext(SimpleIdentifierContext.class,0);
}
public TerminalNode COLON() { return getToken(FeatherParser.COLON, 0); }
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public TerminalNode ELIPSIS() { return getToken(FeatherParser.ELIPSIS, 0); }
public MethodParameterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_methodParameter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterMethodParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitMethodParameter(this);
}
}
public final MethodParameterContext methodParameter() throws RecognitionException {
MethodParameterContext _localctx = new MethodParameterContext(_ctx, getState());
enterRule(_localctx, 96, RULE_methodParameter);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(923);
simpleIdentifier();
setState(924);
match(COLON);
setState(925);
type();
setState(927);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ELIPSIS) {
{
setState(926);
match(ELIPSIS);
}
}
}
}
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 MethodBlockContext methodBlock() {
return getRuleContext(MethodBlockContext.class,0);
}
public TerminalNode ASSIGNMENT() { return getToken(FeatherParser.ASSIGNMENT, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
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 FeatherParserListener ) ((FeatherParserListener)listener).enterMethodBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitMethodBody(this);
}
}
public final MethodBodyContext methodBody() throws RecognitionException {
MethodBodyContext _localctx = new MethodBodyContext(_ctx, getState());
enterRule(_localctx, 98, RULE_methodBody);
int _la;
try {
setState(938);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LCURL:
enterOuterAlt(_localctx, 1);
{
setState(929);
methodBlock();
}
break;
case ASSIGNMENT:
enterOuterAlt(_localctx, 2);
{
setState(930);
match(ASSIGNMENT);
setState(934);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(931);
match(NL);
}
}
setState(936);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(937);
expression();
}
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 MethodBlockContext extends ParserRuleContext {
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public MethodBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_methodBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterMethodBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitMethodBlock(this);
}
}
public final MethodBlockContext methodBlock() throws RecognitionException {
MethodBlockContext _localctx = new MethodBlockContext(_ctx, getState());
enterRule(_localctx, 100, RULE_methodBlock);
try {
enterOuterAlt(_localctx, 1);
{
setState(940);
block();
}
}
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 LCURL() { return getToken(FeatherParser.LCURL, 0); }
public StatementsContext statements() {
return getRuleContext(StatementsContext.class,0);
}
public TerminalNode RCURL() { return getToken(FeatherParser.RCURL, 0); }
public BlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_block; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitBlock(this);
}
}
public final BlockContext block() throws RecognitionException {
BlockContext _localctx = new BlockContext(_ctx, getState());
enterRule(_localctx, 102, RULE_block);
try {
enterOuterAlt(_localctx, 1);
{
setState(942);
match(LCURL);
setState(943);
statements();
setState(944);
match(RCURL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ControlStructureBodyContext extends ParserRuleContext {
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ControlStructureBodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_controlStructureBody; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterControlStructureBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitControlStructureBody(this);
}
}
public final ControlStructureBodyContext controlStructureBody() throws RecognitionException {
ControlStructureBodyContext _localctx = new ControlStructureBodyContext(_ctx, getState());
enterRule(_localctx, 104, RULE_controlStructureBody);
try {
setState(948);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LCURL:
enterOuterAlt(_localctx, 1);
{
setState(946);
block();
}
break;
case LPAREN:
case ADD:
case SUB:
case INCR:
case DECR:
case EXCL:
case COLON_COLON:
case BREAK:
case CATCH:
case CONSTRUCTOR:
case CONTINUE:
case DO:
case ENUM:
case FINALLY:
case FOR:
case IF:
case IMPORT:
case LIBRARY:
case RETURN:
case SUPER:
case THIS:
case THROW:
case TRY:
case WHILE:
case WITH:
case QUOTE_OPEN:
case TRIPLE_QUOTE_OPEN:
case COMMAND_OPEN:
case FloatLiteral:
case DoubleLiteral:
case LongLiteral:
case ByteLiteral:
case ShortLiteral:
case IntegerLiteral:
case RealLiteral:
case BooleanLiteral:
case NullLiteral:
case Identifier:
case CharacterLiteral:
enterOuterAlt(_localctx, 2);
{
setState(947);
expression();
}
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 StatementsContext extends ParserRuleContext {
public List<AnysemiContext> anysemi() {
return getRuleContexts(AnysemiContext.class);
}
public AnysemiContext anysemi(int i) {
return getRuleContext(AnysemiContext.class,i);
}
public List<StatementContext> statement() {
return getRuleContexts(StatementContext.class);
}
public StatementContext statement(int i) {
return getRuleContext(StatementContext.class,i);
}
public StatementsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_statements; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterStatements(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitStatements(this);
}
}
public final StatementsContext statements() throws RecognitionException {
StatementsContext _localctx = new StatementsContext(_ctx, getState());
enterRule(_localctx, 106, RULE_statements);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(953);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL || _la==SEMICOLON) {
{
{
setState(950);
anysemi();
}
}
setState(955);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(970);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -4611686007438310912L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 10009953817363671L) != 0)) {
{
setState(956);
statement();
setState(967);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL || _la==SEMICOLON) {
{
{
setState(958);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(957);
anysemi();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(960);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,121,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
setState(963);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -4611686007438310912L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 10009953817363671L) != 0)) {
{
setState(962);
statement();
}
}
}
}
setState(969);
_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 StatementContext extends ParserRuleContext {
public LocalVariableDeclarationContext localVariableDeclaration() {
return getRuleContext(LocalVariableDeclarationContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public StatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_statement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitStatement(this);
}
}
public final StatementContext statement() throws RecognitionException {
StatementContext _localctx = new StatementContext(_ctx, getState());
enterRule(_localctx, 108, RULE_statement);
try {
setState(974);
_errHandler.sync(this);
switch (_input.LA(1)) {
case VAL:
case VAR:
enterOuterAlt(_localctx, 1);
{
setState(972);
localVariableDeclaration();
}
break;
case LPAREN:
case ADD:
case SUB:
case INCR:
case DECR:
case EXCL:
case COLON_COLON:
case BREAK:
case CATCH:
case CONSTRUCTOR:
case CONTINUE:
case DO:
case ENUM:
case FINALLY:
case FOR:
case IF:
case IMPORT:
case LIBRARY:
case RETURN:
case SUPER:
case THIS:
case THROW:
case TRY:
case WHILE:
case WITH:
case QUOTE_OPEN:
case TRIPLE_QUOTE_OPEN:
case COMMAND_OPEN:
case FloatLiteral:
case DoubleLiteral:
case LongLiteral:
case ByteLiteral:
case ShortLiteral:
case IntegerLiteral:
case RealLiteral:
case BooleanLiteral:
case NullLiteral:
case Identifier:
case CharacterLiteral:
enterOuterAlt(_localctx, 2);
{
setState(973);
expression();
}
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 LocalVariableDeclarationContext extends ParserRuleContext {
public Token def;
public VariableDeclarationContext variableDeclaration() {
return getRuleContext(VariableDeclarationContext.class,0);
}
public TerminalNode VAR() { return getToken(FeatherParser.VAR, 0); }
public TerminalNode VAL() { return getToken(FeatherParser.VAL, 0); }
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public TerminalNode ASSIGNMENT() { return getToken(FeatherParser.ASSIGNMENT, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
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 FeatherParserListener ) ((FeatherParserListener)listener).enterLocalVariableDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitLocalVariableDeclaration(this);
}
}
public final LocalVariableDeclarationContext localVariableDeclaration() throws RecognitionException {
LocalVariableDeclarationContext _localctx = new LocalVariableDeclarationContext(_ctx, getState());
enterRule(_localctx, 110, RULE_localVariableDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(976);
((LocalVariableDeclarationContext)_localctx).def = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==VAL || _la==VAR) ) {
((LocalVariableDeclarationContext)_localctx).def = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(980);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(977);
match(NL);
}
}
setState(982);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(983);
variableDeclaration();
setState(998);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) {
case 1:
{
setState(987);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(984);
match(NL);
}
}
setState(989);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(990);
match(ASSIGNMENT);
setState(994);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(991);
match(NL);
}
}
setState(996);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(997);
expression();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ThrowStatementContext extends ParserRuleContext {
public TerminalNode THROW() { return getToken(FeatherParser.THROW, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public ThrowStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_throwStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterThrowStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitThrowStatement(this);
}
}
public final ThrowStatementContext throwStatement() throws RecognitionException {
ThrowStatementContext _localctx = new ThrowStatementContext(_ctx, getState());
enterRule(_localctx, 112, RULE_throwStatement);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1000);
match(THROW);
setState(1004);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1001);
match(NL);
}
}
setState(1006);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1007);
expression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ReturnStatementContext extends ParserRuleContext {
public TerminalNode RETURN() { return getToken(FeatherParser.RETURN, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ReturnStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_returnStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterReturnStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitReturnStatement(this);
}
}
public final ReturnStatementContext returnStatement() throws RecognitionException {
ReturnStatementContext _localctx = new ReturnStatementContext(_ctx, getState());
enterRule(_localctx, 114, RULE_returnStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(1009);
match(RETURN);
setState(1011);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,131,_ctx) ) {
case 1:
{
setState(1010);
expression();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ContinueStatementContext extends ParserRuleContext {
public TerminalNode CONTINUE() { return getToken(FeatherParser.CONTINUE, 0); }
public ContinueStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_continueStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterContinueStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitContinueStatement(this);
}
}
public final ContinueStatementContext continueStatement() throws RecognitionException {
ContinueStatementContext _localctx = new ContinueStatementContext(_ctx, getState());
enterRule(_localctx, 116, RULE_continueStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(1013);
match(CONTINUE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class BreakStatementContext extends ParserRuleContext {
public TerminalNode BREAK() { return getToken(FeatherParser.BREAK, 0); }
public BreakStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_breakStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterBreakStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitBreakStatement(this);
}
}
public final BreakStatementContext breakStatement() throws RecognitionException {
BreakStatementContext _localctx = new BreakStatementContext(_ctx, getState());
enterRule(_localctx, 118, RULE_breakStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(1015);
match(BREAK);
}
}
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 bop;
public WhileStatementContext whileStatement() {
return getRuleContext(WhileStatementContext.class,0);
}
public DoWhileStatementContext doWhileStatement() {
return getRuleContext(DoWhileStatementContext.class,0);
}
public ForStatementContext forStatement() {
return getRuleContext(ForStatementContext.class,0);
}
public ContinueStatementContext continueStatement() {
return getRuleContext(ContinueStatementContext.class,0);
}
public BreakStatementContext breakStatement() {
return getRuleContext(BreakStatementContext.class,0);
}
public ReturnStatementContext returnStatement() {
return getRuleContext(ReturnStatementContext.class,0);
}
public List<PostfixCallContext> postfixCall() {
return getRuleContexts(PostfixCallContext.class);
}
public PostfixCallContext postfixCall(int i) {
return getRuleContext(PostfixCallContext.class,i);
}
public List<TerminalNode> ASSIGNMENT() { return getTokens(FeatherParser.ASSIGNMENT); }
public TerminalNode ASSIGNMENT(int i) {
return getToken(FeatherParser.ASSIGNMENT, i);
}
public List<TerminalNode> ADD_ASSIGNMENT() { return getTokens(FeatherParser.ADD_ASSIGNMENT); }
public TerminalNode ADD_ASSIGNMENT(int i) {
return getToken(FeatherParser.ADD_ASSIGNMENT, i);
}
public List<TerminalNode> SUB_ASSIGNMENT() { return getTokens(FeatherParser.SUB_ASSIGNMENT); }
public TerminalNode SUB_ASSIGNMENT(int i) {
return getToken(FeatherParser.SUB_ASSIGNMENT, i);
}
public List<TerminalNode> MULT_ASSIGNMENT() { return getTokens(FeatherParser.MULT_ASSIGNMENT); }
public TerminalNode MULT_ASSIGNMENT(int i) {
return getToken(FeatherParser.MULT_ASSIGNMENT, i);
}
public List<TerminalNode> DIVIDE_ASSIGNMENT() { return getTokens(FeatherParser.DIVIDE_ASSIGNMENT); }
public TerminalNode DIVIDE_ASSIGNMENT(int i) {
return getToken(FeatherParser.DIVIDE_ASSIGNMENT, i);
}
public List<TerminalNode> FLOOR_DIV_ASSIGNMENT() { return getTokens(FeatherParser.FLOOR_DIV_ASSIGNMENT); }
public TerminalNode FLOOR_DIV_ASSIGNMENT(int i) {
return getToken(FeatherParser.FLOOR_DIV_ASSIGNMENT, i);
}
public List<TerminalNode> REM_ASSIGNMENT() { return getTokens(FeatherParser.REM_ASSIGNMENT); }
public TerminalNode REM_ASSIGNMENT(int i) {
return getToken(FeatherParser.REM_ASSIGNMENT, i);
}
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 FeatherParserListener ) ((FeatherParserListener)listener).enterExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitExpression(this);
}
}
public final ExpressionContext expression() throws RecognitionException {
ExpressionContext _localctx = new ExpressionContext(_ctx, getState());
enterRule(_localctx, 120, RULE_expression);
int _la;
try {
int _alt;
setState(1031);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,133,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1017);
whileStatement();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1018);
doWhileStatement();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1019);
forStatement();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1020);
continueStatement();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1021);
breakStatement();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(1022);
returnStatement();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(1023);
postfixCall(0);
setState(1028);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,132,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1024);
((ExpressionContext)_localctx).bop = _input.LT(1);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 8727373545472L) != 0)) ) {
((ExpressionContext)_localctx).bop = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1025);
postfixCall(0);
}
}
}
setState(1030);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,132,_ctx);
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PostfixCallContext extends ParserRuleContext {
public SimpleIdentifierContext methodName;
public DisjunctionContext disjunction() {
return getRuleContext(DisjunctionContext.class,0);
}
public PostfixCallContext postfixCall() {
return getRuleContext(PostfixCallContext.class,0);
}
public TerminalNode COLON() { return getToken(FeatherParser.COLON, 0); }
public CallSuffixContext callSuffix() {
return getRuleContext(CallSuffixContext.class,0);
}
public SimpleIdentifierContext simpleIdentifier() {
return getRuleContext(SimpleIdentifierContext.class,0);
}
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public PostfixCallContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_postfixCall; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterPostfixCall(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitPostfixCall(this);
}
}
public final PostfixCallContext postfixCall() throws RecognitionException {
return postfixCall(0);
}
private PostfixCallContext postfixCall(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
PostfixCallContext _localctx = new PostfixCallContext(_ctx, _parentState);
PostfixCallContext _prevctx = _localctx;
int _startState = 122;
enterRecursionRule(_localctx, 122, RULE_postfixCall, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(1034);
disjunction(0);
}
_ctx.stop = _input.LT(-1);
setState(1049);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,135,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new PostfixCallContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_postfixCall);
setState(1036);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(1037);
match(COLON);
setState(1041);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1038);
match(NL);
}
}
setState(1043);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1044);
((PostfixCallContext)_localctx).methodName = simpleIdentifier();
setState(1045);
callSuffix();
}
}
}
setState(1051);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,135,_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 DisjunctionContext extends ParserRuleContext {
public Token bop;
public ConjunctionContext conjunction() {
return getRuleContext(ConjunctionContext.class,0);
}
public List<DisjunctionContext> disjunction() {
return getRuleContexts(DisjunctionContext.class);
}
public DisjunctionContext disjunction(int i) {
return getRuleContext(DisjunctionContext.class,i);
}
public TerminalNode DISJ() { return getToken(FeatherParser.DISJ, 0); }
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public DisjunctionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_disjunction; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterDisjunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitDisjunction(this);
}
}
public final DisjunctionContext disjunction() throws RecognitionException {
return disjunction(0);
}
private DisjunctionContext disjunction(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
DisjunctionContext _localctx = new DisjunctionContext(_ctx, _parentState);
DisjunctionContext _prevctx = _localctx;
int _startState = 124;
enterRecursionRule(_localctx, 124, RULE_disjunction, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(1053);
conjunction(0);
}
_ctx.stop = _input.LT(-1);
setState(1072);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,138,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new DisjunctionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_disjunction);
setState(1055);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(1059);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1056);
match(NL);
}
}
setState(1061);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1062);
((DisjunctionContext)_localctx).bop = match(DISJ);
setState(1066);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1063);
match(NL);
}
}
setState(1068);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1069);
disjunction(3);
}
}
}
setState(1074);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,138,_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 ConjunctionContext extends ParserRuleContext {
public Token bop;
public EqualityComparisonContext equalityComparison() {
return getRuleContext(EqualityComparisonContext.class,0);
}
public List<ConjunctionContext> conjunction() {
return getRuleContexts(ConjunctionContext.class);
}
public ConjunctionContext conjunction(int i) {
return getRuleContext(ConjunctionContext.class,i);
}
public TerminalNode CONJ() { return getToken(FeatherParser.CONJ, 0); }
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public ConjunctionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_conjunction; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterConjunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitConjunction(this);
}
}
public final ConjunctionContext conjunction() throws RecognitionException {
return conjunction(0);
}
private ConjunctionContext conjunction(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ConjunctionContext _localctx = new ConjunctionContext(_ctx, _parentState);
ConjunctionContext _prevctx = _localctx;
int _startState = 126;
enterRecursionRule(_localctx, 126, RULE_conjunction, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(1076);
equalityComparison(0);
}
_ctx.stop = _input.LT(-1);
setState(1095);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,141,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new ConjunctionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_conjunction);
setState(1078);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(1082);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1079);
match(NL);
}
}
setState(1084);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1085);
((ConjunctionContext)_localctx).bop = match(CONJ);
setState(1089);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1086);
match(NL);
}
}
setState(1091);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1092);
conjunction(3);
}
}
}
setState(1097);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,141,_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 EqualityComparisonContext extends ParserRuleContext {
public Token bop;
public ComparisonContext comparison() {
return getRuleContext(ComparisonContext.class,0);
}
public List<EqualityComparisonContext> equalityComparison() {
return getRuleContexts(EqualityComparisonContext.class);
}
public EqualityComparisonContext equalityComparison(int i) {
return getRuleContext(EqualityComparisonContext.class,i);
}
public TerminalNode EXCL_EQ() { return getToken(FeatherParser.EXCL_EQ, 0); }
public TerminalNode EXCL_EQEQ() { return getToken(FeatherParser.EXCL_EQEQ, 0); }
public TerminalNode EQEQ() { return getToken(FeatherParser.EQEQ, 0); }
public TerminalNode EQEQEQ() { return getToken(FeatherParser.EQEQEQ, 0); }
public TerminalNode PIPE() { return getToken(FeatherParser.PIPE, 0); }
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public EqualityComparisonContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_equalityComparison; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterEqualityComparison(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitEqualityComparison(this);
}
}
public final EqualityComparisonContext equalityComparison() throws RecognitionException {
return equalityComparison(0);
}
private EqualityComparisonContext equalityComparison(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
EqualityComparisonContext _localctx = new EqualityComparisonContext(_ctx, _parentState);
EqualityComparisonContext _prevctx = _localctx;
int _startState = 128;
enterRecursionRule(_localctx, 128, RULE_equalityComparison, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(1099);
comparison();
}
_ctx.stop = _input.LT(-1);
setState(1112);
_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 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new EqualityComparisonContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_equalityComparison);
setState(1101);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(1102);
((EqualityComparisonContext)_localctx).bop = _input.LT(1);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 60798595506372608L) != 0)) ) {
((EqualityComparisonContext)_localctx).bop = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1106);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1103);
match(NL);
}
}
setState(1108);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1109);
equalityComparison(3);
}
}
}
setState(1114);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,143,_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 ComparisonContext extends ParserRuleContext {
public Token bop;
public List<NamedInfixContext> namedInfix() {
return getRuleContexts(NamedInfixContext.class);
}
public NamedInfixContext namedInfix(int i) {
return getRuleContext(NamedInfixContext.class,i);
}
public TerminalNode LANGLE() { return getToken(FeatherParser.LANGLE, 0); }
public TerminalNode RANGLE() { return getToken(FeatherParser.RANGLE, 0); }
public TerminalNode LE() { return getToken(FeatherParser.LE, 0); }
public TerminalNode GE() { return getToken(FeatherParser.GE, 0); }
public TerminalNode REDIRECT() { return getToken(FeatherParser.REDIRECT, 0); }
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public ComparisonContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_comparison; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterComparison(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitComparison(this);
}
}
public final ComparisonContext comparison() throws RecognitionException {
ComparisonContext _localctx = new ComparisonContext(_ctx, getState());
enterRule(_localctx, 130, RULE_comparison);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1115);
namedInfix();
setState(1124);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,145,_ctx) ) {
case 1:
{
setState(1116);
((ComparisonContext)_localctx).bop = _input.LT(1);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 2181431069507584L) != 0)) ) {
((ComparisonContext)_localctx).bop = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1120);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1117);
match(NL);
}
}
setState(1122);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1123);
namedInfix();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class NamedInfixContext extends ParserRuleContext {
public Token bop;
public ElvisExpressionContext elvisExpression() {
return getRuleContext(ElvisExpressionContext.class,0);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public TerminalNode IS() { return getToken(FeatherParser.IS, 0); }
public TerminalNode NOT_IS() { return getToken(FeatherParser.NOT_IS, 0); }
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public NamedInfixContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_namedInfix; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterNamedInfix(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitNamedInfix(this);
}
}
public final NamedInfixContext namedInfix() throws RecognitionException {
NamedInfixContext _localctx = new NamedInfixContext(_ctx, getState());
enterRule(_localctx, 132, RULE_namedInfix);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1126);
elvisExpression(0);
setState(1135);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,147,_ctx) ) {
case 1:
{
setState(1127);
((NamedInfixContext)_localctx).bop = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==IS || _la==NOT_IS) ) {
((NamedInfixContext)_localctx).bop = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1131);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1128);
match(NL);
}
}
setState(1133);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1134);
type();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ElvisExpressionContext extends ParserRuleContext {
public Token bop;
public InfixFunctionCallContext infixFunctionCall() {
return getRuleContext(InfixFunctionCallContext.class,0);
}
public List<ElvisExpressionContext> elvisExpression() {
return getRuleContexts(ElvisExpressionContext.class);
}
public ElvisExpressionContext elvisExpression(int i) {
return getRuleContext(ElvisExpressionContext.class,i);
}
public TerminalNode ELVIS() { return getToken(FeatherParser.ELVIS, 0); }
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public ElvisExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_elvisExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterElvisExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitElvisExpression(this);
}
}
public final ElvisExpressionContext elvisExpression() throws RecognitionException {
return elvisExpression(0);
}
private ElvisExpressionContext elvisExpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ElvisExpressionContext _localctx = new ElvisExpressionContext(_ctx, _parentState);
ElvisExpressionContext _prevctx = _localctx;
int _startState = 134;
enterRecursionRule(_localctx, 134, RULE_elvisExpression, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(1138);
infixFunctionCall(0);
}
_ctx.stop = _input.LT(-1);
setState(1151);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,149,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new ElvisExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_elvisExpression);
setState(1140);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(1141);
((ElvisExpressionContext)_localctx).bop = match(ELVIS);
setState(1145);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1142);
match(NL);
}
}
setState(1147);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1148);
elvisExpression(3);
}
}
}
setState(1153);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,149,_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 InfixFunctionCallContext extends ParserRuleContext {
public SimpleIdentifierContext methodName;
public MapToExpressionContext mapToExpression() {
return getRuleContext(MapToExpressionContext.class,0);
}
public RangeExpressionContext rangeExpression() {
return getRuleContext(RangeExpressionContext.class,0);
}
public AdditiveExpressionContext additiveExpression() {
return getRuleContext(AdditiveExpressionContext.class,0);
}
public List<InfixFunctionCallContext> infixFunctionCall() {
return getRuleContexts(InfixFunctionCallContext.class);
}
public InfixFunctionCallContext infixFunctionCall(int i) {
return getRuleContext(InfixFunctionCallContext.class,i);
}
public SimpleIdentifierContext simpleIdentifier() {
return getRuleContext(SimpleIdentifierContext.class,0);
}
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public InfixFunctionCallContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_infixFunctionCall; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterInfixFunctionCall(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitInfixFunctionCall(this);
}
}
public final InfixFunctionCallContext infixFunctionCall() throws RecognitionException {
return infixFunctionCall(0);
}
private InfixFunctionCallContext infixFunctionCall(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
InfixFunctionCallContext _localctx = new InfixFunctionCallContext(_ctx, _parentState);
InfixFunctionCallContext _prevctx = _localctx;
int _startState = 136;
enterRecursionRule(_localctx, 136, RULE_infixFunctionCall, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1158);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) {
case 1:
{
setState(1155);
mapToExpression();
}
break;
case 2:
{
setState(1156);
rangeExpression();
}
break;
case 3:
{
setState(1157);
additiveExpression(0);
}
break;
}
_ctx.stop = _input.LT(-1);
setState(1172);
_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;
{
{
_localctx = new InfixFunctionCallContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_infixFunctionCall);
setState(1160);
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
setState(1161);
((InfixFunctionCallContext)_localctx).methodName = simpleIdentifier();
setState(1165);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1162);
match(NL);
}
}
setState(1167);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1168);
infixFunctionCall(5);
}
}
}
setState(1174);
_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 MapToExpressionContext extends ParserRuleContext {
public Token bop;
public List<AdditiveExpressionContext> additiveExpression() {
return getRuleContexts(AdditiveExpressionContext.class);
}
public AdditiveExpressionContext additiveExpression(int i) {
return getRuleContext(AdditiveExpressionContext.class,i);
}
public TerminalNode MAP_TO() { return getToken(FeatherParser.MAP_TO, 0); }
public TerminalNode IN() { return getToken(FeatherParser.IN, 0); }
public TerminalNode NOT_IN() { return getToken(FeatherParser.NOT_IN, 0); }
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public MapToExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_mapToExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterMapToExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitMapToExpression(this);
}
}
public final MapToExpressionContext mapToExpression() throws RecognitionException {
MapToExpressionContext _localctx = new MapToExpressionContext(_ctx, getState());
enterRule(_localctx, 138, RULE_mapToExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1175);
additiveExpression(0);
setState(1176);
((MapToExpressionContext)_localctx).bop = _input.LT(1);
_la = _input.LA(1);
if ( !(((((_la - 56)) & ~0x3f) == 0 && ((1L << (_la - 56)) & 3145729L) != 0)) ) {
((MapToExpressionContext)_localctx).bop = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1180);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1177);
match(NL);
}
}
setState(1182);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1183);
additiveExpression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RangeExpressionContext extends ParserRuleContext {
public Token bop;
public List<AdditiveExpressionContext> additiveExpression() {
return getRuleContexts(AdditiveExpressionContext.class);
}
public AdditiveExpressionContext additiveExpression(int i) {
return getRuleContext(AdditiveExpressionContext.class,i);
}
public TerminalNode RANGE() { return getToken(FeatherParser.RANGE, 0); }
public TerminalNode RANGE_UNTIL() { return getToken(FeatherParser.RANGE_UNTIL, 0); }
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public RangeExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rangeExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterRangeExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitRangeExpression(this);
}
}
public final RangeExpressionContext rangeExpression() throws RecognitionException {
RangeExpressionContext _localctx = new RangeExpressionContext(_ctx, getState());
enterRule(_localctx, 140, RULE_rangeExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1185);
additiveExpression(0);
setState(1186);
((RangeExpressionContext)_localctx).bop = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==RANGE || _la==RANGE_UNTIL) ) {
((RangeExpressionContext)_localctx).bop = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1190);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1187);
match(NL);
}
}
setState(1192);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1193);
additiveExpression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AdditiveExpressionContext extends ParserRuleContext {
public Token bop;
public MultiplicativeExpressionContext multiplicativeExpression() {
return getRuleContext(MultiplicativeExpressionContext.class,0);
}
public List<AdditiveExpressionContext> additiveExpression() {
return getRuleContexts(AdditiveExpressionContext.class);
}
public AdditiveExpressionContext additiveExpression(int i) {
return getRuleContext(AdditiveExpressionContext.class,i);
}
public TerminalNode ADD() { return getToken(FeatherParser.ADD, 0); }
public TerminalNode SUB() { return getToken(FeatherParser.SUB, 0); }
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public AdditiveExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_additiveExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterAdditiveExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitAdditiveExpression(this);
}
}
public final AdditiveExpressionContext additiveExpression() throws RecognitionException {
return additiveExpression(0);
}
private AdditiveExpressionContext additiveExpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
AdditiveExpressionContext _localctx = new AdditiveExpressionContext(_ctx, _parentState);
AdditiveExpressionContext _prevctx = _localctx;
int _startState = 142;
enterRecursionRule(_localctx, 142, RULE_additiveExpression, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(1196);
multiplicativeExpression(0);
}
_ctx.stop = _input.LT(-1);
setState(1209);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,156,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new AdditiveExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_additiveExpression);
setState(1198);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(1199);
((AdditiveExpressionContext)_localctx).bop = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==ADD || _la==SUB) ) {
((AdditiveExpressionContext)_localctx).bop = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1203);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1200);
match(NL);
}
}
setState(1205);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1206);
additiveExpression(3);
}
}
}
setState(1211);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,156,_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 MultiplicativeExpressionContext extends ParserRuleContext {
public Token bop;
public PowerExpressionContext powerExpression() {
return getRuleContext(PowerExpressionContext.class,0);
}
public List<MultiplicativeExpressionContext> multiplicativeExpression() {
return getRuleContexts(MultiplicativeExpressionContext.class);
}
public MultiplicativeExpressionContext multiplicativeExpression(int i) {
return getRuleContext(MultiplicativeExpressionContext.class,i);
}
public TerminalNode MULT() { return getToken(FeatherParser.MULT, 0); }
public TerminalNode FLOOR_DIV() { return getToken(FeatherParser.FLOOR_DIV, 0); }
public TerminalNode DIVIDE() { return getToken(FeatherParser.DIVIDE, 0); }
public TerminalNode REM() { return getToken(FeatherParser.REM, 0); }
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public MultiplicativeExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_multiplicativeExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterMultiplicativeExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitMultiplicativeExpression(this);
}
}
public final MultiplicativeExpressionContext multiplicativeExpression() throws RecognitionException {
return multiplicativeExpression(0);
}
private MultiplicativeExpressionContext multiplicativeExpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
MultiplicativeExpressionContext _localctx = new MultiplicativeExpressionContext(_ctx, _parentState);
MultiplicativeExpressionContext _prevctx = _localctx;
int _startState = 144;
enterRecursionRule(_localctx, 144, RULE_multiplicativeExpression, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(1213);
powerExpression(0);
}
_ctx.stop = _input.LT(-1);
setState(1226);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,158,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new MultiplicativeExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_multiplicativeExpression);
setState(1215);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(1216);
((MultiplicativeExpressionContext)_localctx).bop = _input.LT(1);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 6029312L) != 0)) ) {
((MultiplicativeExpressionContext)_localctx).bop = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1220);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1217);
match(NL);
}
}
setState(1222);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1223);
multiplicativeExpression(3);
}
}
}
setState(1228);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,158,_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 PowerExpressionContext extends ParserRuleContext {
public Token bop;
public TypeRHSContext typeRHS() {
return getRuleContext(TypeRHSContext.class,0);
}
public List<PowerExpressionContext> powerExpression() {
return getRuleContexts(PowerExpressionContext.class);
}
public PowerExpressionContext powerExpression(int i) {
return getRuleContext(PowerExpressionContext.class,i);
}
public TerminalNode POWER() { return getToken(FeatherParser.POWER, 0); }
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public PowerExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_powerExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterPowerExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitPowerExpression(this);
}
}
public final PowerExpressionContext powerExpression() throws RecognitionException {
return powerExpression(0);
}
private PowerExpressionContext powerExpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
PowerExpressionContext _localctx = new PowerExpressionContext(_ctx, _parentState);
PowerExpressionContext _prevctx = _localctx;
int _startState = 146;
enterRecursionRule(_localctx, 146, RULE_powerExpression, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(1230);
typeRHS();
}
_ctx.stop = _input.LT(-1);
setState(1243);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,160,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new PowerExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_powerExpression);
setState(1232);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(1233);
((PowerExpressionContext)_localctx).bop = match(POWER);
setState(1237);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1234);
match(NL);
}
}
setState(1239);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1240);
powerExpression(3);
}
}
}
setState(1245);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,160,_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 TypeRHSContext extends ParserRuleContext {
public Token bop;
public PrefixUnaryExpressionContext prefixUnaryExpression() {
return getRuleContext(PrefixUnaryExpressionContext.class,0);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public TerminalNode AS() { return getToken(FeatherParser.AS, 0); }
public TerminalNode AS_SAFE() { return getToken(FeatherParser.AS_SAFE, 0); }
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public TypeRHSContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeRHS; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterTypeRHS(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitTypeRHS(this);
}
}
public final TypeRHSContext typeRHS() throws RecognitionException {
TypeRHSContext _localctx = new TypeRHSContext(_ctx, getState());
enterRule(_localctx, 148, RULE_typeRHS);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1246);
prefixUnaryExpression();
setState(1255);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,162,_ctx) ) {
case 1:
{
setState(1250);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1247);
match(NL);
}
}
setState(1252);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1253);
((TypeRHSContext)_localctx).bop = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==AS_SAFE || _la==AS) ) {
((TypeRHSContext)_localctx).bop = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1254);
type();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PrefixUnaryExpressionContext extends ParserRuleContext {
public Token uop;
public PrefixUnaryExpressionContext prefixUnaryExpression() {
return getRuleContext(PrefixUnaryExpressionContext.class,0);
}
public TerminalNode ADD() { return getToken(FeatherParser.ADD, 0); }
public TerminalNode SUB() { return getToken(FeatherParser.SUB, 0); }
public TerminalNode EXCL() { return getToken(FeatherParser.EXCL, 0); }
public TerminalNode DECR() { return getToken(FeatherParser.DECR, 0); }
public TerminalNode INCR() { return getToken(FeatherParser.INCR, 0); }
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public InvokableExpressionContext invokableExpression() {
return getRuleContext(InvokableExpressionContext.class,0);
}
public PrefixUnaryExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_prefixUnaryExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterPrefixUnaryExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitPrefixUnaryExpression(this);
}
}
public final PrefixUnaryExpressionContext prefixUnaryExpression() throws RecognitionException {
PrefixUnaryExpressionContext _localctx = new PrefixUnaryExpressionContext(_ctx, getState());
enterRule(_localctx, 150, RULE_prefixUnaryExpression);
int _la;
try {
setState(1266);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ADD:
case SUB:
case INCR:
case DECR:
case EXCL:
enterOuterAlt(_localctx, 1);
{
setState(1257);
((PrefixUnaryExpressionContext)_localctx).uop = _input.LT(1);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 2399141888L) != 0)) ) {
((PrefixUnaryExpressionContext)_localctx).uop = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1261);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1258);
match(NL);
}
}
setState(1263);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1264);
prefixUnaryExpression();
}
break;
case LPAREN:
case COLON_COLON:
case BREAK:
case CATCH:
case CONSTRUCTOR:
case CONTINUE:
case ENUM:
case FINALLY:
case IF:
case IMPORT:
case LIBRARY:
case SUPER:
case THIS:
case THROW:
case TRY:
case WITH:
case QUOTE_OPEN:
case TRIPLE_QUOTE_OPEN:
case COMMAND_OPEN:
case FloatLiteral:
case DoubleLiteral:
case LongLiteral:
case ByteLiteral:
case ShortLiteral:
case IntegerLiteral:
case RealLiteral:
case BooleanLiteral:
case NullLiteral:
case Identifier:
case CharacterLiteral:
enterOuterAlt(_localctx, 2);
{
setState(1265);
invokableExpression();
}
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 InvokableExpressionContext extends ParserRuleContext {
public PostfixUnaryExpressionContext postfixUnaryExpression() {
return getRuleContext(PostfixUnaryExpressionContext.class,0);
}
public CallSuffixContext callSuffix() {
return getRuleContext(CallSuffixContext.class,0);
}
public InvokableExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_invokableExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterInvokableExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitInvokableExpression(this);
}
}
public final InvokableExpressionContext invokableExpression() throws RecognitionException {
InvokableExpressionContext _localctx = new InvokableExpressionContext(_ctx, getState());
enterRule(_localctx, 152, RULE_invokableExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(1268);
postfixUnaryExpression(0);
setState(1270);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,165,_ctx) ) {
case 1:
{
setState(1269);
callSuffix();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PostfixUnaryExpressionContext extends ParserRuleContext {
public Token uop;
public WithContext with() {
return getRuleContext(WithContext.class,0);
}
public MethodCallContext methodCall() {
return getRuleContext(MethodCallContext.class,0);
}
public AtomicExpressionContext atomicExpression() {
return getRuleContext(AtomicExpressionContext.class,0);
}
public FunctionContext function() {
return getRuleContext(FunctionContext.class,0);
}
public PostfixUnaryExpressionContext postfixUnaryExpression() {
return getRuleContext(PostfixUnaryExpressionContext.class,0);
}
public ArrayAccessContext arrayAccess() {
return getRuleContext(ArrayAccessContext.class,0);
}
public ReceiverActionContext receiverAction() {
return getRuleContext(ReceiverActionContext.class,0);
}
public ReceiverMethodCallContext receiverMethodCall() {
return getRuleContext(ReceiverMethodCallContext.class,0);
}
public FieldAccessContext fieldAccess() {
return getRuleContext(FieldAccessContext.class,0);
}
public CurriedFunctionContext curriedFunction() {
return getRuleContext(CurriedFunctionContext.class,0);
}
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public TerminalNode INCR() { return getToken(FeatherParser.INCR, 0); }
public TerminalNode DECR() { return getToken(FeatherParser.DECR, 0); }
public PostfixUnaryExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_postfixUnaryExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterPostfixUnaryExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitPostfixUnaryExpression(this);
}
}
public final PostfixUnaryExpressionContext postfixUnaryExpression() throws RecognitionException {
return postfixUnaryExpression(0);
}
private PostfixUnaryExpressionContext postfixUnaryExpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
PostfixUnaryExpressionContext _localctx = new PostfixUnaryExpressionContext(_ctx, _parentState);
PostfixUnaryExpressionContext _prevctx = _localctx;
int _startState = 154;
enterRecursionRule(_localctx, 154, RULE_postfixUnaryExpression, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1277);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,166,_ctx) ) {
case 1:
{
setState(1273);
with();
}
break;
case 2:
{
setState(1274);
methodCall();
}
break;
case 3:
{
setState(1275);
atomicExpression();
}
break;
case 4:
{
setState(1276);
function();
}
break;
}
_ctx.stop = _input.LT(-1);
setState(1296);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,169,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new PostfixUnaryExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_postfixUnaryExpression);
setState(1279);
if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
setState(1283);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1280);
match(NL);
}
}
setState(1285);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1292);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,168,_ctx) ) {
case 1:
{
setState(1286);
((PostfixUnaryExpressionContext)_localctx).uop = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==INCR || _la==DECR) ) {
((PostfixUnaryExpressionContext)_localctx).uop = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case 2:
{
setState(1287);
arrayAccess();
}
break;
case 3:
{
setState(1288);
receiverAction();
}
break;
case 4:
{
setState(1289);
receiverMethodCall();
}
break;
case 5:
{
setState(1290);
fieldAccess();
}
break;
case 6:
{
setState(1291);
curriedFunction();
}
break;
}
}
}
}
setState(1298);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,169,_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 ReceiverMethodCallContext extends ParserRuleContext {
public TerminalNode DOT() { return getToken(FeatherParser.DOT, 0); }
public SimpleIdentifierContext simpleIdentifier() {
return getRuleContext(SimpleIdentifierContext.class,0);
}
public CallSuffixContext callSuffix() {
return getRuleContext(CallSuffixContext.class,0);
}
public ReceiverMethodCallContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_receiverMethodCall; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterReceiverMethodCall(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitReceiverMethodCall(this);
}
}
public final ReceiverMethodCallContext receiverMethodCall() throws RecognitionException {
ReceiverMethodCallContext _localctx = new ReceiverMethodCallContext(_ctx, getState());
enterRule(_localctx, 156, RULE_receiverMethodCall);
try {
enterOuterAlt(_localctx, 1);
{
setState(1299);
match(DOT);
setState(1300);
simpleIdentifier();
setState(1301);
callSuffix();
}
}
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 SimpleIdentifierContext simpleIdentifier() {
return getRuleContext(SimpleIdentifierContext.class,0);
}
public CallSuffixContext callSuffix() {
return getRuleContext(CallSuffixContext.class,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 FeatherParserListener ) ((FeatherParserListener)listener).enterMethodCall(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitMethodCall(this);
}
}
public final MethodCallContext methodCall() throws RecognitionException {
MethodCallContext _localctx = new MethodCallContext(_ctx, getState());
enterRule(_localctx, 158, RULE_methodCall);
try {
enterOuterAlt(_localctx, 1);
{
setState(1303);
simpleIdentifier();
setState(1304);
callSuffix();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FunctionContext extends ParserRuleContext {
public SimpleIdentifierContext className;
public SimpleIdentifierContext methodName;
public TerminalNode COLON_COLON() { return getToken(FeatherParser.COLON_COLON, 0); }
public List<SimpleIdentifierContext> simpleIdentifier() {
return getRuleContexts(SimpleIdentifierContext.class);
}
public SimpleIdentifierContext simpleIdentifier(int i) {
return getRuleContext(SimpleIdentifierContext.class,i);
}
public TerminalNode LANGLE() { return getToken(FeatherParser.LANGLE, 0); }
public TerminalNode RANGLE() { return getToken(FeatherParser.RANGLE, 0); }
public List<TypeContext> type() {
return getRuleContexts(TypeContext.class);
}
public TypeContext type(int i) {
return getRuleContext(TypeContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(FeatherParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(FeatherParser.COMMA, i);
}
public FunctionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_function; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitFunction(this);
}
}
public final FunctionContext function() throws RecognitionException {
FunctionContext _localctx = new FunctionContext(_ctx, getState());
enterRule(_localctx, 160, RULE_function);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1307);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 63)) & ~0x3f) == 0 && ((1L << (_la - 63)) & 2251799847371077L) != 0)) {
{
setState(1306);
((FunctionContext)_localctx).className = simpleIdentifier();
}
}
setState(1309);
match(COLON_COLON);
setState(1310);
((FunctionContext)_localctx).methodName = simpleIdentifier();
setState(1323);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,173,_ctx) ) {
case 1:
{
setState(1311);
match(LANGLE);
setState(1320);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LPAREN || _la==CATCH || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 562949961842769L) != 0)) {
{
setState(1312);
type();
setState(1317);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1313);
match(COMMA);
setState(1314);
type();
}
}
setState(1319);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(1322);
match(RANGLE);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CurriedFunctionContext extends ParserRuleContext {
public SimpleIdentifierContext methodName;
public TerminalNode CURRIED() { return getToken(FeatherParser.CURRIED, 0); }
public SimpleIdentifierContext simpleIdentifier() {
return getRuleContext(SimpleIdentifierContext.class,0);
}
public TerminalNode LANGLE() { return getToken(FeatherParser.LANGLE, 0); }
public TerminalNode RANGLE() { return getToken(FeatherParser.RANGLE, 0); }
public List<TypeContext> type() {
return getRuleContexts(TypeContext.class);
}
public TypeContext type(int i) {
return getRuleContext(TypeContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(FeatherParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(FeatherParser.COMMA, i);
}
public CurriedFunctionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_curriedFunction; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterCurriedFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitCurriedFunction(this);
}
}
public final CurriedFunctionContext curriedFunction() throws RecognitionException {
CurriedFunctionContext _localctx = new CurriedFunctionContext(_ctx, getState());
enterRule(_localctx, 162, RULE_curriedFunction);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1325);
match(CURRIED);
setState(1326);
((CurriedFunctionContext)_localctx).methodName = simpleIdentifier();
setState(1339);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,176,_ctx) ) {
case 1:
{
setState(1327);
match(LANGLE);
setState(1336);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LPAREN || _la==CATCH || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 562949961842769L) != 0)) {
{
setState(1328);
type();
setState(1333);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1329);
match(COMMA);
setState(1330);
type();
}
}
setState(1335);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(1338);
match(RANGLE);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ReceiverActionContext extends ParserRuleContext {
public ReceiverDescriptionContext receiverDescription() {
return getRuleContext(ReceiverDescriptionContext.class,0);
}
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public ReceiverActionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_receiverAction; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterReceiverAction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitReceiverAction(this);
}
}
public final ReceiverActionContext receiverAction() throws RecognitionException {
ReceiverActionContext _localctx = new ReceiverActionContext(_ctx, getState());
enterRule(_localctx, 164, RULE_receiverAction);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1341);
receiverDescription();
setState(1345);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1342);
match(NL);
}
}
setState(1347);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1348);
block();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ReceiverDescriptionContext extends ParserRuleContext {
public Token action;
public TerminalNode DOT() { return getToken(FeatherParser.DOT, 0); }
public TerminalNode APPLY() { return getToken(FeatherParser.APPLY, 0); }
public ReceiverDescriptionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_receiverDescription; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterReceiverDescription(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitReceiverDescription(this);
}
}
public final ReceiverDescriptionContext receiverDescription() throws RecognitionException {
ReceiverDescriptionContext _localctx = new ReceiverDescriptionContext(_ctx, getState());
enterRule(_localctx, 166, RULE_receiverDescription);
try {
enterOuterAlt(_localctx, 1);
{
setState(1350);
match(DOT);
setState(1351);
((ReceiverDescriptionContext)_localctx).action = match(APPLY);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class WithContext extends ParserRuleContext {
public WithDescriptionContext withDescription() {
return getRuleContext(WithDescriptionContext.class,0);
}
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public WithContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_with; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterWith(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitWith(this);
}
}
public final WithContext with() throws RecognitionException {
WithContext _localctx = new WithContext(_ctx, getState());
enterRule(_localctx, 168, RULE_with);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1353);
withDescription();
setState(1357);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1354);
match(NL);
}
}
setState(1359);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1360);
block();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class WithDescriptionContext extends ParserRuleContext {
public Token action;
public TerminalNode LPAREN() { return getToken(FeatherParser.LPAREN, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RPAREN() { return getToken(FeatherParser.RPAREN, 0); }
public TerminalNode WITH() { return getToken(FeatherParser.WITH, 0); }
public WithDescriptionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_withDescription; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterWithDescription(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitWithDescription(this);
}
}
public final WithDescriptionContext withDescription() throws RecognitionException {
WithDescriptionContext _localctx = new WithDescriptionContext(_ctx, getState());
enterRule(_localctx, 170, RULE_withDescription);
try {
enterOuterAlt(_localctx, 1);
{
setState(1362);
((WithDescriptionContext)_localctx).action = match(WITH);
setState(1363);
match(LPAREN);
setState(1364);
expression();
setState(1365);
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 FieldAccessContext extends ParserRuleContext {
public TerminalNode DOT() { return getToken(FeatherParser.DOT, 0); }
public SimpleIdentifierContext simpleIdentifier() {
return getRuleContext(SimpleIdentifierContext.class,0);
}
public FieldAccessContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fieldAccess; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterFieldAccess(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitFieldAccess(this);
}
}
public final FieldAccessContext fieldAccess() throws RecognitionException {
FieldAccessContext _localctx = new FieldAccessContext(_ctx, getState());
enterRule(_localctx, 172, RULE_fieldAccess);
try {
enterOuterAlt(_localctx, 1);
{
setState(1367);
match(DOT);
setState(1368);
simpleIdentifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ArrayAccessContext extends ParserRuleContext {
public TerminalNode LSQUARE() { return getToken(FeatherParser.LSQUARE, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RSQUARE() { return getToken(FeatherParser.RSQUARE, 0); }
public TerminalNode BARRELOPEN() { return getToken(FeatherParser.BARRELOPEN, 0); }
public TerminalNode BARRELCLOSE() { return getToken(FeatherParser.BARRELCLOSE, 0); }
public ArrayAccessContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arrayAccess; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterArrayAccess(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitArrayAccess(this);
}
}
public final ArrayAccessContext arrayAccess() throws RecognitionException {
ArrayAccessContext _localctx = new ArrayAccessContext(_ctx, getState());
enterRule(_localctx, 174, RULE_arrayAccess);
try {
setState(1378);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LSQUARE:
enterOuterAlt(_localctx, 1);
{
setState(1370);
match(LSQUARE);
setState(1371);
expression();
setState(1372);
match(RSQUARE);
}
break;
case BARRELOPEN:
enterOuterAlt(_localctx, 2);
{
setState(1374);
match(BARRELOPEN);
setState(1375);
expression();
setState(1376);
match(BARRELCLOSE);
}
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 CallSuffixContext extends ParserRuleContext {
public ValueArgumentsContext valueArguments() {
return getRuleContext(ValueArgumentsContext.class,0);
}
public TypeArgumentsContext typeArguments() {
return getRuleContext(TypeArgumentsContext.class,0);
}
public CallSuffixContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_callSuffix; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterCallSuffix(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitCallSuffix(this);
}
}
public final CallSuffixContext callSuffix() throws RecognitionException {
CallSuffixContext _localctx = new CallSuffixContext(_ctx, getState());
enterRule(_localctx, 176, RULE_callSuffix);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1381);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LANGLE) {
{
setState(1380);
typeArguments();
}
}
setState(1383);
valueArguments();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ValueArgumentsContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(FeatherParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(FeatherParser.RPAREN, 0); }
public List<ValueArgumentContext> valueArgument() {
return getRuleContexts(ValueArgumentContext.class);
}
public ValueArgumentContext valueArgument(int i) {
return getRuleContext(ValueArgumentContext.class,i);
}
public List<TerminalNode> COMMA() { return getTokens(FeatherParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(FeatherParser.COMMA, i);
}
public ValueArgumentsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_valueArguments; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterValueArguments(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitValueArguments(this);
}
}
public final ValueArgumentsContext valueArguments() throws RecognitionException {
ValueArgumentsContext _localctx = new ValueArgumentsContext(_ctx, getState());
enterRule(_localctx, 178, RULE_valueArguments);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1385);
match(LPAREN);
setState(1394);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -4611686007438310848L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 10009950596138199L) != 0)) {
{
setState(1386);
valueArgument();
setState(1391);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1387);
match(COMMA);
setState(1388);
valueArgument();
}
}
setState(1393);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(1396);
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 ValueArgumentContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public ValueArgumentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_valueArgument; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterValueArgument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitValueArgument(this);
}
}
public final ValueArgumentContext valueArgument() throws RecognitionException {
ValueArgumentContext _localctx = new ValueArgumentContext(_ctx, getState());
enterRule(_localctx, 180, RULE_valueArgument);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1401);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1398);
match(NL);
}
}
setState(1403);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1404);
expression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AtomicExpressionContext extends ParserRuleContext {
public ParenthesizedExpressionContext parenthesizedExpression() {
return getRuleContext(ParenthesizedExpressionContext.class,0);
}
public ThrowStatementContext throwStatement() {
return getRuleContext(ThrowStatementContext.class,0);
}
public LiteralConstantContext literalConstant() {
return getRuleContext(LiteralConstantContext.class,0);
}
public ThisExpressionContext thisExpression() {
return getRuleContext(ThisExpressionContext.class,0);
}
public AtomicIdentifierContext atomicIdentifier() {
return getRuleContext(AtomicIdentifierContext.class,0);
}
public IfExpressionContext ifExpression() {
return getRuleContext(IfExpressionContext.class,0);
}
public TryExpressionContext tryExpression() {
return getRuleContext(TryExpressionContext.class,0);
}
public SuperExpressionContext superExpression() {
return getRuleContext(SuperExpressionContext.class,0);
}
public ContinueStatementContext continueStatement() {
return getRuleContext(ContinueStatementContext.class,0);
}
public BreakStatementContext breakStatement() {
return getRuleContext(BreakStatementContext.class,0);
}
public AtomicExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_atomicExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterAtomicExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitAtomicExpression(this);
}
}
public final AtomicExpressionContext atomicExpression() throws RecognitionException {
AtomicExpressionContext _localctx = new AtomicExpressionContext(_ctx, getState());
enterRule(_localctx, 182, RULE_atomicExpression);
try {
setState(1416);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LPAREN:
enterOuterAlt(_localctx, 1);
{
setState(1406);
parenthesizedExpression();
}
break;
case THROW:
enterOuterAlt(_localctx, 2);
{
setState(1407);
throwStatement();
}
break;
case QUOTE_OPEN:
case TRIPLE_QUOTE_OPEN:
case COMMAND_OPEN:
case FloatLiteral:
case DoubleLiteral:
case LongLiteral:
case ByteLiteral:
case ShortLiteral:
case IntegerLiteral:
case RealLiteral:
case BooleanLiteral:
case NullLiteral:
case CharacterLiteral:
enterOuterAlt(_localctx, 3);
{
setState(1408);
literalConstant();
}
break;
case THIS:
enterOuterAlt(_localctx, 4);
{
setState(1409);
thisExpression();
}
break;
case CATCH:
case CONSTRUCTOR:
case ENUM:
case FINALLY:
case IMPORT:
case LIBRARY:
case Identifier:
enterOuterAlt(_localctx, 5);
{
setState(1410);
atomicIdentifier();
}
break;
case IF:
enterOuterAlt(_localctx, 6);
{
setState(1411);
ifExpression();
}
break;
case TRY:
enterOuterAlt(_localctx, 7);
{
setState(1412);
tryExpression();
}
break;
case SUPER:
enterOuterAlt(_localctx, 8);
{
setState(1413);
superExpression();
}
break;
case CONTINUE:
enterOuterAlt(_localctx, 9);
{
setState(1414);
continueStatement();
}
break;
case BREAK:
enterOuterAlt(_localctx, 10);
{
setState(1415);
breakStatement();
}
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 AtomicIdentifierContext extends ParserRuleContext {
public SimpleIdentifierContext simpleIdentifier() {
return getRuleContext(SimpleIdentifierContext.class,0);
}
public AtomicIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_atomicIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterAtomicIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitAtomicIdentifier(this);
}
}
public final AtomicIdentifierContext atomicIdentifier() throws RecognitionException {
AtomicIdentifierContext _localctx = new AtomicIdentifierContext(_ctx, getState());
enterRule(_localctx, 184, RULE_atomicIdentifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(1418);
simpleIdentifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ThisExpressionContext extends ParserRuleContext {
public TerminalNode THIS() { return getToken(FeatherParser.THIS, 0); }
public ThisExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_thisExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterThisExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitThisExpression(this);
}
}
public final ThisExpressionContext thisExpression() throws RecognitionException {
ThisExpressionContext _localctx = new ThisExpressionContext(_ctx, getState());
enterRule(_localctx, 186, RULE_thisExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(1420);
match(THIS);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SuperExpressionContext extends ParserRuleContext {
public TerminalNode SUPER() { return getToken(FeatherParser.SUPER, 0); }
public SuperExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_superExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterSuperExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitSuperExpression(this);
}
}
public final SuperExpressionContext superExpression() throws RecognitionException {
SuperExpressionContext _localctx = new SuperExpressionContext(_ctx, getState());
enterRule(_localctx, 188, RULE_superExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(1422);
match(SUPER);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ParenthesizedExpressionContext extends ParserRuleContext {
public TerminalNode LPAREN() { return getToken(FeatherParser.LPAREN, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RPAREN() { return getToken(FeatherParser.RPAREN, 0); }
public ParenthesizedExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parenthesizedExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterParenthesizedExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitParenthesizedExpression(this);
}
}
public final ParenthesizedExpressionContext parenthesizedExpression() throws RecognitionException {
ParenthesizedExpressionContext _localctx = new ParenthesizedExpressionContext(_ctx, getState());
enterRule(_localctx, 190, RULE_parenthesizedExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(1424);
match(LPAREN);
setState(1425);
expression();
setState(1426);
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 IfExpressionContext extends ParserRuleContext {
public TerminalNode IF() { return getToken(FeatherParser.IF, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public List<ControlStructureBodyContext> controlStructureBody() {
return getRuleContexts(ControlStructureBodyContext.class);
}
public ControlStructureBodyContext controlStructureBody(int i) {
return getRuleContext(ControlStructureBodyContext.class,i);
}
public TerminalNode SEMICOLON() { return getToken(FeatherParser.SEMICOLON, 0); }
public TerminalNode ELSE() { return getToken(FeatherParser.ELSE, 0); }
public IfExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ifExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterIfExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitIfExpression(this);
}
}
public final IfExpressionContext ifExpression() throws RecognitionException {
IfExpressionContext _localctx = new IfExpressionContext(_ctx, getState());
enterRule(_localctx, 192, RULE_ifExpression);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1428);
match(IF);
setState(1432);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1429);
match(NL);
}
}
setState(1434);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1435);
expression();
setState(1439);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,186,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1436);
match(NL);
}
}
}
setState(1441);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,186,_ctx);
}
setState(1445);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,187,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1442);
match(NL);
}
}
}
setState(1447);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,187,_ctx);
}
setState(1449);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,188,_ctx) ) {
case 1:
{
setState(1448);
controlStructureBody();
}
break;
}
setState(1452);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,189,_ctx) ) {
case 1:
{
setState(1451);
match(SEMICOLON);
}
break;
}
setState(1468);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,192,_ctx) ) {
case 1:
{
setState(1457);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1454);
match(NL);
}
}
setState(1459);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1460);
match(ELSE);
setState(1464);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1461);
match(NL);
}
}
setState(1466);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1467);
controlStructureBody();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ForStatementContext extends ParserRuleContext {
public ForSetupContext forSetup() {
return getRuleContext(ForSetupContext.class,0);
}
public ForBodyContext forBody() {
return getRuleContext(ForBodyContext.class,0);
}
public ForStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterForStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitForStatement(this);
}
}
public final ForStatementContext forStatement() throws RecognitionException {
ForStatementContext _localctx = new ForStatementContext(_ctx, getState());
enterRule(_localctx, 194, RULE_forStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(1470);
forSetup();
setState(1471);
forBody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ForSetupContext extends ParserRuleContext {
public SimpleIdentifierContext loopVar;
public SimpleIdentifierContext counterVar;
public TerminalNode FOR() { return getToken(FeatherParser.FOR, 0); }
public TerminalNode IN() { return getToken(FeatherParser.IN, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public List<SimpleIdentifierContext> simpleIdentifier() {
return getRuleContexts(SimpleIdentifierContext.class);
}
public SimpleIdentifierContext simpleIdentifier(int i) {
return getRuleContext(SimpleIdentifierContext.class,i);
}
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public TerminalNode LPAREN() { return getToken(FeatherParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(FeatherParser.RPAREN, 0); }
public TerminalNode COMMA() { return getToken(FeatherParser.COMMA, 0); }
public ForSetupContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forSetup; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterForSetup(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitForSetup(this);
}
}
public final ForSetupContext forSetup() throws RecognitionException {
ForSetupContext _localctx = new ForSetupContext(_ctx, getState());
enterRule(_localctx, 196, RULE_forSetup);
int _la;
try {
setState(1549);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,201,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1473);
match(FOR);
setState(1474);
((ForSetupContext)_localctx).loopVar = simpleIdentifier();
setState(1478);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1475);
match(NL);
}
}
setState(1480);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1481);
match(IN);
setState(1485);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1482);
match(NL);
}
}
setState(1487);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1488);
expression();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1490);
match(FOR);
setState(1491);
match(LPAREN);
setState(1492);
((ForSetupContext)_localctx).loopVar = simpleIdentifier();
setState(1496);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1493);
match(NL);
}
}
setState(1498);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1499);
match(IN);
setState(1503);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1500);
match(NL);
}
}
setState(1505);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1506);
expression();
setState(1507);
match(RPAREN);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1509);
match(FOR);
setState(1510);
((ForSetupContext)_localctx).counterVar = simpleIdentifier();
setState(1511);
match(COMMA);
setState(1512);
((ForSetupContext)_localctx).loopVar = simpleIdentifier();
setState(1516);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1513);
match(NL);
}
}
setState(1518);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1519);
match(IN);
setState(1523);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1520);
match(NL);
}
}
setState(1525);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1526);
expression();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1528);
match(FOR);
setState(1529);
match(LPAREN);
setState(1530);
((ForSetupContext)_localctx).counterVar = simpleIdentifier();
setState(1531);
match(COMMA);
setState(1532);
((ForSetupContext)_localctx).loopVar = simpleIdentifier();
setState(1536);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1533);
match(NL);
}
}
setState(1538);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1539);
match(IN);
setState(1543);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1540);
match(NL);
}
}
setState(1545);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1546);
expression();
setState(1547);
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 ForBodyContext extends ParserRuleContext {
public ControlStructureBodyContext controlStructureBody() {
return getRuleContext(ControlStructureBodyContext.class,0);
}
public ForBodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forBody; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterForBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitForBody(this);
}
}
public final ForBodyContext forBody() throws RecognitionException {
ForBodyContext _localctx = new ForBodyContext(_ctx, getState());
enterRule(_localctx, 198, RULE_forBody);
try {
enterOuterAlt(_localctx, 1);
{
setState(1552);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,202,_ctx) ) {
case 1:
{
setState(1551);
controlStructureBody();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class WhileStatementContext extends ParserRuleContext {
public TerminalNode WHILE() { return getToken(FeatherParser.WHILE, 0); }
public TerminalNode LPAREN() { return getToken(FeatherParser.LPAREN, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RPAREN() { return getToken(FeatherParser.RPAREN, 0); }
public ControlStructureBodyContext controlStructureBody() {
return getRuleContext(ControlStructureBodyContext.class,0);
}
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public WhileStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_whileStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterWhileStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitWhileStatement(this);
}
}
public final WhileStatementContext whileStatement() throws RecognitionException {
WhileStatementContext _localctx = new WhileStatementContext(_ctx, getState());
enterRule(_localctx, 200, RULE_whileStatement);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1554);
match(WHILE);
setState(1558);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1555);
match(NL);
}
}
setState(1560);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1561);
match(LPAREN);
setState(1562);
expression();
setState(1563);
match(RPAREN);
setState(1567);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1564);
match(NL);
}
}
setState(1569);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1570);
controlStructureBody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DoWhileStatementContext extends ParserRuleContext {
public TerminalNode DO() { return getToken(FeatherParser.DO, 0); }
public ControlStructureBodyContext controlStructureBody() {
return getRuleContext(ControlStructureBodyContext.class,0);
}
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public TerminalNode WHILE() { return getToken(FeatherParser.WHILE, 0); }
public TerminalNode LPAREN() { return getToken(FeatherParser.LPAREN, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RPAREN() { return getToken(FeatherParser.RPAREN, 0); }
public DoWhileStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_doWhileStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterDoWhileStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitDoWhileStatement(this);
}
}
public final DoWhileStatementContext doWhileStatement() throws RecognitionException {
DoWhileStatementContext _localctx = new DoWhileStatementContext(_ctx, getState());
enterRule(_localctx, 202, RULE_doWhileStatement);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1572);
match(DO);
setState(1576);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1573);
match(NL);
}
}
setState(1578);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1579);
controlStructureBody();
setState(1583);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,206,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1580);
match(NL);
}
}
}
setState(1585);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,206,_ctx);
}
setState(1597);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,208,_ctx) ) {
case 1:
{
setState(1586);
match(WHILE);
setState(1590);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1587);
match(NL);
}
}
setState(1592);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1593);
match(LPAREN);
setState(1594);
expression();
setState(1595);
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 TryExpressionContext extends ParserRuleContext {
public TerminalNode TRY() { return getToken(FeatherParser.TRY, 0); }
public TryBlockContext tryBlock() {
return getRuleContext(TryBlockContext.class,0);
}
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public List<CatchBlockContext> catchBlock() {
return getRuleContexts(CatchBlockContext.class);
}
public CatchBlockContext catchBlock(int i) {
return getRuleContext(CatchBlockContext.class,i);
}
public FinallyBlockContext finallyBlock() {
return getRuleContext(FinallyBlockContext.class,0);
}
public TryExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tryExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterTryExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitTryExpression(this);
}
}
public final TryExpressionContext tryExpression() throws RecognitionException {
TryExpressionContext _localctx = new TryExpressionContext(_ctx, getState());
enterRule(_localctx, 204, RULE_tryExpression);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1599);
match(TRY);
setState(1603);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1600);
match(NL);
}
}
setState(1605);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1606);
tryBlock();
setState(1616);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,211,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1610);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1607);
match(NL);
}
}
setState(1612);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1613);
catchBlock();
}
}
}
setState(1618);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,211,_ctx);
}
setState(1626);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,213,_ctx) ) {
case 1:
{
setState(1622);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1619);
match(NL);
}
}
setState(1624);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1625);
finallyBlock();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TryBlockContext extends ParserRuleContext {
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public TryBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tryBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterTryBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitTryBlock(this);
}
}
public final TryBlockContext tryBlock() throws RecognitionException {
TryBlockContext _localctx = new TryBlockContext(_ctx, getState());
enterRule(_localctx, 206, RULE_tryBlock);
try {
enterOuterAlt(_localctx, 1);
{
setState(1628);
block();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CatchBlockContext extends ParserRuleContext {
public SimpleIdentifierContext name;
public SimpleIdentifierContext throwType;
public TerminalNode CATCH() { return getToken(FeatherParser.CATCH, 0); }
public TerminalNode LPAREN() { return getToken(FeatherParser.LPAREN, 0); }
public TerminalNode COLON() { return getToken(FeatherParser.COLON, 0); }
public TerminalNode RPAREN() { return getToken(FeatherParser.RPAREN, 0); }
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public List<SimpleIdentifierContext> simpleIdentifier() {
return getRuleContexts(SimpleIdentifierContext.class);
}
public SimpleIdentifierContext simpleIdentifier(int i) {
return getRuleContext(SimpleIdentifierContext.class,i);
}
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public CatchBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_catchBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterCatchBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitCatchBlock(this);
}
}
public final CatchBlockContext catchBlock() throws RecognitionException {
CatchBlockContext _localctx = new CatchBlockContext(_ctx, getState());
enterRule(_localctx, 208, RULE_catchBlock);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1630);
match(CATCH);
setState(1634);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1631);
match(NL);
}
}
setState(1636);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1637);
match(LPAREN);
setState(1638);
((CatchBlockContext)_localctx).name = simpleIdentifier();
setState(1639);
match(COLON);
setState(1640);
((CatchBlockContext)_localctx).throwType = simpleIdentifier();
setState(1641);
match(RPAREN);
setState(1645);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1642);
match(NL);
}
}
setState(1647);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1648);
block();
}
}
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(FeatherParser.FINALLY, 0); }
public BlockContext block() {
return getRuleContext(BlockContext.class,0);
}
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
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 FeatherParserListener ) ((FeatherParserListener)listener).enterFinallyBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitFinallyBlock(this);
}
}
public final FinallyBlockContext finallyBlock() throws RecognitionException {
FinallyBlockContext _localctx = new FinallyBlockContext(_ctx, getState());
enterRule(_localctx, 210, RULE_finallyBlock);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1650);
match(FINALLY);
setState(1654);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1651);
match(NL);
}
}
setState(1656);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1657);
block();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LiteralConstantContext extends ParserRuleContext {
public NullLiteralContext nullLiteral() {
return getRuleContext(NullLiteralContext.class,0);
}
public BooleanLiteralContext booleanLiteral() {
return getRuleContext(BooleanLiteralContext.class,0);
}
public CharacterLiteralContext characterLiteral() {
return getRuleContext(CharacterLiteralContext.class,0);
}
public ByteLiteralContext byteLiteral() {
return getRuleContext(ByteLiteralContext.class,0);
}
public ShortLiteralContext shortLiteral() {
return getRuleContext(ShortLiteralContext.class,0);
}
public IntLiteralContext intLiteral() {
return getRuleContext(IntLiteralContext.class,0);
}
public LongLiteralContext longLiteral() {
return getRuleContext(LongLiteralContext.class,0);
}
public FloatLiteralContext floatLiteral() {
return getRuleContext(FloatLiteralContext.class,0);
}
public DoubleLiteralContext doubleLiteral() {
return getRuleContext(DoubleLiteralContext.class,0);
}
public RealLiteralContext realLiteral() {
return getRuleContext(RealLiteralContext.class,0);
}
public StringLiteralContext stringLiteral() {
return getRuleContext(StringLiteralContext.class,0);
}
public CommandLiteralContext commandLiteral() {
return getRuleContext(CommandLiteralContext.class,0);
}
public LiteralConstantContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_literalConstant; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterLiteralConstant(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitLiteralConstant(this);
}
}
public final LiteralConstantContext literalConstant() throws RecognitionException {
LiteralConstantContext _localctx = new LiteralConstantContext(_ctx, getState());
enterRule(_localctx, 212, RULE_literalConstant);
try {
setState(1671);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NullLiteral:
enterOuterAlt(_localctx, 1);
{
setState(1659);
nullLiteral();
}
break;
case BooleanLiteral:
enterOuterAlt(_localctx, 2);
{
setState(1660);
booleanLiteral();
}
break;
case CharacterLiteral:
enterOuterAlt(_localctx, 3);
{
setState(1661);
characterLiteral();
}
break;
case ByteLiteral:
enterOuterAlt(_localctx, 4);
{
setState(1662);
byteLiteral();
}
break;
case ShortLiteral:
enterOuterAlt(_localctx, 5);
{
setState(1663);
shortLiteral();
}
break;
case IntegerLiteral:
enterOuterAlt(_localctx, 6);
{
setState(1664);
intLiteral();
}
break;
case LongLiteral:
enterOuterAlt(_localctx, 7);
{
setState(1665);
longLiteral();
}
break;
case FloatLiteral:
enterOuterAlt(_localctx, 8);
{
setState(1666);
floatLiteral();
}
break;
case DoubleLiteral:
enterOuterAlt(_localctx, 9);
{
setState(1667);
doubleLiteral();
}
break;
case RealLiteral:
enterOuterAlt(_localctx, 10);
{
setState(1668);
realLiteral();
}
break;
case QUOTE_OPEN:
case TRIPLE_QUOTE_OPEN:
enterOuterAlt(_localctx, 11);
{
setState(1669);
stringLiteral();
}
break;
case COMMAND_OPEN:
enterOuterAlt(_localctx, 12);
{
setState(1670);
commandLiteral();
}
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 NullLiteralContext extends ParserRuleContext {
public TerminalNode NullLiteral() { return getToken(FeatherParser.NullLiteral, 0); }
public NullLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_nullLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterNullLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitNullLiteral(this);
}
}
public final NullLiteralContext nullLiteral() throws RecognitionException {
NullLiteralContext _localctx = new NullLiteralContext(_ctx, getState());
enterRule(_localctx, 214, RULE_nullLiteral);
try {
enterOuterAlt(_localctx, 1);
{
setState(1673);
match(NullLiteral);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class BooleanLiteralContext extends ParserRuleContext {
public TerminalNode BooleanLiteral() { return getToken(FeatherParser.BooleanLiteral, 0); }
public BooleanLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_booleanLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterBooleanLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitBooleanLiteral(this);
}
}
public final BooleanLiteralContext booleanLiteral() throws RecognitionException {
BooleanLiteralContext _localctx = new BooleanLiteralContext(_ctx, getState());
enterRule(_localctx, 216, RULE_booleanLiteral);
try {
enterOuterAlt(_localctx, 1);
{
setState(1675);
match(BooleanLiteral);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CharacterLiteralContext extends ParserRuleContext {
public TerminalNode CharacterLiteral() { return getToken(FeatherParser.CharacterLiteral, 0); }
public CharacterLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_characterLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterCharacterLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitCharacterLiteral(this);
}
}
public final CharacterLiteralContext characterLiteral() throws RecognitionException {
CharacterLiteralContext _localctx = new CharacterLiteralContext(_ctx, getState());
enterRule(_localctx, 218, RULE_characterLiteral);
try {
enterOuterAlt(_localctx, 1);
{
setState(1677);
match(CharacterLiteral);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ByteLiteralContext extends ParserRuleContext {
public TerminalNode ByteLiteral() { return getToken(FeatherParser.ByteLiteral, 0); }
public ByteLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_byteLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterByteLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitByteLiteral(this);
}
}
public final ByteLiteralContext byteLiteral() throws RecognitionException {
ByteLiteralContext _localctx = new ByteLiteralContext(_ctx, getState());
enterRule(_localctx, 220, RULE_byteLiteral);
try {
enterOuterAlt(_localctx, 1);
{
setState(1679);
match(ByteLiteral);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ShortLiteralContext extends ParserRuleContext {
public TerminalNode ShortLiteral() { return getToken(FeatherParser.ShortLiteral, 0); }
public ShortLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_shortLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterShortLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitShortLiteral(this);
}
}
public final ShortLiteralContext shortLiteral() throws RecognitionException {
ShortLiteralContext _localctx = new ShortLiteralContext(_ctx, getState());
enterRule(_localctx, 222, RULE_shortLiteral);
try {
enterOuterAlt(_localctx, 1);
{
setState(1681);
match(ShortLiteral);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class IntLiteralContext extends ParserRuleContext {
public TerminalNode IntegerLiteral() { return getToken(FeatherParser.IntegerLiteral, 0); }
public IntLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_intLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterIntLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitIntLiteral(this);
}
}
public final IntLiteralContext intLiteral() throws RecognitionException {
IntLiteralContext _localctx = new IntLiteralContext(_ctx, getState());
enterRule(_localctx, 224, RULE_intLiteral);
try {
enterOuterAlt(_localctx, 1);
{
setState(1683);
match(IntegerLiteral);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LongLiteralContext extends ParserRuleContext {
public TerminalNode LongLiteral() { return getToken(FeatherParser.LongLiteral, 0); }
public LongLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_longLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterLongLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitLongLiteral(this);
}
}
public final LongLiteralContext longLiteral() throws RecognitionException {
LongLiteralContext _localctx = new LongLiteralContext(_ctx, getState());
enterRule(_localctx, 226, RULE_longLiteral);
try {
enterOuterAlt(_localctx, 1);
{
setState(1685);
match(LongLiteral);
}
}
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 FloatLiteral() { return getToken(FeatherParser.FloatLiteral, 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 FeatherParserListener ) ((FeatherParserListener)listener).enterFloatLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitFloatLiteral(this);
}
}
public final FloatLiteralContext floatLiteral() throws RecognitionException {
FloatLiteralContext _localctx = new FloatLiteralContext(_ctx, getState());
enterRule(_localctx, 228, RULE_floatLiteral);
try {
enterOuterAlt(_localctx, 1);
{
setState(1687);
match(FloatLiteral);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DoubleLiteralContext extends ParserRuleContext {
public TerminalNode DoubleLiteral() { return getToken(FeatherParser.DoubleLiteral, 0); }
public DoubleLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_doubleLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterDoubleLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitDoubleLiteral(this);
}
}
public final DoubleLiteralContext doubleLiteral() throws RecognitionException {
DoubleLiteralContext _localctx = new DoubleLiteralContext(_ctx, getState());
enterRule(_localctx, 230, RULE_doubleLiteral);
try {
enterOuterAlt(_localctx, 1);
{
setState(1689);
match(DoubleLiteral);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class RealLiteralContext extends ParserRuleContext {
public TerminalNode RealLiteral() { return getToken(FeatherParser.RealLiteral, 0); }
public RealLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_realLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterRealLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitRealLiteral(this);
}
}
public final RealLiteralContext realLiteral() throws RecognitionException {
RealLiteralContext _localctx = new RealLiteralContext(_ctx, getState());
enterRule(_localctx, 232, RULE_realLiteral);
try {
enterOuterAlt(_localctx, 1);
{
setState(1691);
match(RealLiteral);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StringLiteralContext extends ParserRuleContext {
public LineStringLiteralContext lineStringLiteral() {
return getRuleContext(LineStringLiteralContext.class,0);
}
public MultiLineStringLiteralContext multiLineStringLiteral() {
return getRuleContext(MultiLineStringLiteralContext.class,0);
}
public StringLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_stringLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterStringLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitStringLiteral(this);
}
}
public final StringLiteralContext stringLiteral() throws RecognitionException {
StringLiteralContext _localctx = new StringLiteralContext(_ctx, getState());
enterRule(_localctx, 234, RULE_stringLiteral);
try {
setState(1695);
_errHandler.sync(this);
switch (_input.LA(1)) {
case QUOTE_OPEN:
enterOuterAlt(_localctx, 1);
{
setState(1693);
lineStringLiteral();
}
break;
case TRIPLE_QUOTE_OPEN:
enterOuterAlt(_localctx, 2);
{
setState(1694);
multiLineStringLiteral();
}
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 LineStringLiteralContext extends ParserRuleContext {
public TerminalNode QUOTE_OPEN() { return getToken(FeatherParser.QUOTE_OPEN, 0); }
public TerminalNode QUOTE_CLOSE() { return getToken(FeatherParser.QUOTE_CLOSE, 0); }
public List<LineStringContentContext> lineStringContent() {
return getRuleContexts(LineStringContentContext.class);
}
public LineStringContentContext lineStringContent(int i) {
return getRuleContext(LineStringContentContext.class,i);
}
public List<LineStringExpressionContext> lineStringExpression() {
return getRuleContexts(LineStringExpressionContext.class);
}
public LineStringExpressionContext lineStringExpression(int i) {
return getRuleContext(LineStringExpressionContext.class,i);
}
public LineStringLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lineStringLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterLineStringLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitLineStringLiteral(this);
}
}
public final LineStringLiteralContext lineStringLiteral() throws RecognitionException {
LineStringLiteralContext _localctx = new LineStringLiteralContext(_ctx, getState());
enterRule(_localctx, 236, RULE_lineStringLiteral);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1697);
match(QUOTE_OPEN);
setState(1702);
_errHandler.sync(this);
_la = _input.LA(1);
while (((((_la - 131)) & ~0x3f) == 0 && ((1L << (_la - 131)) & 15L) != 0)) {
{
setState(1700);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LineStrRef:
case LineStrText:
case LineStrEscapedChar:
{
setState(1698);
lineStringContent();
}
break;
case LineStrExprStart:
{
setState(1699);
lineStringExpression();
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(1704);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1705);
match(QUOTE_CLOSE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MultiLineStringLiteralContext extends ParserRuleContext {
public TerminalNode TRIPLE_QUOTE_OPEN() { return getToken(FeatherParser.TRIPLE_QUOTE_OPEN, 0); }
public TerminalNode TRIPLE_QUOTE_CLOSE() { return getToken(FeatherParser.TRIPLE_QUOTE_CLOSE, 0); }
public List<MultiLineStringContentContext> multiLineStringContent() {
return getRuleContexts(MultiLineStringContentContext.class);
}
public MultiLineStringContentContext multiLineStringContent(int i) {
return getRuleContext(MultiLineStringContentContext.class,i);
}
public List<MultiLineStringExpressionContext> multiLineStringExpression() {
return getRuleContexts(MultiLineStringExpressionContext.class);
}
public MultiLineStringExpressionContext multiLineStringExpression(int i) {
return getRuleContext(MultiLineStringExpressionContext.class,i);
}
public List<MultiLineStringQuoteContext> multiLineStringQuote() {
return getRuleContexts(MultiLineStringQuoteContext.class);
}
public MultiLineStringQuoteContext multiLineStringQuote(int i) {
return getRuleContext(MultiLineStringQuoteContext.class,i);
}
public MultiLineStringLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_multiLineStringLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterMultiLineStringLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitMultiLineStringLiteral(this);
}
}
public final MultiLineStringLiteralContext multiLineStringLiteral() throws RecognitionException {
MultiLineStringLiteralContext _localctx = new MultiLineStringLiteralContext(_ctx, getState());
enterRule(_localctx, 238, RULE_multiLineStringLiteral);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1707);
match(TRIPLE_QUOTE_OPEN);
setState(1713);
_errHandler.sync(this);
_la = _input.LA(1);
while (((((_la - 136)) & ~0x3f) == 0 && ((1L << (_la - 136)) & 31L) != 0)) {
{
setState(1711);
_errHandler.sync(this);
switch (_input.LA(1)) {
case MultiLineStrRef:
case MultiLineStrText:
case MultiLineStrEscapedChar:
{
setState(1708);
multiLineStringContent();
}
break;
case MultiLineStrExprStart:
{
setState(1709);
multiLineStringExpression();
}
break;
case MultiLineStringQuote:
{
setState(1710);
multiLineStringQuote();
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(1715);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1716);
match(TRIPLE_QUOTE_CLOSE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LineStringContentContext extends ParserRuleContext {
public Token ref;
public List<TerminalNode> LineStrText() { return getTokens(FeatherParser.LineStrText); }
public TerminalNode LineStrText(int i) {
return getToken(FeatherParser.LineStrText, i);
}
public List<TerminalNode> LineStrEscapedChar() { return getTokens(FeatherParser.LineStrEscapedChar); }
public TerminalNode LineStrEscapedChar(int i) {
return getToken(FeatherParser.LineStrEscapedChar, i);
}
public TerminalNode LineStrRef() { return getToken(FeatherParser.LineStrRef, 0); }
public LineStringContentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lineStringContent; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterLineStringContent(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitLineStringContent(this);
}
}
public final LineStringContentContext lineStringContent() throws RecognitionException {
LineStringContentContext _localctx = new LineStringContentContext(_ctx, getState());
enterRule(_localctx, 240, RULE_lineStringContent);
int _la;
try {
int _alt;
setState(1724);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LineStrText:
case LineStrEscapedChar:
enterOuterAlt(_localctx, 1);
{
setState(1719);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(1718);
_la = _input.LA(1);
if ( !(_la==LineStrText || _la==LineStrEscapedChar) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(1721);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,223,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
break;
case LineStrRef:
enterOuterAlt(_localctx, 2);
{
setState(1723);
((LineStringContentContext)_localctx).ref = match(LineStrRef);
}
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 LineStringExpressionContext extends ParserRuleContext {
public TerminalNode LineStrExprStart() { return getToken(FeatherParser.LineStrExprStart, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RCURL() { return getToken(FeatherParser.RCURL, 0); }
public LineStringExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lineStringExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterLineStringExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitLineStringExpression(this);
}
}
public final LineStringExpressionContext lineStringExpression() throws RecognitionException {
LineStringExpressionContext _localctx = new LineStringExpressionContext(_ctx, getState());
enterRule(_localctx, 242, RULE_lineStringExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(1726);
match(LineStrExprStart);
setState(1727);
expression();
setState(1728);
match(RCURL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MultiLineStringContentContext extends ParserRuleContext {
public Token ref;
public List<TerminalNode> MultiLineStrText() { return getTokens(FeatherParser.MultiLineStrText); }
public TerminalNode MultiLineStrText(int i) {
return getToken(FeatherParser.MultiLineStrText, i);
}
public List<TerminalNode> MultiLineStrEscapedChar() { return getTokens(FeatherParser.MultiLineStrEscapedChar); }
public TerminalNode MultiLineStrEscapedChar(int i) {
return getToken(FeatherParser.MultiLineStrEscapedChar, i);
}
public TerminalNode MultiLineStrRef() { return getToken(FeatherParser.MultiLineStrRef, 0); }
public MultiLineStringContentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_multiLineStringContent; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterMultiLineStringContent(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitMultiLineStringContent(this);
}
}
public final MultiLineStringContentContext multiLineStringContent() throws RecognitionException {
MultiLineStringContentContext _localctx = new MultiLineStringContentContext(_ctx, getState());
enterRule(_localctx, 244, RULE_multiLineStringContent);
int _la;
try {
int _alt;
setState(1736);
_errHandler.sync(this);
switch (_input.LA(1)) {
case MultiLineStrText:
case MultiLineStrEscapedChar:
enterOuterAlt(_localctx, 1);
{
setState(1731);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(1730);
_la = _input.LA(1);
if ( !(_la==MultiLineStrText || _la==MultiLineStrEscapedChar) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(1733);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,225,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
break;
case MultiLineStrRef:
enterOuterAlt(_localctx, 2);
{
setState(1735);
((MultiLineStringContentContext)_localctx).ref = match(MultiLineStrRef);
}
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 MultiLineStringExpressionContext extends ParserRuleContext {
public TerminalNode MultiLineStrExprStart() { return getToken(FeatherParser.MultiLineStrExprStart, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RCURL() { return getToken(FeatherParser.RCURL, 0); }
public MultiLineStringExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_multiLineStringExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterMultiLineStringExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitMultiLineStringExpression(this);
}
}
public final MultiLineStringExpressionContext multiLineStringExpression() throws RecognitionException {
MultiLineStringExpressionContext _localctx = new MultiLineStringExpressionContext(_ctx, getState());
enterRule(_localctx, 246, RULE_multiLineStringExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(1738);
match(MultiLineStrExprStart);
setState(1739);
expression();
setState(1740);
match(RCURL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MultiLineStringQuoteContext extends ParserRuleContext {
public TerminalNode MultiLineStringQuote() { return getToken(FeatherParser.MultiLineStringQuote, 0); }
public MultiLineStringQuoteContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_multiLineStringQuote; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterMultiLineStringQuote(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitMultiLineStringQuote(this);
}
}
public final MultiLineStringQuoteContext multiLineStringQuote() throws RecognitionException {
MultiLineStringQuoteContext _localctx = new MultiLineStringQuoteContext(_ctx, getState());
enterRule(_localctx, 248, RULE_multiLineStringQuote);
try {
enterOuterAlt(_localctx, 1);
{
setState(1742);
match(MultiLineStringQuote);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CommandLiteralContext extends ParserRuleContext {
public TerminalNode COMMAND_OPEN() { return getToken(FeatherParser.COMMAND_OPEN, 0); }
public TerminalNode COMMAND_CLOSE() { return getToken(FeatherParser.COMMAND_CLOSE, 0); }
public List<CommandContentContext> commandContent() {
return getRuleContexts(CommandContentContext.class);
}
public CommandContentContext commandContent(int i) {
return getRuleContext(CommandContentContext.class,i);
}
public List<CommandExpressionContext> commandExpression() {
return getRuleContexts(CommandExpressionContext.class);
}
public CommandExpressionContext commandExpression(int i) {
return getRuleContext(CommandExpressionContext.class,i);
}
public CommandLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_commandLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterCommandLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitCommandLiteral(this);
}
}
public final CommandLiteralContext commandLiteral() throws RecognitionException {
CommandLiteralContext _localctx = new CommandLiteralContext(_ctx, getState());
enterRule(_localctx, 250, RULE_commandLiteral);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1744);
match(COMMAND_OPEN);
setState(1749);
_errHandler.sync(this);
_la = _input.LA(1);
while (((((_la - 147)) & ~0x3f) == 0 && ((1L << (_la - 147)) & 15L) != 0)) {
{
setState(1747);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CommandRef:
case CommandText:
case CommandEscapedChar:
{
setState(1745);
commandContent();
}
break;
case CommandExprStart:
{
setState(1746);
commandExpression();
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(1751);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1752);
match(COMMAND_CLOSE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CommandContentContext extends ParserRuleContext {
public Token ref;
public List<TerminalNode> CommandText() { return getTokens(FeatherParser.CommandText); }
public TerminalNode CommandText(int i) {
return getToken(FeatherParser.CommandText, i);
}
public List<TerminalNode> CommandEscapedChar() { return getTokens(FeatherParser.CommandEscapedChar); }
public TerminalNode CommandEscapedChar(int i) {
return getToken(FeatherParser.CommandEscapedChar, i);
}
public TerminalNode CommandRef() { return getToken(FeatherParser.CommandRef, 0); }
public CommandContentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_commandContent; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterCommandContent(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitCommandContent(this);
}
}
public final CommandContentContext commandContent() throws RecognitionException {
CommandContentContext _localctx = new CommandContentContext(_ctx, getState());
enterRule(_localctx, 252, RULE_commandContent);
int _la;
try {
int _alt;
setState(1760);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CommandText:
case CommandEscapedChar:
enterOuterAlt(_localctx, 1);
{
setState(1755);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(1754);
_la = _input.LA(1);
if ( !(_la==CommandText || _la==CommandEscapedChar) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(1757);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,229,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
break;
case CommandRef:
enterOuterAlt(_localctx, 2);
{
setState(1759);
((CommandContentContext)_localctx).ref = match(CommandRef);
}
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 CommandExpressionContext extends ParserRuleContext {
public TerminalNode CommandExprStart() { return getToken(FeatherParser.CommandExprStart, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RCURL() { return getToken(FeatherParser.RCURL, 0); }
public CommandExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_commandExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterCommandExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitCommandExpression(this);
}
}
public final CommandExpressionContext commandExpression() throws RecognitionException {
CommandExpressionContext _localctx = new CommandExpressionContext(_ctx, getState());
enterRule(_localctx, 254, RULE_commandExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(1762);
match(CommandExprStart);
setState(1763);
expression();
setState(1764);
match(RCURL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class IdentifierContext extends ParserRuleContext {
public List<SimpleIdentifierContext> simpleIdentifier() {
return getRuleContexts(SimpleIdentifierContext.class);
}
public SimpleIdentifierContext simpleIdentifier(int i) {
return getRuleContext(SimpleIdentifierContext.class,i);
}
public List<TerminalNode> DOT() { return getTokens(FeatherParser.DOT); }
public TerminalNode DOT(int i) {
return getToken(FeatherParser.DOT, i);
}
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
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 FeatherParserListener ) ((FeatherParserListener)listener).enterIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitIdentifier(this);
}
}
public final IdentifierContext identifier() throws RecognitionException {
IdentifierContext _localctx = new IdentifierContext(_ctx, getState());
enterRule(_localctx, 256, RULE_identifier);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1766);
simpleIdentifier();
setState(1777);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,232,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1770);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1767);
match(NL);
}
}
setState(1772);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1773);
match(DOT);
setState(1774);
simpleIdentifier();
}
}
}
setState(1779);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,232,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SimpleIdentifierContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(FeatherParser.Identifier, 0); }
public TerminalNode CATCH() { return getToken(FeatherParser.CATCH, 0); }
public TerminalNode CONSTRUCTOR() { return getToken(FeatherParser.CONSTRUCTOR, 0); }
public TerminalNode ENUM() { return getToken(FeatherParser.ENUM, 0); }
public TerminalNode FINALLY() { return getToken(FeatherParser.FINALLY, 0); }
public TerminalNode IMPORT() { return getToken(FeatherParser.IMPORT, 0); }
public TerminalNode LIBRARY() { return getToken(FeatherParser.LIBRARY, 0); }
public SimpleIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simpleIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterSimpleIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitSimpleIdentifier(this);
}
}
public final SimpleIdentifierContext simpleIdentifier() throws RecognitionException {
SimpleIdentifierContext _localctx = new SimpleIdentifierContext(_ctx, getState());
enterRule(_localctx, 258, RULE_simpleIdentifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1780);
_la = _input.LA(1);
if ( !(((((_la - 63)) & ~0x3f) == 0 && ((1L << (_la - 63)) & 2251799847371077L) != 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 SemiContext extends ParserRuleContext {
public List<TerminalNode> NL() { return getTokens(FeatherParser.NL); }
public TerminalNode NL(int i) {
return getToken(FeatherParser.NL, i);
}
public TerminalNode SEMICOLON() { return getToken(FeatherParser.SEMICOLON, 0); }
public SemiContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_semi; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterSemi(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitSemi(this);
}
}
public final SemiContext semi() throws RecognitionException {
SemiContext _localctx = new SemiContext(_ctx, getState());
enterRule(_localctx, 260, RULE_semi);
int _la;
try {
int _alt;
setState(1800);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,236,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1783);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(1782);
match(NL);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(1785);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,233,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1790);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NL) {
{
{
setState(1787);
match(NL);
}
}
setState(1792);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1793);
match(SEMICOLON);
setState(1797);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,235,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(1794);
match(NL);
}
}
}
setState(1799);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,235,_ctx);
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AnysemiContext extends ParserRuleContext {
public TerminalNode NL() { return getToken(FeatherParser.NL, 0); }
public TerminalNode SEMICOLON() { return getToken(FeatherParser.SEMICOLON, 0); }
public AnysemiContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_anysemi; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).enterAnysemi(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof FeatherParserListener ) ((FeatherParserListener)listener).exitAnysemi(this);
}
}
public final AnysemiContext anysemi() throws RecognitionException {
AnysemiContext _localctx = new AnysemiContext(_ctx, getState());
enterRule(_localctx, 262, RULE_anysemi);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1802);
_la = _input.LA(1);
if ( !(_la==NL || _la==SEMICOLON) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
switch (ruleIndex) {
case 61:
return postfixCall_sempred((PostfixCallContext)_localctx, predIndex);
case 62:
return disjunction_sempred((DisjunctionContext)_localctx, predIndex);
case 63:
return conjunction_sempred((ConjunctionContext)_localctx, predIndex);
case 64:
return equalityComparison_sempred((EqualityComparisonContext)_localctx, predIndex);
case 67:
return elvisExpression_sempred((ElvisExpressionContext)_localctx, predIndex);
case 68:
return infixFunctionCall_sempred((InfixFunctionCallContext)_localctx, predIndex);
case 71:
return additiveExpression_sempred((AdditiveExpressionContext)_localctx, predIndex);
case 72:
return multiplicativeExpression_sempred((MultiplicativeExpressionContext)_localctx, predIndex);
case 73:
return powerExpression_sempred((PowerExpressionContext)_localctx, predIndex);
case 77:
return postfixUnaryExpression_sempred((PostfixUnaryExpressionContext)_localctx, predIndex);
}
return true;
}
private boolean postfixCall_sempred(PostfixCallContext _localctx, int predIndex) {
switch (predIndex) {
case 0:
return precpred(_ctx, 2);
}
return true;
}
private boolean disjunction_sempred(DisjunctionContext _localctx, int predIndex) {
switch (predIndex) {
case 1:
return precpred(_ctx, 2);
}
return true;
}
private boolean conjunction_sempred(ConjunctionContext _localctx, int predIndex) {
switch (predIndex) {
case 2:
return precpred(_ctx, 2);
}
return true;
}
private boolean equalityComparison_sempred(EqualityComparisonContext _localctx, int predIndex) {
switch (predIndex) {
case 3:
return precpred(_ctx, 2);
}
return true;
}
private boolean elvisExpression_sempred(ElvisExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 4:
return precpred(_ctx, 2);
}
return true;
}
private boolean infixFunctionCall_sempred(InfixFunctionCallContext _localctx, int predIndex) {
switch (predIndex) {
case 5:
return precpred(_ctx, 4);
}
return true;
}
private boolean additiveExpression_sempred(AdditiveExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 6:
return precpred(_ctx, 2);
}
return true;
}
private boolean multiplicativeExpression_sempred(MultiplicativeExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 7:
return precpred(_ctx, 2);
}
return true;
}
private boolean powerExpression_sempred(PowerExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 8:
return precpred(_ctx, 2);
}
return true;
}
private boolean postfixUnaryExpression_sempred(PostfixUnaryExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 9:
return precpred(_ctx, 5);
}
return true;
}
public static final String _serializedATN =
"\u0004\u0001\u0096\u070d\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\u0007"+
"1\u00022\u00072\u00023\u00073\u00024\u00074\u00025\u00075\u00026\u0007"+
"6\u00027\u00077\u00028\u00078\u00029\u00079\u0002:\u0007:\u0002;\u0007"+
";\u0002<\u0007<\u0002=\u0007=\u0002>\u0007>\u0002?\u0007?\u0002@\u0007"+
"@\u0002A\u0007A\u0002B\u0007B\u0002C\u0007C\u0002D\u0007D\u0002E\u0007"+
"E\u0002F\u0007F\u0002G\u0007G\u0002H\u0007H\u0002I\u0007I\u0002J\u0007"+
"J\u0002K\u0007K\u0002L\u0007L\u0002M\u0007M\u0002N\u0007N\u0002O\u0007"+
"O\u0002P\u0007P\u0002Q\u0007Q\u0002R\u0007R\u0002S\u0007S\u0002T\u0007"+
"T\u0002U\u0007U\u0002V\u0007V\u0002W\u0007W\u0002X\u0007X\u0002Y\u0007"+
"Y\u0002Z\u0007Z\u0002[\u0007[\u0002\\\u0007\\\u0002]\u0007]\u0002^\u0007"+
"^\u0002_\u0007_\u0002`\u0007`\u0002a\u0007a\u0002b\u0007b\u0002c\u0007"+
"c\u0002d\u0007d\u0002e\u0007e\u0002f\u0007f\u0002g\u0007g\u0002h\u0007"+
"h\u0002i\u0007i\u0002j\u0007j\u0002k\u0007k\u0002l\u0007l\u0002m\u0007"+
"m\u0002n\u0007n\u0002o\u0007o\u0002p\u0007p\u0002q\u0007q\u0002r\u0007"+
"r\u0002s\u0007s\u0002t\u0007t\u0002u\u0007u\u0002v\u0007v\u0002w\u0007"+
"w\u0002x\u0007x\u0002y\u0007y\u0002z\u0007z\u0002{\u0007{\u0002|\u0007"+
"|\u0002}\u0007}\u0002~\u0007~\u0002\u007f\u0007\u007f\u0002\u0080\u0007"+
"\u0080\u0002\u0081\u0007\u0081\u0002\u0082\u0007\u0082\u0002\u0083\u0007"+
"\u0083\u0001\u0000\u0003\u0000\u010a\b\u0000\u0001\u0000\u0005\u0000\u010d"+
"\b\u0000\n\u0000\f\u0000\u0110\t\u0000\u0001\u0000\u0005\u0000\u0113\b"+
"\u0000\n\u0000\f\u0000\u0116\t\u0000\u0001\u0000\u0001\u0000\u0005\u0000"+
"\u011a\b\u0000\n\u0000\f\u0000\u011d\t\u0000\u0001\u0000\u0005\u0000\u0120"+
"\b\u0000\n\u0000\f\u0000\u0123\t\u0000\u0001\u0000\u0001\u0000\u0004\u0000"+
"\u0127\b\u0000\u000b\u0000\f\u0000\u0128\u0001\u0000\u0003\u0000\u012c"+
"\b\u0000\u0005\u0000\u012e\b\u0000\n\u0000\f\u0000\u0131\t\u0000\u0003"+
"\u0000\u0133\b\u0000\u0001\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0001"+
"\u0002\u0001\u0002\u0001\u0002\u0001\u0003\u0001\u0003\u0001\u0003\u0003"+
"\u0003\u013f\b\u0003\u0003\u0003\u0141\b\u0003\u0001\u0004\u0001\u0004"+
"\u0001\u0004\u0005\u0004\u0146\b\u0004\n\u0004\f\u0004\u0149\t\u0004\u0001"+
"\u0005\u0001\u0005\u0001\u0005\u0003\u0005\u014e\b\u0005\u0001\u0006\u0001"+
"\u0006\u0003\u0006\u0152\b\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001"+
"\u0006\u0003\u0006\u0158\b\u0006\u0001\u0006\u0003\u0006\u015b\b\u0006"+
"\u0001\u0007\u0001\u0007\u0001\u0007\u0003\u0007\u0160\b\u0007\u0001\b"+
"\u0001\b\u0001\b\u0001\t\u0001\t\u0001\t\u0003\t\u0168\b\t\u0001\n\u0001"+
"\n\u0005\n\u016c\b\n\n\n\f\n\u016f\t\n\u0001\n\u0001\n\u0001\u000b\u0001"+
"\u000b\u0005\u000b\u0175\b\u000b\n\u000b\f\u000b\u0178\t\u000b\u0001\f"+
"\u0003\f\u017b\b\f\u0001\f\u0001\f\u0001\f\u0005\f\u0180\b\f\n\f\f\f\u0183"+
"\t\f\u0001\f\u0001\f\u0001\f\u0003\f\u0188\b\f\u0001\f\u0001\f\u0001\f"+
"\u0005\f\u018d\b\f\n\f\f\f\u0190\t\f\u0001\f\u0003\f\u0193\b\f\u0001\r"+
"\u0003\r\u0196\b\r\u0001\r\u0003\r\u0199\b\r\u0001\r\u0001\r\u0003\r\u019d"+
"\b\r\u0001\r\u0001\r\u0001\u000e\u0003\u000e\u01a2\b\u000e\u0001\u000e"+
"\u0003\u000e\u01a5\b\u000e\u0001\u000e\u0005\u000e\u01a8\b\u000e\n\u000e"+
"\f\u000e\u01ab\t\u000e\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f"+
"\u0005\u000f\u01b1\b\u000f\n\u000f\f\u000f\u01b4\t\u000f\u0003\u000f\u01b6"+
"\b\u000f\u0001\u000f\u0001\u000f\u0001\u0010\u0003\u0010\u01bb\b\u0010"+
"\u0001\u0010\u0001\u0010\u0003\u0010\u01bf\b\u0010\u0001\u0010\u0005\u0010"+
"\u01c2\b\u0010\n\u0010\f\u0010\u01c5\t\u0010\u0001\u0010\u0001\u0010\u0001"+
"\u0010\u0001\u0010\u0003\u0010\u01cb\b\u0010\u0001\u0011\u0001\u0011\u0005"+
"\u0011\u01cf\b\u0011\n\u0011\f\u0011\u01d2\t\u0011\u0001\u0011\u0001\u0011"+
"\u0005\u0011\u01d6\b\u0011\n\u0011\f\u0011\u01d9\t\u0011\u0001\u0011\u0005"+
"\u0011\u01dc\b\u0011\n\u0011\f\u0011\u01df\t\u0011\u0001\u0012\u0001\u0012"+
"\u0003\u0012\u01e3\b\u0012\u0001\u0013\u0001\u0013\u0005\u0013\u01e7\b"+
"\u0013\n\u0013\f\u0013\u01ea\t\u0013\u0001\u0013\u0001\u0013\u0001\u0014"+
"\u0001\u0014\u0005\u0014\u01f0\b\u0014\n\u0014\f\u0014\u01f3\t\u0014\u0001"+
"\u0014\u0003\u0014\u01f6\b\u0014\u0001\u0014\u0005\u0014\u01f9\b\u0014"+
"\n\u0014\f\u0014\u01fc\t\u0014\u0001\u0014\u0005\u0014\u01ff\b\u0014\n"+
"\u0014\f\u0014\u0202\t\u0014\u0001\u0014\u0005\u0014\u0205\b\u0014\n\u0014"+
"\f\u0014\u0208\t\u0014\u0001\u0014\u0001\u0014\u0001\u0015\u0001\u0015"+
"\u0005\u0015\u020e\b\u0015\n\u0015\f\u0015\u0211\t\u0015\u0001\u0015\u0001"+
"\u0015\u0005\u0015\u0215\b\u0015\n\u0015\f\u0015\u0218\t\u0015\u0001\u0015"+
"\u0005\u0015\u021b\b\u0015\n\u0015\f\u0015\u021e\t\u0015\u0001\u0015\u0005"+
"\u0015\u0221\b\u0015\n\u0015\f\u0015\u0224\t\u0015\u0001\u0015\u0003\u0015"+
"\u0227\b\u0015\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0017\u0001\u0017"+
"\u0001\u0017\u0001\u0017\u0005\u0017\u0230\b\u0017\n\u0017\f\u0017\u0233"+
"\t\u0017\u0003\u0017\u0235\b\u0017\u0001\u0017\u0003\u0017\u0238\b\u0017"+
"\u0001\u0018\u0001\u0018\u0005\u0018\u023c\b\u0018\n\u0018\f\u0018\u023f"+
"\t\u0018\u0001\u0018\u0001\u0018\u0005\u0018\u0243\b\u0018\n\u0018\f\u0018"+
"\u0246\t\u0018\u0001\u0018\u0001\u0018\u0005\u0018\u024a\b\u0018\n\u0018"+
"\f\u0018\u024d\t\u0018\u0001\u0018\u0005\u0018\u0250\b\u0018\n\u0018\f"+
"\u0018\u0253\t\u0018\u0001\u0018\u0001\u0018\u0001\u0019\u0001\u0019\u0003"+
"\u0019\u0259\b\u0019\u0001\u001a\u0001\u001a\u0003\u001a\u025d\b\u001a"+
"\u0001\u001b\u0001\u001b\u0003\u001b\u0261\b\u001b\u0001\u001c\u0001\u001c"+
"\u0001\u001c\u0001\u001c\u0005\u001c\u0267\b\u001c\n\u001c\f\u001c\u026a"+
"\t\u001c\u0003\u001c\u026c\b\u001c\u0001\u001c\u0001\u001c\u0001\u001c"+
"\u0001\u001d\u0001\u001d\u0003\u001d\u0273\b\u001d\u0001\u001e\u0001\u001e"+
"\u0001\u001e\u0005\u001e\u0278\b\u001e\n\u001e\f\u001e\u027b\t\u001e\u0001"+
"\u001e\u0001\u001e\u0005\u001e\u027f\b\u001e\n\u001e\f\u001e\u0282\t\u001e"+
"\u0001\u001e\u0005\u001e\u0285\b\u001e\n\u001e\f\u001e\u0288\t\u001e\u0001"+
"\u001e\u0001\u001e\u0001\u001f\u0001\u001f\u0001 \u0001 \u0001 \u0001"+
" \u0003 \u0292\b \u0001 \u0005 \u0295\b \n \f \u0298\t \u0001!\u0001!"+
"\u0005!\u029c\b!\n!\f!\u029f\t!\u0001!\u0003!\u02a2\b!\u0001\"\u0003\""+
"\u02a5\b\"\u0001\"\u0001\"\u0001\"\u0005\"\u02aa\b\"\n\"\f\"\u02ad\t\""+
"\u0001\"\u0001\"\u0005\"\u02b1\b\"\n\"\f\"\u02b4\t\"\u0001\"\u0001\"\u0005"+
"\"\u02b8\b\"\n\"\f\"\u02bb\t\"\u0001\"\u0003\"\u02be\b\"\u0001#\u0001"+
"#\u0001#\u0001#\u0005#\u02c4\b#\n#\f#\u02c7\t#\u0003#\u02c9\b#\u0001#"+
"\u0001#\u0001$\u0001$\u0005$\u02cf\b$\n$\f$\u02d2\t$\u0001$\u0001$\u0001"+
"$\u0005$\u02d7\b$\n$\f$\u02da\t$\u0001$\u0003$\u02dd\b$\u0001%\u0001%"+
"\u0005%\u02e1\b%\n%\f%\u02e4\t%\u0001%\u0001%\u0005%\u02e8\b%\n%\f%\u02eb"+
"\t%\u0001%\u0003%\u02ee\b%\u0001&\u0003&\u02f1\b&\u0001&\u0001&\u0003"+
"&\u02f5\b&\u0001&\u0001&\u0005&\u02f9\b&\n&\f&\u02fc\t&\u0001&\u0001&"+
"\u0001\'\u0005\'\u0301\b\'\n\'\f\'\u0304\t\'\u0001(\u0001(\u0005(\u0308"+
"\b(\n(\f(\u030b\t(\u0001(\u0003(\u030e\b(\u0001)\u0001)\u0005)\u0312\b"+
")\n)\f)\u0315\t)\u0001)\u0001)\u0005)\u0319\b)\n)\f)\u031c\t)\u0001)\u0001"+
")\u0005)\u0320\b)\n)\f)\u0323\t)\u0001)\u0005)\u0326\b)\n)\f)\u0329\t"+
")\u0001)\u0005)\u032c\b)\n)\f)\u032f\t)\u0001)\u0001)\u0005)\u0333\b)"+
"\n)\f)\u0336\t)\u0001*\u0001*\u0005*\u033a\b*\n*\f*\u033d\t*\u0001*\u0001"+
"*\u0005*\u0341\b*\n*\f*\u0344\t*\u0001*\u0001*\u0001+\u0001+\u0005+\u034a"+
"\b+\n+\f+\u034d\t+\u0001+\u0001+\u0001,\u0001,\u0001,\u0003,\u0354\b,"+
"\u0001-\u0001-\u0005-\u0358\b-\n-\f-\u035b\t-\u0001-\u0003-\u035e\b-\u0001"+
".\u0003.\u0361\b.\u0001.\u0001.\u0003.\u0365\b.\u0001.\u0003.\u0368\b"+
".\u0001.\u0003.\u036b\b.\u0001.\u0003.\u036e\b.\u0001.\u0001.\u0005.\u0372"+
"\b.\n.\f.\u0375\t.\u0001.\u0001.\u0005.\u0379\b.\n.\f.\u037c\t.\u0001"+
".\u0001.\u0005.\u0380\b.\n.\f.\u0383\t.\u0001.\u0001.\u0005.\u0387\b."+
"\n.\f.\u038a\t.\u0001.\u0003.\u038d\b.\u0001/\u0001/\u0001/\u0001/\u0005"+
"/\u0393\b/\n/\f/\u0396\t/\u0003/\u0398\b/\u0001/\u0001/\u00010\u00010"+
"\u00010\u00010\u00030\u03a0\b0\u00011\u00011\u00011\u00051\u03a5\b1\n"+
"1\f1\u03a8\t1\u00011\u00031\u03ab\b1\u00012\u00012\u00013\u00013\u0001"+
"3\u00013\u00014\u00014\u00034\u03b5\b4\u00015\u00055\u03b8\b5\n5\f5\u03bb"+
"\t5\u00015\u00015\u00045\u03bf\b5\u000b5\f5\u03c0\u00015\u00035\u03c4"+
"\b5\u00055\u03c6\b5\n5\f5\u03c9\t5\u00035\u03cb\b5\u00016\u00016\u0003"+
"6\u03cf\b6\u00017\u00017\u00057\u03d3\b7\n7\f7\u03d6\t7\u00017\u00017"+
"\u00057\u03da\b7\n7\f7\u03dd\t7\u00017\u00017\u00057\u03e1\b7\n7\f7\u03e4"+
"\t7\u00017\u00037\u03e7\b7\u00018\u00018\u00058\u03eb\b8\n8\f8\u03ee\t"+
"8\u00018\u00018\u00019\u00019\u00039\u03f4\b9\u0001:\u0001:\u0001;\u0001"+
";\u0001<\u0001<\u0001<\u0001<\u0001<\u0001<\u0001<\u0001<\u0001<\u0005"+
"<\u0403\b<\n<\f<\u0406\t<\u0003<\u0408\b<\u0001=\u0001=\u0001=\u0001="+
"\u0001=\u0001=\u0005=\u0410\b=\n=\f=\u0413\t=\u0001=\u0001=\u0001=\u0005"+
"=\u0418\b=\n=\f=\u041b\t=\u0001>\u0001>\u0001>\u0001>\u0001>\u0005>\u0422"+
"\b>\n>\f>\u0425\t>\u0001>\u0001>\u0005>\u0429\b>\n>\f>\u042c\t>\u0001"+
">\u0005>\u042f\b>\n>\f>\u0432\t>\u0001?\u0001?\u0001?\u0001?\u0001?\u0005"+
"?\u0439\b?\n?\f?\u043c\t?\u0001?\u0001?\u0005?\u0440\b?\n?\f?\u0443\t"+
"?\u0001?\u0005?\u0446\b?\n?\f?\u0449\t?\u0001@\u0001@\u0001@\u0001@\u0001"+
"@\u0001@\u0005@\u0451\b@\n@\f@\u0454\t@\u0001@\u0005@\u0457\b@\n@\f@\u045a"+
"\t@\u0001A\u0001A\u0001A\u0005A\u045f\bA\nA\fA\u0462\tA\u0001A\u0003A"+
"\u0465\bA\u0001B\u0001B\u0001B\u0005B\u046a\bB\nB\fB\u046d\tB\u0001B\u0003"+
"B\u0470\bB\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0005C\u0478\bC\n"+
"C\fC\u047b\tC\u0001C\u0005C\u047e\bC\nC\fC\u0481\tC\u0001D\u0001D\u0001"+
"D\u0001D\u0003D\u0487\bD\u0001D\u0001D\u0001D\u0005D\u048c\bD\nD\fD\u048f"+
"\tD\u0001D\u0001D\u0005D\u0493\bD\nD\fD\u0496\tD\u0001E\u0001E\u0001E"+
"\u0005E\u049b\bE\nE\fE\u049e\tE\u0001E\u0001E\u0001F\u0001F\u0001F\u0005"+
"F\u04a5\bF\nF\fF\u04a8\tF\u0001F\u0001F\u0001G\u0001G\u0001G\u0001G\u0001"+
"G\u0001G\u0005G\u04b2\bG\nG\fG\u04b5\tG\u0001G\u0005G\u04b8\bG\nG\fG\u04bb"+
"\tG\u0001H\u0001H\u0001H\u0001H\u0001H\u0001H\u0005H\u04c3\bH\nH\fH\u04c6"+
"\tH\u0001H\u0005H\u04c9\bH\nH\fH\u04cc\tH\u0001I\u0001I\u0001I\u0001I"+
"\u0001I\u0001I\u0005I\u04d4\bI\nI\fI\u04d7\tI\u0001I\u0005I\u04da\bI\n"+
"I\fI\u04dd\tI\u0001J\u0001J\u0005J\u04e1\bJ\nJ\fJ\u04e4\tJ\u0001J\u0001"+
"J\u0003J\u04e8\bJ\u0001K\u0001K\u0005K\u04ec\bK\nK\fK\u04ef\tK\u0001K"+
"\u0001K\u0003K\u04f3\bK\u0001L\u0001L\u0003L\u04f7\bL\u0001M\u0001M\u0001"+
"M\u0001M\u0001M\u0003M\u04fe\bM\u0001M\u0001M\u0005M\u0502\bM\nM\fM\u0505"+
"\tM\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0003M\u050d\bM\u0005M\u050f"+
"\bM\nM\fM\u0512\tM\u0001N\u0001N\u0001N\u0001N\u0001O\u0001O\u0001O\u0001"+
"P\u0003P\u051c\bP\u0001P\u0001P\u0001P\u0001P\u0001P\u0001P\u0005P\u0524"+
"\bP\nP\fP\u0527\tP\u0003P\u0529\bP\u0001P\u0003P\u052c\bP\u0001Q\u0001"+
"Q\u0001Q\u0001Q\u0001Q\u0001Q\u0005Q\u0534\bQ\nQ\fQ\u0537\tQ\u0003Q\u0539"+
"\bQ\u0001Q\u0003Q\u053c\bQ\u0001R\u0001R\u0005R\u0540\bR\nR\fR\u0543\t"+
"R\u0001R\u0001R\u0001S\u0001S\u0001S\u0001T\u0001T\u0005T\u054c\bT\nT"+
"\fT\u054f\tT\u0001T\u0001T\u0001U\u0001U\u0001U\u0001U\u0001U\u0001V\u0001"+
"V\u0001V\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0003"+
"W\u0563\bW\u0001X\u0003X\u0566\bX\u0001X\u0001X\u0001Y\u0001Y\u0001Y\u0001"+
"Y\u0005Y\u056e\bY\nY\fY\u0571\tY\u0003Y\u0573\bY\u0001Y\u0001Y\u0001Z"+
"\u0005Z\u0578\bZ\nZ\fZ\u057b\tZ\u0001Z\u0001Z\u0001[\u0001[\u0001[\u0001"+
"[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001[\u0003[\u0589\b[\u0001\\\u0001"+
"\\\u0001]\u0001]\u0001^\u0001^\u0001_\u0001_\u0001_\u0001_\u0001`\u0001"+
"`\u0005`\u0597\b`\n`\f`\u059a\t`\u0001`\u0001`\u0005`\u059e\b`\n`\f`\u05a1"+
"\t`\u0001`\u0005`\u05a4\b`\n`\f`\u05a7\t`\u0001`\u0003`\u05aa\b`\u0001"+
"`\u0003`\u05ad\b`\u0001`\u0005`\u05b0\b`\n`\f`\u05b3\t`\u0001`\u0001`"+
"\u0005`\u05b7\b`\n`\f`\u05ba\t`\u0001`\u0003`\u05bd\b`\u0001a\u0001a\u0001"+
"a\u0001b\u0001b\u0001b\u0005b\u05c5\bb\nb\fb\u05c8\tb\u0001b\u0001b\u0005"+
"b\u05cc\bb\nb\fb\u05cf\tb\u0001b\u0001b\u0001b\u0001b\u0001b\u0001b\u0005"+
"b\u05d7\bb\nb\fb\u05da\tb\u0001b\u0001b\u0005b\u05de\bb\nb\fb\u05e1\t"+
"b\u0001b\u0001b\u0001b\u0001b\u0001b\u0001b\u0001b\u0001b\u0005b\u05eb"+
"\bb\nb\fb\u05ee\tb\u0001b\u0001b\u0005b\u05f2\bb\nb\fb\u05f5\tb\u0001"+
"b\u0001b\u0001b\u0001b\u0001b\u0001b\u0001b\u0001b\u0005b\u05ff\bb\nb"+
"\fb\u0602\tb\u0001b\u0001b\u0005b\u0606\bb\nb\fb\u0609\tb\u0001b\u0001"+
"b\u0001b\u0003b\u060e\bb\u0001c\u0003c\u0611\bc\u0001d\u0001d\u0005d\u0615"+
"\bd\nd\fd\u0618\td\u0001d\u0001d\u0001d\u0001d\u0005d\u061e\bd\nd\fd\u0621"+
"\td\u0001d\u0001d\u0001e\u0001e\u0005e\u0627\be\ne\fe\u062a\te\u0001e"+
"\u0001e\u0005e\u062e\be\ne\fe\u0631\te\u0001e\u0001e\u0005e\u0635\be\n"+
"e\fe\u0638\te\u0001e\u0001e\u0001e\u0001e\u0003e\u063e\be\u0001f\u0001"+
"f\u0005f\u0642\bf\nf\ff\u0645\tf\u0001f\u0001f\u0005f\u0649\bf\nf\ff\u064c"+
"\tf\u0001f\u0005f\u064f\bf\nf\ff\u0652\tf\u0001f\u0005f\u0655\bf\nf\f"+
"f\u0658\tf\u0001f\u0003f\u065b\bf\u0001g\u0001g\u0001h\u0001h\u0005h\u0661"+
"\bh\nh\fh\u0664\th\u0001h\u0001h\u0001h\u0001h\u0001h\u0001h\u0005h\u066c"+
"\bh\nh\fh\u066f\th\u0001h\u0001h\u0001i\u0001i\u0005i\u0675\bi\ni\fi\u0678"+
"\ti\u0001i\u0001i\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001"+
"j\u0001j\u0001j\u0001j\u0001j\u0003j\u0688\bj\u0001k\u0001k\u0001l\u0001"+
"l\u0001m\u0001m\u0001n\u0001n\u0001o\u0001o\u0001p\u0001p\u0001q\u0001"+
"q\u0001r\u0001r\u0001s\u0001s\u0001t\u0001t\u0001u\u0001u\u0003u\u06a0"+
"\bu\u0001v\u0001v\u0001v\u0005v\u06a5\bv\nv\fv\u06a8\tv\u0001v\u0001v"+
"\u0001w\u0001w\u0001w\u0001w\u0005w\u06b0\bw\nw\fw\u06b3\tw\u0001w\u0001"+
"w\u0001x\u0004x\u06b8\bx\u000bx\fx\u06b9\u0001x\u0003x\u06bd\bx\u0001"+
"y\u0001y\u0001y\u0001y\u0001z\u0004z\u06c4\bz\u000bz\fz\u06c5\u0001z\u0003"+
"z\u06c9\bz\u0001{\u0001{\u0001{\u0001{\u0001|\u0001|\u0001}\u0001}\u0001"+
"}\u0005}\u06d4\b}\n}\f}\u06d7\t}\u0001}\u0001}\u0001~\u0004~\u06dc\b~"+
"\u000b~\f~\u06dd\u0001~\u0003~\u06e1\b~\u0001\u007f\u0001\u007f\u0001"+
"\u007f\u0001\u007f\u0001\u0080\u0001\u0080\u0005\u0080\u06e9\b\u0080\n"+
"\u0080\f\u0080\u06ec\t\u0080\u0001\u0080\u0001\u0080\u0005\u0080\u06f0"+
"\b\u0080\n\u0080\f\u0080\u06f3\t\u0080\u0001\u0081\u0001\u0081\u0001\u0082"+
"\u0004\u0082\u06f8\b\u0082\u000b\u0082\f\u0082\u06f9\u0001\u0082\u0005"+
"\u0082\u06fd\b\u0082\n\u0082\f\u0082\u0700\t\u0082\u0001\u0082\u0001\u0082"+
"\u0005\u0082\u0704\b\u0082\n\u0082\f\u0082\u0707\t\u0082\u0003\u0082\u0709"+
"\b\u0082\u0001\u0083\u0001\u0083\u0001\u0083\u0000\nz|~\u0080\u0086\u0088"+
"\u008e\u0090\u0092\u009a\u0084\u0000\u0002\u0004\u0006\b\n\f\u000e\u0010"+
"\u0012\u0014\u0016\u0018\u001a\u001c\u001e \"$&(*,.02468:<>@BDFHJLNPR"+
"TVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c\u008e"+
"\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6"+
"\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc\u00be"+
"\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4\u00d6"+
"\u00d8\u00da\u00dc\u00de\u00e0\u00e2\u00e4\u00e6\u00e8\u00ea\u00ec\u00ee"+
"\u00f0\u00f2\u00f4\u00f6\u00f8\u00fa\u00fc\u00fe\u0100\u0102\u0104\u0106"+
"\u0000\u0015\u0002\u0000FFUU\u0002\u0000;;EE\u0001\u0000_`\u0002\u0000"+
"@@ZZ\u0002\u0000IJTT\u0001\u0000$*\u0003\u0000\u001d\u001d3467\u0001\u0000"+
".2\u0001\u0000NO\u0002\u000088LM\u0001\u0000+,\u0001\u0000\u0018\u0019"+
"\u0002\u0000\u0012\u0014\u0016\u0016\u0002\u000055==\u0002\u0000\u0018"+
"\u001b\u001f\u001f\u0001\u0000\u001a\u001b\u0001\u0000\u0084\u0085\u0001"+
"\u0000\u008a\u008b\u0001\u0000\u0094\u0095\u0007\u0000??AAEEGGPPXXrr\u0002"+
"\u0000\u0006\u0006##\u079b\u0000\u0109\u0001\u0000\u0000\u0000\u0002\u0136"+
"\u0001\u0000\u0000\u0000\u0004\u0138\u0001\u0000\u0000\u0000\u0006\u0140"+
"\u0001\u0000\u0000\u0000\b\u0147\u0001\u0000\u0000\u0000\n\u014a\u0001"+
"\u0000\u0000\u0000\f\u014f\u0001\u0000\u0000\u0000\u000e\u015c\u0001\u0000"+
"\u0000\u0000\u0010\u0161\u0001\u0000\u0000\u0000\u0012\u0167\u0001\u0000"+
"\u0000\u0000\u0014\u0169\u0001\u0000\u0000\u0000\u0016\u0172\u0001\u0000"+
"\u0000\u0000\u0018\u017a\u0001\u0000\u0000\u0000\u001a\u019c\u0001\u0000"+
"\u0000\u0000\u001c\u01a1\u0001\u0000\u0000\u0000\u001e\u01ac\u0001\u0000"+
"\u0000\u0000 \u01ba\u0001\u0000\u0000\u0000\"\u01cc\u0001\u0000\u0000"+
"\u0000$\u01e2\u0001\u0000\u0000\u0000&\u01e4\u0001\u0000\u0000\u0000("+
"\u01ed\u0001\u0000\u0000\u0000*\u020b\u0001\u0000\u0000\u0000,\u0228\u0001"+
"\u0000\u0000\u0000.\u0237\u0001\u0000\u0000\u00000\u0239\u0001\u0000\u0000"+
"\u00002\u0258\u0001\u0000\u0000\u00004\u025c\u0001\u0000\u0000\u00006"+
"\u025e\u0001\u0000\u0000\u00008\u0262\u0001\u0000\u0000\u0000:\u0272\u0001"+
"\u0000\u0000\u0000<\u0274\u0001\u0000\u0000\u0000>\u028b\u0001\u0000\u0000"+
"\u0000@\u0291\u0001\u0000\u0000\u0000B\u0299\u0001\u0000\u0000\u0000D"+
"\u02a4\u0001\u0000\u0000\u0000F\u02bf\u0001\u0000\u0000\u0000H\u02dc\u0001"+
"\u0000\u0000\u0000J\u02de\u0001\u0000\u0000\u0000L\u02f0\u0001\u0000\u0000"+
"\u0000N\u0302\u0001\u0000\u0000\u0000P\u0305\u0001\u0000\u0000\u0000R"+
"\u030f\u0001\u0000\u0000\u0000T\u0337\u0001\u0000\u0000\u0000V\u0347\u0001"+
"\u0000\u0000\u0000X\u0350\u0001\u0000\u0000\u0000Z\u0355\u0001\u0000\u0000"+
"\u0000\\\u0360\u0001\u0000\u0000\u0000^\u038e\u0001\u0000\u0000\u0000"+
"`\u039b\u0001\u0000\u0000\u0000b\u03aa\u0001\u0000\u0000\u0000d\u03ac"+
"\u0001\u0000\u0000\u0000f\u03ae\u0001\u0000\u0000\u0000h\u03b4\u0001\u0000"+
"\u0000\u0000j\u03b9\u0001\u0000\u0000\u0000l\u03ce\u0001\u0000\u0000\u0000"+
"n\u03d0\u0001\u0000\u0000\u0000p\u03e8\u0001\u0000\u0000\u0000r\u03f1"+
"\u0001\u0000\u0000\u0000t\u03f5\u0001\u0000\u0000\u0000v\u03f7\u0001\u0000"+
"\u0000\u0000x\u0407\u0001\u0000\u0000\u0000z\u0409\u0001\u0000\u0000\u0000"+
"|\u041c\u0001\u0000\u0000\u0000~\u0433\u0001\u0000\u0000\u0000\u0080\u044a"+
"\u0001\u0000\u0000\u0000\u0082\u045b\u0001\u0000\u0000\u0000\u0084\u0466"+
"\u0001\u0000\u0000\u0000\u0086\u0471\u0001\u0000\u0000\u0000\u0088\u0486"+
"\u0001\u0000\u0000\u0000\u008a\u0497\u0001\u0000\u0000\u0000\u008c\u04a1"+
"\u0001\u0000\u0000\u0000\u008e\u04ab\u0001\u0000\u0000\u0000\u0090\u04bc"+
"\u0001\u0000\u0000\u0000\u0092\u04cd\u0001\u0000\u0000\u0000\u0094\u04de"+
"\u0001\u0000\u0000\u0000\u0096\u04f2\u0001\u0000\u0000\u0000\u0098\u04f4"+
"\u0001\u0000\u0000\u0000\u009a\u04fd\u0001\u0000\u0000\u0000\u009c\u0513"+
"\u0001\u0000\u0000\u0000\u009e\u0517\u0001\u0000\u0000\u0000\u00a0\u051b"+
"\u0001\u0000\u0000\u0000\u00a2\u052d\u0001\u0000\u0000\u0000\u00a4\u053d"+
"\u0001\u0000\u0000\u0000\u00a6\u0546\u0001\u0000\u0000\u0000\u00a8\u0549"+
"\u0001\u0000\u0000\u0000\u00aa\u0552\u0001\u0000\u0000\u0000\u00ac\u0557"+
"\u0001\u0000\u0000\u0000\u00ae\u0562\u0001\u0000\u0000\u0000\u00b0\u0565"+
"\u0001\u0000\u0000\u0000\u00b2\u0569\u0001\u0000\u0000\u0000\u00b4\u0579"+
"\u0001\u0000\u0000\u0000\u00b6\u0588\u0001\u0000\u0000\u0000\u00b8\u058a"+
"\u0001\u0000\u0000\u0000\u00ba\u058c\u0001\u0000\u0000\u0000\u00bc\u058e"+
"\u0001\u0000\u0000\u0000\u00be\u0590\u0001\u0000\u0000\u0000\u00c0\u0594"+
"\u0001\u0000\u0000\u0000\u00c2\u05be\u0001\u0000\u0000\u0000\u00c4\u060d"+
"\u0001\u0000\u0000\u0000\u00c6\u0610\u0001\u0000\u0000\u0000\u00c8\u0612"+
"\u0001\u0000\u0000\u0000\u00ca\u0624\u0001\u0000\u0000\u0000\u00cc\u063f"+
"\u0001\u0000\u0000\u0000\u00ce\u065c\u0001\u0000\u0000\u0000\u00d0\u065e"+
"\u0001\u0000\u0000\u0000\u00d2\u0672\u0001\u0000\u0000\u0000\u00d4\u0687"+
"\u0001\u0000\u0000\u0000\u00d6\u0689\u0001\u0000\u0000\u0000\u00d8\u068b"+
"\u0001\u0000\u0000\u0000\u00da\u068d\u0001\u0000\u0000\u0000\u00dc\u068f"+
"\u0001\u0000\u0000\u0000\u00de\u0691\u0001\u0000\u0000\u0000\u00e0\u0693"+
"\u0001\u0000\u0000\u0000\u00e2\u0695\u0001\u0000\u0000\u0000\u00e4\u0697"+
"\u0001\u0000\u0000\u0000\u00e6\u0699\u0001\u0000\u0000\u0000\u00e8\u069b"+
"\u0001\u0000\u0000\u0000\u00ea\u069f\u0001\u0000\u0000\u0000\u00ec\u06a1"+
"\u0001\u0000\u0000\u0000\u00ee\u06ab\u0001\u0000\u0000\u0000\u00f0\u06bc"+
"\u0001\u0000\u0000\u0000\u00f2\u06be\u0001\u0000\u0000\u0000\u00f4\u06c8"+
"\u0001\u0000\u0000\u0000\u00f6\u06ca\u0001\u0000\u0000\u0000\u00f8\u06ce"+
"\u0001\u0000\u0000\u0000\u00fa\u06d0\u0001\u0000\u0000\u0000\u00fc\u06e0"+
"\u0001\u0000\u0000\u0000\u00fe\u06e2\u0001\u0000\u0000\u0000\u0100\u06e6"+
"\u0001\u0000\u0000\u0000\u0102\u06f4\u0001\u0000\u0000\u0000\u0104\u0708"+
"\u0001\u0000\u0000\u0000\u0106\u070a\u0001\u0000\u0000\u0000\u0108\u010a"+
"\u0003\u0002\u0001\u0000\u0109\u0108\u0001\u0000\u0000\u0000\u0109\u010a"+
"\u0001\u0000\u0000\u0000\u010a\u010e\u0001\u0000\u0000\u0000\u010b\u010d"+
"\u0005\u0006\u0000\u0000\u010c\u010b\u0001\u0000\u0000\u0000\u010d\u0110"+
"\u0001\u0000\u0000\u0000\u010e\u010c\u0001\u0000\u0000\u0000\u010e\u010f"+
"\u0001\u0000\u0000\u0000\u010f\u0114\u0001\u0000\u0000\u0000\u0110\u010e"+
"\u0001\u0000\u0000\u0000\u0111\u0113\u0003\u0106\u0083\u0000\u0112\u0111"+
"\u0001\u0000\u0000\u0000\u0113\u0116\u0001\u0000\u0000\u0000\u0114\u0112"+
"\u0001\u0000\u0000\u0000\u0114\u0115\u0001\u0000\u0000\u0000\u0115\u0117"+
"\u0001\u0000\u0000\u0000\u0116\u0114\u0001\u0000\u0000\u0000\u0117\u011b"+
"\u0003\u0004\u0002\u0000\u0118\u011a\u0005\u0006\u0000\u0000\u0119\u0118"+
"\u0001\u0000\u0000\u0000\u011a\u011d\u0001\u0000\u0000\u0000\u011b\u0119"+
"\u0001\u0000\u0000\u0000\u011b\u011c\u0001\u0000\u0000\u0000\u011c\u0121"+
"\u0001\u0000\u0000\u0000\u011d\u011b\u0001\u0000\u0000\u0000\u011e\u0120"+
"\u0003\u0106\u0083\u0000\u011f\u011e\u0001\u0000\u0000\u0000\u0120\u0123"+
"\u0001\u0000\u0000\u0000\u0121\u011f\u0001\u0000\u0000\u0000\u0121\u0122"+
"\u0001\u0000\u0000\u0000\u0122\u0132\u0001\u0000\u0000\u0000\u0123\u0121"+
"\u0001\u0000\u0000\u0000\u0124\u012f\u0003\u0012\t\u0000\u0125\u0127\u0003"+
"\u0106\u0083\u0000\u0126\u0125\u0001\u0000\u0000\u0000\u0127\u0128\u0001"+
"\u0000\u0000\u0000\u0128\u0126\u0001\u0000\u0000\u0000\u0128\u0129\u0001"+
"\u0000\u0000\u0000\u0129\u012b\u0001\u0000\u0000\u0000\u012a\u012c\u0003"+
"\u0012\t\u0000\u012b\u012a\u0001\u0000\u0000\u0000\u012b\u012c\u0001\u0000"+
"\u0000\u0000\u012c\u012e\u0001\u0000\u0000\u0000\u012d\u0126\u0001\u0000"+
"\u0000\u0000\u012e\u0131\u0001\u0000\u0000\u0000\u012f\u012d\u0001\u0000"+
"\u0000\u0000\u012f\u0130\u0001\u0000\u0000\u0000\u0130\u0133\u0001\u0000"+
"\u0000\u0000\u0131\u012f\u0001\u0000\u0000\u0000\u0132\u0124\u0001\u0000"+
"\u0000\u0000\u0132\u0133\u0001\u0000\u0000\u0000\u0133\u0134\u0001\u0000"+
"\u0000\u0000\u0134\u0135\u0005\u0000\u0000\u0001\u0135\u0001\u0001\u0000"+
"\u0000\u0000\u0136\u0137\u0005\u0001\u0000\u0000\u0137\u0003\u0001\u0000"+
"\u0000\u0000\u0138\u0139\u0003\u0006\u0003\u0000\u0139\u013a\u0003\b\u0004"+
"\u0000\u013a\u0005\u0001\u0000\u0000\u0000\u013b\u013c\u0005W\u0000\u0000"+
"\u013c\u013e\u0003\u0100\u0080\u0000\u013d\u013f\u0003\u0104\u0082\u0000"+
"\u013e\u013d\u0001\u0000\u0000\u0000\u013e\u013f\u0001\u0000\u0000\u0000"+
"\u013f\u0141\u0001\u0000\u0000\u0000\u0140\u013b\u0001\u0000\u0000\u0000"+
"\u0140\u0141\u0001\u0000\u0000\u0000\u0141\u0007\u0001\u0000\u0000\u0000"+
"\u0142\u0146\u0003\n\u0005\u0000\u0143\u0146\u0003\u000e\u0007\u0000\u0144"+
"\u0146\u0003\f\u0006\u0000\u0145\u0142\u0001\u0000\u0000\u0000\u0145\u0143"+
"\u0001\u0000\u0000\u0000\u0145\u0144\u0001\u0000\u0000\u0000\u0146\u0149"+
"\u0001\u0000\u0000\u0000\u0147\u0145\u0001\u0000\u0000\u0000\u0147\u0148"+
"\u0001\u0000\u0000\u0000\u0148\t\u0001\u0000\u0000\u0000\u0149\u0147\u0001"+
"\u0000\u0000\u0000\u014a\u014b\u0005X\u0000\u0000\u014b\u014d\u0005~\u0000"+
"\u0000\u014c\u014e\u0003\u0104\u0082\u0000\u014d\u014c\u0001\u0000\u0000"+
"\u0000\u014d\u014e\u0001\u0000\u0000\u0000\u014e\u000b\u0001\u0000\u0000"+
"\u0000\u014f\u0151\u0005P\u0000\u0000\u0150\u0152\u0005Z\u0000\u0000\u0151"+
"\u0150\u0001\u0000\u0000\u0000\u0151\u0152\u0001\u0000\u0000\u0000\u0152"+
"\u0153\u0001\u0000\u0000\u0000\u0153\u0157\u0003\u0100\u0080\u0000\u0154"+
"\u0155\u0005\u0007\u0000\u0000\u0155\u0158\u0005\u0012\u0000\u0000\u0156"+
"\u0158\u0003\u0010\b\u0000\u0157\u0154\u0001\u0000\u0000\u0000\u0157\u0156"+
"\u0001\u0000\u0000\u0000\u0157\u0158\u0001\u0000\u0000\u0000\u0158\u015a"+
"\u0001\u0000\u0000\u0000\u0159\u015b\u0003\u0104\u0082\u0000\u015a\u0159"+
"\u0001\u0000\u0000\u0000\u015a\u015b\u0001\u0000\u0000\u0000\u015b\r\u0001"+
"\u0000\u0000\u0000\u015c\u015d\u0005Q\u0000\u0000\u015d\u015f\u0005~\u0000"+
"\u0000\u015e\u0160\u0003\u0104\u0082\u0000\u015f\u015e\u0001\u0000\u0000"+
"\u0000\u015f\u0160\u0001\u0000\u0000\u0000\u0160\u000f\u0001\u0000\u0000"+
"\u0000\u0161\u0162\u0005=\u0000\u0000\u0162\u0163\u0003\u0102\u0081\u0000"+
"\u0163\u0011\u0001\u0000\u0000\u0000\u0164\u0168\u0003\u0014\n\u0000\u0165"+
"\u0168\u0003J%\u0000\u0166\u0168\u0003Z-\u0000\u0167\u0164\u0001\u0000"+
"\u0000\u0000\u0167\u0165\u0001\u0000\u0000\u0000\u0167\u0166\u0001\u0000"+
"\u0000\u0000\u0168\u0013\u0001\u0000\u0000\u0000\u0169\u016d\u0003\u0018"+
"\f\u0000\u016a\u016c\u0005\u0006\u0000\u0000\u016b\u016a\u0001\u0000\u0000"+
"\u0000\u016c\u016f\u0001\u0000\u0000\u0000\u016d\u016b\u0001\u0000\u0000"+
"\u0000\u016d\u016e\u0001\u0000\u0000\u0000\u016e\u0170\u0001\u0000\u0000"+
"\u0000\u016f\u016d\u0001\u0000\u0000\u0000\u0170\u0171\u0003(\u0014\u0000"+
"\u0171\u0015\u0001\u0000\u0000\u0000\u0172\u0176\u0005\u0002\u0000\u0000"+
"\u0173\u0175\u0005\u0006\u0000\u0000\u0174\u0173\u0001\u0000\u0000\u0000"+
"\u0175\u0178\u0001\u0000\u0000\u0000\u0176\u0174\u0001\u0000\u0000\u0000"+
"\u0176\u0177\u0001\u0000\u0000\u0000\u0177\u0017\u0001\u0000\u0000\u0000"+
"\u0178\u0176\u0001\u0000\u0000\u0000\u0179\u017b\u0003\u0016\u000b\u0000"+
"\u017a\u0179\u0001\u0000\u0000\u0000\u017a\u017b\u0001\u0000\u0000\u0000"+
"\u017b\u017c\u0001\u0000\u0000\u0000\u017c\u017d\u0003N\'\u0000\u017d"+
"\u0181\u0003\u001a\r\u0000\u017e\u0180\u0005\u0006\u0000\u0000\u017f\u017e"+
"\u0001\u0000\u0000\u0000\u0180\u0183\u0001\u0000\u0000\u0000\u0181\u017f"+
"\u0001\u0000\u0000\u0000\u0181\u0182\u0001\u0000\u0000\u0000\u0182\u0187"+
"\u0001\u0000\u0000\u0000\u0183\u0181\u0001\u0000\u0000\u0000\u0184\u0185"+
"\u0003N\'\u0000\u0185\u0186\u0005A\u0000\u0000\u0186\u0188\u0001\u0000"+
"\u0000\u0000\u0187\u0184\u0001\u0000\u0000\u0000\u0187\u0188\u0001\u0000"+
"\u0000\u0000\u0188\u0189\u0001\u0000\u0000\u0000\u0189\u0192\u0003\u001c"+
"\u000e\u0000\u018a\u018e\u0005 \u0000\u0000\u018b\u018d\u0005\u0006\u0000"+
"\u0000\u018c\u018b\u0001\u0000\u0000\u0000\u018d\u0190\u0001\u0000\u0000"+
"\u0000\u018e\u018c\u0001\u0000\u0000\u0000\u018e\u018f\u0001\u0000\u0000"+
"\u0000\u018f\u0191\u0001\u0000\u0000\u0000\u0190\u018e\u0001\u0000\u0000"+
"\u0000\u0191\u0193\u0003\"\u0011\u0000\u0192\u018a\u0001\u0000\u0000\u0000"+
"\u0192\u0193\u0001\u0000\u0000\u0000\u0193\u0019\u0001\u0000\u0000\u0000"+
"\u0194\u0196\u0007\u0000\u0000\u0000\u0195\u0194\u0001\u0000\u0000\u0000"+
"\u0195\u0196\u0001\u0000\u0000\u0000\u0196\u0198\u0001\u0000\u0000\u0000"+
"\u0197\u0199\u0007\u0001\u0000\u0000\u0198\u0197\u0001\u0000\u0000\u0000"+
"\u0198\u0199\u0001\u0000\u0000\u0000\u0199\u019a\u0001\u0000\u0000\u0000"+
"\u019a\u019d\u0005@\u0000\u0000\u019b\u019d\u0005R\u0000\u0000\u019c\u0195"+
"\u0001\u0000\u0000\u0000\u019c\u019b\u0001\u0000\u0000\u0000\u019d\u019e"+
"\u0001\u0000\u0000\u0000\u019e\u019f\u0003\u0102\u0081\u0000\u019f\u001b"+
"\u0001\u0000\u0000\u0000\u01a0\u01a2\u0003\u0016\u000b\u0000\u01a1\u01a0"+
"\u0001\u0000\u0000\u0000\u01a1\u01a2\u0001\u0000\u0000\u0000\u01a2\u01a4"+
"\u0001\u0000\u0000\u0000\u01a3\u01a5\u0003\u001e\u000f\u0000\u01a4\u01a3"+
"\u0001\u0000\u0000\u0000\u01a4\u01a5\u0001\u0000\u0000\u0000\u01a5\u01a9"+
"\u0001\u0000\u0000\u0000\u01a6\u01a8\u0005\u0006\u0000\u0000\u01a7\u01a6"+
"\u0001\u0000\u0000\u0000\u01a8\u01ab\u0001\u0000\u0000\u0000\u01a9\u01a7"+
"\u0001\u0000\u0000\u0000\u01a9\u01aa\u0001\u0000\u0000\u0000\u01aa\u001d"+
"\u0001\u0000\u0000\u0000\u01ab\u01a9\u0001\u0000\u0000\u0000\u01ac\u01b5"+
"\u0005\t\u0000\u0000\u01ad\u01b2\u0003 \u0010\u0000\u01ae\u01af\u0005"+
"\b\u0000\u0000\u01af\u01b1\u0003 \u0010\u0000\u01b0\u01ae\u0001\u0000"+
"\u0000\u0000\u01b1\u01b4\u0001\u0000\u0000\u0000\u01b2\u01b0\u0001\u0000"+
"\u0000\u0000\u01b2\u01b3\u0001\u0000\u0000\u0000\u01b3\u01b6\u0001\u0000"+
"\u0000\u0000\u01b4\u01b2\u0001\u0000\u0000\u0000\u01b5\u01ad\u0001\u0000"+
"\u0000\u0000\u01b5\u01b6\u0001\u0000\u0000\u0000\u01b6\u01b7\u0001\u0000"+
"\u0000\u0000\u01b7\u01b8\u0005\n\u0000\u0000\u01b8\u001f\u0001\u0000\u0000"+
"\u0000\u01b9\u01bb\u0003\u0016\u000b\u0000\u01ba\u01b9\u0001\u0000\u0000"+
"\u0000\u01ba\u01bb\u0001\u0000\u0000\u0000\u01bb\u01bc\u0001\u0000\u0000"+
"\u0000\u01bc\u01be\u0003N\'\u0000\u01bd\u01bf\u0007\u0002\u0000\u0000"+
"\u01be\u01bd\u0001\u0000\u0000\u0000\u01be\u01bf\u0001\u0000\u0000\u0000"+
"\u01bf\u01c3\u0001\u0000\u0000\u0000\u01c0\u01c2\u0005\u0006\u0000\u0000"+
"\u01c1\u01c0\u0001\u0000\u0000\u0000\u01c2\u01c5\u0001\u0000\u0000\u0000"+
"\u01c3\u01c1\u0001\u0000\u0000\u0000\u01c3\u01c4\u0001\u0000\u0000\u0000"+
"\u01c4\u01c6\u0001\u0000\u0000\u0000\u01c5\u01c3\u0001\u0000\u0000\u0000"+
"\u01c6\u01c7\u0003\u0102\u0081\u0000\u01c7\u01c8\u0005 \u0000\u0000\u01c8"+
"\u01ca\u00034\u001a\u0000\u01c9\u01cb\u0005:\u0000\u0000\u01ca\u01c9\u0001"+
"\u0000\u0000\u0000\u01ca\u01cb\u0001\u0000\u0000\u0000\u01cb!\u0001\u0000"+
"\u0000\u0000\u01cc\u01dd\u0003$\u0012\u0000\u01cd\u01cf\u0005\u0006\u0000"+
"\u0000\u01ce\u01cd\u0001\u0000\u0000\u0000\u01cf\u01d2\u0001\u0000\u0000"+
"\u0000\u01d0\u01ce\u0001\u0000\u0000\u0000\u01d0\u01d1\u0001\u0000\u0000"+
"\u0000\u01d1\u01d3\u0001\u0000\u0000\u0000\u01d2\u01d0\u0001\u0000\u0000"+
"\u0000\u01d3\u01d7\u0005\b\u0000\u0000\u01d4\u01d6\u0005\u0006\u0000\u0000"+
"\u01d5\u01d4\u0001\u0000\u0000\u0000\u01d6\u01d9\u0001\u0000\u0000\u0000"+
"\u01d7\u01d5\u0001\u0000\u0000\u0000\u01d7\u01d8\u0001\u0000\u0000\u0000"+
"\u01d8\u01da\u0001\u0000\u0000\u0000\u01d9\u01d7\u0001\u0000\u0000\u0000"+
"\u01da\u01dc\u0003$\u0012\u0000\u01db\u01d0\u0001\u0000\u0000\u0000\u01dc"+
"\u01df\u0001\u0000\u0000\u0000\u01dd\u01db\u0001\u0000\u0000\u0000\u01dd"+
"\u01de\u0001\u0000\u0000\u0000\u01de#\u0001\u0000\u0000\u0000\u01df\u01dd"+
"\u0001\u0000\u0000\u0000\u01e0\u01e3\u0003&\u0013\u0000\u01e1\u01e3\u0003"+
"\u0102\u0081\u0000\u01e2\u01e0\u0001\u0000\u0000\u0000\u01e2\u01e1\u0001"+
"\u0000\u0000\u0000\u01e3%\u0001\u0000\u0000\u0000\u01e4\u01e8\u0003\u0102"+
"\u0081\u0000\u01e5\u01e7\u0005\u0006\u0000\u0000\u01e6\u01e5\u0001\u0000"+
"\u0000\u0000\u01e7\u01ea\u0001\u0000\u0000\u0000\u01e8\u01e6\u0001\u0000"+
"\u0000\u0000\u01e8\u01e9\u0001\u0000\u0000\u0000\u01e9\u01eb\u0001\u0000"+
"\u0000\u0000\u01ea\u01e8\u0001\u0000\u0000\u0000\u01eb\u01ec\u0003\u00b0"+
"X\u0000\u01ec\'\u0001\u0000\u0000\u0000\u01ed\u01f1\u0005\u000f\u0000"+
"\u0000\u01ee\u01f0\u0005\u0006\u0000\u0000\u01ef\u01ee\u0001\u0000\u0000"+
"\u0000\u01f0\u01f3\u0001\u0000\u0000\u0000\u01f1\u01ef\u0001\u0000\u0000"+
"\u0000\u01f1\u01f2\u0001\u0000\u0000\u0000\u01f2\u01f5\u0001\u0000\u0000"+
"\u0000\u01f3\u01f1\u0001\u0000\u0000\u0000\u01f4\u01f6\u0003*\u0015\u0000"+
"\u01f5\u01f4\u0001\u0000\u0000\u0000\u01f5\u01f6\u0001\u0000\u0000\u0000"+
"\u01f6\u01fa\u0001\u0000\u0000\u0000\u01f7\u01f9\u0005\u0006\u0000\u0000"+
"\u01f8\u01f7\u0001\u0000\u0000\u0000\u01f9\u01fc\u0001\u0000\u0000\u0000"+
"\u01fa\u01f8\u0001\u0000\u0000\u0000\u01fa\u01fb\u0001\u0000\u0000\u0000"+
"\u01fb\u0200\u0001\u0000\u0000\u0000\u01fc\u01fa\u0001\u0000\u0000\u0000"+
"\u01fd\u01ff\u0003@ \u0000\u01fe\u01fd\u0001\u0000\u0000\u0000\u01ff\u0202"+
"\u0001\u0000\u0000\u0000\u0200\u01fe\u0001\u0000\u0000\u0000\u0200\u0201"+
"\u0001\u0000\u0000\u0000\u0201\u0206\u0001\u0000\u0000\u0000\u0202\u0200"+
"\u0001\u0000\u0000\u0000\u0203\u0205\u0005\u0006\u0000\u0000\u0204\u0203"+
"\u0001\u0000\u0000\u0000\u0205\u0208\u0001\u0000\u0000\u0000\u0206\u0204"+
"\u0001\u0000\u0000\u0000\u0206\u0207\u0001\u0000\u0000\u0000\u0207\u0209"+
"\u0001\u0000\u0000\u0000\u0208\u0206\u0001\u0000\u0000\u0000\u0209\u020a"+
"\u0005\u0010\u0000\u0000\u020a)\u0001\u0000\u0000\u0000\u020b\u021c\u0003"+
",\u0016\u0000\u020c\u020e\u0005\u0006\u0000\u0000\u020d\u020c\u0001\u0000"+
"\u0000\u0000\u020e\u0211\u0001\u0000\u0000\u0000\u020f\u020d\u0001\u0000"+
"\u0000\u0000\u020f\u0210\u0001\u0000\u0000\u0000\u0210\u0212\u0001\u0000"+
"\u0000\u0000\u0211\u020f\u0001\u0000\u0000\u0000\u0212\u0216\u0005\b\u0000"+
"\u0000\u0213\u0215\u0005\u0006\u0000\u0000\u0214\u0213\u0001\u0000\u0000"+
"\u0000\u0215\u0218\u0001\u0000\u0000\u0000\u0216\u0214\u0001\u0000\u0000"+
"\u0000\u0216\u0217\u0001\u0000\u0000\u0000\u0217\u0219\u0001\u0000\u0000"+
"\u0000\u0218\u0216\u0001\u0000\u0000\u0000\u0219\u021b\u0003,\u0016\u0000"+
"\u021a\u020f\u0001\u0000\u0000\u0000\u021b\u021e\u0001\u0000\u0000\u0000"+
"\u021c\u021a\u0001\u0000\u0000\u0000\u021c\u021d\u0001\u0000\u0000\u0000"+
"\u021d\u0222\u0001\u0000\u0000\u0000\u021e\u021c\u0001\u0000\u0000\u0000"+
"\u021f\u0221\u0005\u0006\u0000\u0000\u0220\u021f\u0001\u0000\u0000\u0000"+
"\u0221\u0224\u0001\u0000\u0000\u0000\u0222\u0220\u0001\u0000\u0000\u0000"+
"\u0222\u0223\u0001\u0000\u0000\u0000\u0223\u0226\u0001\u0000\u0000\u0000"+
"\u0224\u0222\u0001\u0000\u0000\u0000\u0225\u0227\u0005#\u0000\u0000\u0226"+
"\u0225\u0001\u0000\u0000\u0000\u0226\u0227\u0001\u0000\u0000\u0000\u0227"+
"+\u0001\u0000\u0000\u0000\u0228\u0229\u0003\u0102\u0081\u0000\u0229\u022a"+
"\u0003.\u0017\u0000\u022a-\u0001\u0000\u0000\u0000\u022b\u0234\u0005\t"+
"\u0000\u0000\u022c\u0231\u0003\u00b4Z\u0000\u022d\u022e\u0005\b\u0000"+
"\u0000\u022e\u0230\u0003\u00b4Z\u0000\u022f\u022d\u0001\u0000\u0000\u0000"+
"\u0230\u0233\u0001\u0000\u0000\u0000\u0231\u022f\u0001\u0000\u0000\u0000"+
"\u0231\u0232\u0001\u0000\u0000\u0000\u0232\u0235\u0001\u0000\u0000\u0000"+
"\u0233\u0231\u0001\u0000\u0000\u0000\u0234\u022c\u0001\u0000\u0000\u0000"+
"\u0234\u0235\u0001\u0000\u0000\u0000\u0235\u0236\u0001\u0000\u0000\u0000"+
"\u0236\u0238\u0005\n\u0000\u0000\u0237\u022b\u0001\u0000\u0000\u0000\u0237"+
"\u0238\u0001\u0000\u0000\u0000\u0238/\u0001\u0000\u0000\u0000\u0239\u023d"+
"\u0005.\u0000\u0000\u023a\u023c\u0005\u0006\u0000\u0000\u023b\u023a\u0001"+
"\u0000\u0000\u0000\u023c\u023f\u0001\u0000\u0000\u0000\u023d\u023b\u0001"+
"\u0000\u0000\u0000\u023d\u023e\u0001\u0000\u0000\u0000\u023e\u0240\u0001"+
"\u0000\u0000\u0000\u023f\u023d\u0001\u0000\u0000\u0000\u0240\u024b\u0003"+
"2\u0019\u0000\u0241\u0243\u0005\u0006\u0000\u0000\u0242\u0241\u0001\u0000"+
"\u0000\u0000\u0243\u0246\u0001\u0000\u0000\u0000\u0244\u0242\u0001\u0000"+
"\u0000\u0000\u0244\u0245\u0001\u0000\u0000\u0000\u0245\u0247\u0001\u0000"+
"\u0000\u0000\u0246\u0244\u0001\u0000\u0000\u0000\u0247\u0248\u0005\b\u0000"+
"\u0000\u0248\u024a\u00032\u0019\u0000\u0249\u0244\u0001\u0000\u0000\u0000"+
"\u024a\u024d\u0001\u0000\u0000\u0000\u024b\u0249\u0001\u0000\u0000\u0000"+
"\u024b\u024c\u0001\u0000\u0000\u0000\u024c\u0251\u0001\u0000\u0000\u0000"+
"\u024d\u024b\u0001\u0000\u0000\u0000\u024e\u0250\u0005\u0006\u0000\u0000"+
"\u024f\u024e\u0001\u0000\u0000\u0000\u0250\u0253\u0001\u0000\u0000\u0000"+
"\u0251\u024f\u0001\u0000\u0000\u0000\u0251\u0252\u0001\u0000\u0000\u0000"+
"\u0252\u0254\u0001\u0000\u0000\u0000\u0253\u0251\u0001\u0000\u0000\u0000"+
"\u0254\u0255\u0005/\u0000\u0000\u02551\u0001\u0000\u0000\u0000\u0256\u0259"+
"\u00034\u001a\u0000\u0257\u0259\u0005\u0012\u0000\u0000\u0258\u0256\u0001"+
"\u0000\u0000\u0000\u0258\u0257\u0001\u0000\u0000\u0000\u02593\u0001\u0000"+
"\u0000\u0000\u025a\u025d\u00036\u001b\u0000\u025b\u025d\u00038\u001c\u0000"+
"\u025c\u025a\u0001\u0000\u0000\u0000\u025c\u025b\u0001\u0000\u0000\u0000"+
"\u025d5\u0001\u0000\u0000\u0000\u025e\u0260\u0003>\u001f\u0000\u025f\u0261"+
"\u0003<\u001e\u0000\u0260\u025f\u0001\u0000\u0000\u0000\u0260\u0261\u0001"+
"\u0000\u0000\u0000\u02617\u0001\u0000\u0000\u0000\u0262\u026b\u0005\t"+
"\u0000\u0000\u0263\u0268\u00034\u001a\u0000\u0264\u0265\u0005\b\u0000"+
"\u0000\u0265\u0267\u00034\u001a\u0000\u0266\u0264\u0001\u0000\u0000\u0000"+
"\u0267\u026a\u0001\u0000\u0000\u0000\u0268\u0266\u0001\u0000\u0000\u0000"+
"\u0268\u0269\u0001\u0000\u0000\u0000\u0269\u026c\u0001\u0000\u0000\u0000"+
"\u026a\u0268\u0001\u0000\u0000\u0000\u026b\u0263\u0001\u0000\u0000\u0000"+
"\u026b\u026c\u0001\u0000\u0000\u0000\u026c\u026d\u0001\u0000\u0000\u0000"+
"\u026d\u026e\u0005\n\u0000\u0000\u026e\u026f\u0003:\u001d\u0000\u026f"+
"9\u0001\u0000\u0000\u0000\u0270\u0271\u0005\u0017\u0000\u0000\u0271\u0273"+
"\u00034\u001a\u0000\u0272\u0270\u0001\u0000\u0000\u0000\u0272\u0273\u0001"+
"\u0000\u0000\u0000\u0273;\u0001\u0000\u0000\u0000\u0274\u0275\u0005.\u0000"+
"\u0000\u0275\u0280\u00036\u001b\u0000\u0276\u0278\u0005\u0006\u0000\u0000"+
"\u0277\u0276\u0001\u0000\u0000\u0000\u0278\u027b\u0001\u0000\u0000\u0000"+
"\u0279\u0277\u0001\u0000\u0000\u0000\u0279\u027a\u0001\u0000\u0000\u0000"+
"\u027a\u027c\u0001\u0000\u0000\u0000\u027b\u0279\u0001\u0000\u0000\u0000"+
"\u027c\u027d\u0005\b\u0000\u0000\u027d\u027f\u00036\u001b\u0000\u027e"+
"\u0279\u0001\u0000\u0000\u0000\u027f\u0282\u0001\u0000\u0000\u0000\u0280"+
"\u027e\u0001\u0000\u0000\u0000\u0280\u0281\u0001\u0000\u0000\u0000\u0281"+
"\u0286\u0001\u0000\u0000\u0000\u0282\u0280\u0001\u0000\u0000\u0000\u0283"+
"\u0285\u0005\u0006\u0000\u0000\u0284\u0283\u0001\u0000\u0000\u0000\u0285"+
"\u0288\u0001\u0000\u0000\u0000\u0286\u0284\u0001\u0000\u0000\u0000\u0286"+
"\u0287\u0001\u0000\u0000\u0000\u0287\u0289\u0001\u0000\u0000\u0000\u0288"+
"\u0286\u0001\u0000\u0000\u0000\u0289\u028a\u0005/\u0000\u0000\u028a=\u0001"+
"\u0000\u0000\u0000\u028b\u028c\u0003\u0102\u0081\u0000\u028c?\u0001\u0000"+
"\u0000\u0000\u028d\u0292\u0003B!\u0000\u028e\u0292\u0003J%\u0000\u028f"+
"\u0292\u0003Z-\u0000\u0290\u0292\u0003V+\u0000\u0291\u028d\u0001\u0000"+
"\u0000\u0000\u0291\u028e\u0001\u0000\u0000\u0000\u0291\u028f\u0001\u0000"+
"\u0000\u0000\u0291\u0290\u0001\u0000\u0000\u0000\u0292\u0296\u0001\u0000"+
"\u0000\u0000\u0293\u0295\u0003\u0106\u0083\u0000\u0294\u0293\u0001\u0000"+
"\u0000\u0000\u0295\u0298\u0001\u0000\u0000\u0000\u0296\u0294\u0001\u0000"+
"\u0000\u0000\u0296\u0297\u0001\u0000\u0000\u0000\u0297A\u0001\u0000\u0000"+
"\u0000\u0298\u0296\u0001\u0000\u0000\u0000\u0299\u029d\u0003D\"\u0000"+
"\u029a\u029c\u0005\u0006\u0000\u0000\u029b\u029a\u0001\u0000\u0000\u0000"+
"\u029c\u029f\u0001\u0000\u0000\u0000\u029d\u029b\u0001\u0000\u0000\u0000"+
"\u029d\u029e\u0001\u0000\u0000\u0000\u029e\u02a1\u0001\u0000\u0000\u0000"+
"\u029f\u029d\u0001\u0000\u0000\u0000\u02a0\u02a2\u0003f3\u0000\u02a1\u02a0"+
"\u0001\u0000\u0000\u0000\u02a1\u02a2\u0001\u0000\u0000\u0000\u02a2C\u0001"+
"\u0000\u0000\u0000\u02a3\u02a5\u0003\u0016\u000b\u0000\u02a4\u02a3\u0001"+
"\u0000\u0000\u0000\u02a4\u02a5\u0001\u0000\u0000\u0000\u02a5\u02a6\u0001"+
"\u0000\u0000\u0000\u02a6\u02a7\u0003N\'\u0000\u02a7\u02ab\u0005A\u0000"+
"\u0000\u02a8\u02aa\u0005\u0006\u0000\u0000\u02a9\u02a8\u0001\u0000\u0000"+
"\u0000\u02aa\u02ad\u0001\u0000\u0000\u0000\u02ab\u02a9\u0001\u0000\u0000"+
"\u0000\u02ab\u02ac\u0001\u0000\u0000\u0000\u02ac\u02ae\u0001\u0000\u0000"+
"\u0000\u02ad\u02ab\u0001\u0000\u0000\u0000\u02ae\u02bd\u0003F#\u0000\u02af"+
"\u02b1\u0005\u0006\u0000\u0000\u02b0\u02af\u0001\u0000\u0000\u0000\u02b1"+
"\u02b4\u0001\u0000\u0000\u0000\u02b2\u02b0\u0001\u0000\u0000\u0000\u02b2"+
"\u02b3\u0001\u0000\u0000\u0000\u02b3\u02b5\u0001\u0000\u0000\u0000\u02b4"+
"\u02b2\u0001\u0000\u0000\u0000\u02b5\u02b9\u0005 \u0000\u0000\u02b6\u02b8"+
"\u0005\u0006\u0000\u0000\u02b7\u02b6\u0001\u0000\u0000\u0000\u02b8\u02bb"+
"\u0001\u0000\u0000\u0000\u02b9\u02b7\u0001\u0000\u0000\u0000\u02b9\u02ba"+
"\u0001\u0000\u0000\u0000\u02ba\u02bc\u0001\u0000\u0000\u0000\u02bb\u02b9"+
"\u0001\u0000\u0000\u0000\u02bc\u02be\u0003H$\u0000\u02bd\u02b2\u0001\u0000"+
"\u0000\u0000\u02bd\u02be\u0001\u0000\u0000\u0000\u02beE\u0001\u0000\u0000"+
"\u0000\u02bf\u02c8\u0005\t\u0000\u0000\u02c0\u02c5\u0003`0\u0000\u02c1"+
"\u02c2\u0005\b\u0000\u0000\u02c2\u02c4\u0003`0\u0000\u02c3\u02c1\u0001"+
"\u0000\u0000\u0000\u02c4\u02c7\u0001\u0000\u0000\u0000\u02c5\u02c3\u0001"+
"\u0000\u0000\u0000\u02c5\u02c6\u0001\u0000\u0000\u0000\u02c6\u02c9\u0001"+
"\u0000\u0000\u0000\u02c7\u02c5\u0001\u0000\u0000\u0000\u02c8\u02c0\u0001"+
"\u0000\u0000\u0000\u02c8\u02c9\u0001\u0000\u0000\u0000\u02c9\u02ca\u0001"+
"\u0000\u0000\u0000\u02ca\u02cb\u0005\n\u0000\u0000\u02cbG\u0001\u0000"+
"\u0000\u0000\u02cc\u02d0\u0005\\\u0000\u0000\u02cd\u02cf\u0005\u0006\u0000"+
"\u0000\u02ce\u02cd\u0001\u0000\u0000\u0000\u02cf\u02d2\u0001\u0000\u0000"+
"\u0000\u02d0\u02ce\u0001\u0000\u0000\u0000\u02d0\u02d1\u0001\u0000\u0000"+
"\u0000\u02d1\u02d3\u0001\u0000\u0000\u0000\u02d2\u02d0\u0001\u0000\u0000"+
"\u0000\u02d3\u02dd\u0003\u00b2Y\u0000\u02d4\u02d8\u0005[\u0000\u0000\u02d5"+
"\u02d7\u0005\u0006\u0000\u0000\u02d6\u02d5\u0001\u0000\u0000\u0000\u02d7"+
"\u02da\u0001\u0000\u0000\u0000\u02d8\u02d6\u0001\u0000\u0000\u0000\u02d8"+
"\u02d9\u0001\u0000\u0000\u0000\u02d9\u02db\u0001\u0000\u0000\u0000\u02da"+
"\u02d8\u0001\u0000\u0000\u0000\u02db\u02dd\u0003\u00b2Y\u0000\u02dc\u02cc"+
"\u0001\u0000\u0000\u0000\u02dc\u02d4\u0001\u0000\u0000\u0000\u02ddI\u0001"+
"\u0000\u0000\u0000\u02de\u02ed\u0003L&\u0000\u02df\u02e1\u0005\u0006\u0000"+
"\u0000\u02e0\u02df\u0001\u0000\u0000\u0000\u02e1\u02e4\u0001\u0000\u0000"+
"\u0000\u02e2\u02e0\u0001\u0000\u0000\u0000\u02e2\u02e3\u0001\u0000\u0000"+
"\u0000\u02e3\u02e5\u0001\u0000\u0000\u0000\u02e4\u02e2\u0001\u0000\u0000"+
"\u0000\u02e5\u02e9\u0005$\u0000\u0000\u02e6\u02e8\u0005\u0006\u0000\u0000"+
"\u02e7\u02e6\u0001\u0000\u0000\u0000\u02e8\u02eb\u0001\u0000\u0000\u0000"+
"\u02e9\u02e7\u0001\u0000\u0000\u0000\u02e9\u02ea\u0001\u0000\u0000\u0000"+
"\u02ea\u02ec\u0001\u0000\u0000\u0000\u02eb\u02e9\u0001\u0000\u0000\u0000"+
"\u02ec\u02ee\u0003x<\u0000\u02ed\u02e2\u0001\u0000\u0000\u0000\u02ed\u02ee"+
"\u0001\u0000\u0000\u0000\u02eeK\u0001\u0000\u0000\u0000\u02ef\u02f1\u0003"+
"\u0016\u000b\u0000\u02f0\u02ef\u0001\u0000\u0000\u0000\u02f0\u02f1\u0001"+
"\u0000\u0000\u0000\u02f1\u02f2\u0001\u0000\u0000\u0000\u02f2\u02f4\u0003"+
"N\'\u0000\u02f3\u02f5\u0007\u0003\u0000\u0000\u02f4\u02f3\u0001\u0000"+
"\u0000\u0000\u02f4\u02f5\u0001\u0000\u0000\u0000\u02f5\u02f6\u0001\u0000"+
"\u0000\u0000\u02f6\u02fa\u0007\u0002\u0000\u0000\u02f7\u02f9\u0005\u0006"+
"\u0000\u0000\u02f8\u02f7\u0001\u0000\u0000\u0000\u02f9\u02fc\u0001\u0000"+
"\u0000\u0000\u02fa\u02f8\u0001\u0000\u0000\u0000\u02fa\u02fb\u0001\u0000"+
"\u0000\u0000\u02fb\u02fd\u0001\u0000\u0000\u0000\u02fc\u02fa\u0001\u0000"+
"\u0000\u0000\u02fd\u02fe\u0003X,\u0000\u02feM\u0001\u0000\u0000\u0000"+
"\u02ff\u0301\u0003P(\u0000\u0300\u02ff\u0001\u0000\u0000\u0000\u0301\u0304"+
"\u0001\u0000\u0000\u0000\u0302\u0300\u0001\u0000\u0000\u0000\u0302\u0303"+
"\u0001\u0000\u0000\u0000\u0303O\u0001\u0000\u0000\u0000\u0304\u0302\u0001"+
"\u0000\u0000\u0000\u0305\u0309\u0005s\u0000\u0000\u0306\u0308\u0005\u0006"+
"\u0000\u0000\u0307\u0306\u0001\u0000\u0000\u0000\u0308\u030b\u0001\u0000"+
"\u0000\u0000\u0309\u0307\u0001\u0000\u0000\u0000\u0309\u030a\u0001\u0000"+
"\u0000\u0000\u030a\u030d\u0001\u0000\u0000\u0000\u030b\u0309\u0001\u0000"+
"\u0000\u0000\u030c\u030e\u0003R)\u0000\u030d\u030c\u0001\u0000\u0000\u0000"+
"\u030d\u030e\u0001\u0000\u0000\u0000\u030eQ\u0001\u0000\u0000\u0000\u030f"+
"\u0313\u0005\t\u0000\u0000\u0310\u0312\u0005\u0006\u0000\u0000\u0311\u0310"+
"\u0001\u0000\u0000\u0000\u0312\u0315\u0001\u0000\u0000\u0000\u0313\u0311"+
"\u0001\u0000\u0000\u0000\u0313\u0314\u0001\u0000\u0000\u0000\u0314\u0316"+
"\u0001\u0000\u0000\u0000\u0315\u0313\u0001\u0000\u0000\u0000\u0316\u0327"+
"\u0003T*\u0000\u0317\u0319\u0005\u0006\u0000\u0000\u0318\u0317\u0001\u0000"+
"\u0000\u0000\u0319\u031c\u0001\u0000\u0000\u0000\u031a\u0318\u0001\u0000"+
"\u0000\u0000\u031a\u031b\u0001\u0000\u0000\u0000\u031b\u031d\u0001\u0000"+
"\u0000\u0000\u031c\u031a\u0001\u0000\u0000\u0000\u031d\u0321\u0005\b\u0000"+
"\u0000\u031e\u0320\u0005\u0006\u0000\u0000\u031f\u031e\u0001\u0000\u0000"+
"\u0000\u0320\u0323\u0001\u0000\u0000\u0000\u0321\u031f\u0001\u0000\u0000"+
"\u0000\u0321\u0322\u0001\u0000\u0000\u0000\u0322\u0324\u0001\u0000\u0000"+
"\u0000\u0323\u0321\u0001\u0000\u0000\u0000\u0324\u0326\u0003T*\u0000\u0325"+
"\u031a\u0001\u0000\u0000\u0000\u0326\u0329\u0001\u0000\u0000\u0000\u0327"+
"\u0325\u0001\u0000\u0000\u0000\u0327\u0328\u0001\u0000\u0000\u0000\u0328"+
"\u032d\u0001\u0000\u0000\u0000\u0329\u0327\u0001\u0000\u0000\u0000\u032a"+
"\u032c\u0005\u0006\u0000\u0000\u032b\u032a\u0001\u0000\u0000\u0000\u032c"+
"\u032f\u0001\u0000\u0000\u0000\u032d\u032b\u0001\u0000\u0000\u0000\u032d"+
"\u032e\u0001\u0000\u0000\u0000\u032e\u0330\u0001\u0000\u0000\u0000\u032f"+
"\u032d\u0001\u0000\u0000\u0000\u0330\u0334\u0005\n\u0000\u0000\u0331\u0333"+
"\u0005\u0006\u0000\u0000\u0332\u0331\u0001\u0000\u0000\u0000\u0333\u0336"+
"\u0001\u0000\u0000\u0000\u0334\u0332\u0001\u0000\u0000\u0000\u0334\u0335"+
"\u0001\u0000\u0000\u0000\u0335S\u0001\u0000\u0000\u0000\u0336\u0334\u0001"+
"\u0000\u0000\u0000\u0337\u033b\u0003\u0102\u0081\u0000\u0338\u033a\u0005"+
"\u0006\u0000\u0000\u0339\u0338\u0001\u0000\u0000\u0000\u033a\u033d\u0001"+
"\u0000\u0000\u0000\u033b\u0339\u0001\u0000\u0000\u0000\u033b\u033c\u0001"+
"\u0000\u0000\u0000\u033c\u033e\u0001\u0000\u0000\u0000\u033d\u033b\u0001"+
"\u0000\u0000\u0000\u033e\u0342\u0005$\u0000\u0000\u033f\u0341\u0005\u0006"+
"\u0000\u0000\u0340\u033f\u0001\u0000\u0000\u0000\u0341\u0344\u0001\u0000"+
"\u0000\u0000\u0342\u0340\u0001\u0000\u0000\u0000\u0342\u0343\u0001\u0000"+
"\u0000\u0000\u0343\u0345\u0001\u0000\u0000\u0000\u0344\u0342\u0001\u0000"+
"\u0000\u0000\u0345\u0346\u0003\u00d4j\u0000\u0346U\u0001\u0000\u0000\u0000"+
"\u0347\u034b\u0005S\u0000\u0000\u0348\u034a\u0005\u0006\u0000\u0000\u0349"+
"\u0348\u0001\u0000\u0000\u0000\u034a\u034d\u0001\u0000\u0000\u0000\u034b"+
"\u0349\u0001\u0000\u0000\u0000\u034b\u034c\u0001\u0000\u0000\u0000\u034c"+
"\u034e\u0001\u0000\u0000\u0000\u034d\u034b\u0001\u0000\u0000\u0000\u034e"+
"\u034f\u0003f3\u0000\u034fW\u0001\u0000\u0000\u0000\u0350\u0353\u0003"+
"\u0102\u0081\u0000\u0351\u0352\u0005 \u0000\u0000\u0352\u0354\u00034\u001a"+
"\u0000\u0353\u0351\u0001\u0000\u0000\u0000\u0353\u0354\u0001\u0000\u0000"+
"\u0000\u0354Y\u0001\u0000\u0000\u0000\u0355\u035d\u0003\\.\u0000\u0356"+
"\u0358\u0005\u0006\u0000\u0000\u0357\u0356\u0001\u0000\u0000\u0000\u0358"+
"\u035b\u0001\u0000\u0000\u0000\u0359\u0357\u0001\u0000\u0000\u0000\u0359"+
"\u035a\u0001\u0000\u0000\u0000\u035a\u035c\u0001\u0000\u0000\u0000\u035b"+
"\u0359\u0001\u0000\u0000\u0000\u035c\u035e\u0003b1\u0000\u035d\u0359\u0001"+
"\u0000\u0000\u0000\u035d\u035e\u0001\u0000\u0000\u0000\u035e[\u0001\u0000"+
"\u0000\u0000\u035f\u0361\u0003\u0016\u000b\u0000\u0360\u035f\u0001\u0000"+
"\u0000\u0000\u0360\u0361\u0001\u0000\u0000\u0000\u0361\u0362\u0001\u0000"+
"\u0000\u0000\u0362\u0364\u0003N\'\u0000\u0363\u0365\u0005Z\u0000\u0000"+
"\u0364\u0363\u0001\u0000\u0000\u0000\u0364\u0365\u0001\u0000\u0000\u0000"+
"\u0365\u0367\u0001\u0000\u0000\u0000\u0366\u0368\u0007\u0000\u0000\u0000"+
"\u0367\u0366\u0001\u0000\u0000\u0000\u0367\u0368\u0001\u0000\u0000\u0000"+
"\u0368\u036a\u0001\u0000\u0000\u0000\u0369\u036b\u0005;\u0000\u0000\u036a"+
"\u0369\u0001\u0000\u0000\u0000\u036a\u036b\u0001\u0000\u0000\u0000\u036b"+
"\u036d\u0001\u0000\u0000\u0000\u036c\u036e\u0005V\u0000\u0000\u036d\u036c"+
"\u0001\u0000\u0000\u0000\u036d\u036e\u0001\u0000\u0000\u0000\u036e\u036f"+
"\u0001\u0000\u0000\u0000\u036f\u0373\u0007\u0004\u0000\u0000\u0370\u0372"+
"\u0005\u0006\u0000\u0000\u0371\u0370\u0001\u0000\u0000\u0000\u0372\u0375"+
"\u0001\u0000\u0000\u0000\u0373\u0371\u0001\u0000\u0000\u0000\u0373\u0374"+
"\u0001\u0000\u0000\u0000\u0374\u0376\u0001\u0000\u0000\u0000\u0375\u0373"+
"\u0001\u0000\u0000\u0000\u0376\u037a\u0003\u0102\u0081\u0000\u0377\u0379"+
"\u0005\u0006\u0000\u0000\u0378\u0377\u0001\u0000\u0000\u0000\u0379\u037c"+
"\u0001\u0000\u0000\u0000\u037a\u0378\u0001\u0000\u0000\u0000\u037a\u037b"+
"\u0001\u0000\u0000\u0000\u037b\u037d\u0001\u0000\u0000\u0000\u037c\u037a"+
"\u0001\u0000\u0000\u0000\u037d\u038c\u0003^/\u0000\u037e\u0380\u0005\u0006"+
"\u0000\u0000\u037f\u037e\u0001\u0000\u0000\u0000\u0380\u0383\u0001\u0000"+
"\u0000\u0000\u0381\u037f\u0001\u0000\u0000\u0000\u0381\u0382\u0001\u0000"+
"\u0000\u0000\u0382\u0384\u0001\u0000\u0000\u0000\u0383\u0381\u0001\u0000"+
"\u0000\u0000\u0384\u0388\u0005 \u0000\u0000\u0385\u0387\u0005\u0006\u0000"+
"\u0000\u0386\u0385\u0001\u0000\u0000\u0000\u0387\u038a\u0001\u0000\u0000"+
"\u0000\u0388\u0386\u0001\u0000\u0000\u0000\u0388\u0389\u0001\u0000\u0000"+
"\u0000\u0389\u038b\u0001\u0000\u0000\u0000\u038a\u0388\u0001\u0000\u0000"+
"\u0000\u038b\u038d\u00034\u001a\u0000\u038c\u0381\u0001\u0000\u0000\u0000"+
"\u038c\u038d\u0001\u0000\u0000\u0000\u038d]\u0001\u0000\u0000\u0000\u038e"+
"\u0397\u0005\t\u0000\u0000\u038f\u0394\u0003`0\u0000\u0390\u0391\u0005"+
"\b\u0000\u0000\u0391\u0393\u0003`0\u0000\u0392\u0390\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\u038f\u0001\u0000\u0000"+
"\u0000\u0397\u0398\u0001\u0000\u0000\u0000\u0398\u0399\u0001\u0000\u0000"+
"\u0000\u0399\u039a\u0005\n\u0000\u0000\u039a_\u0001\u0000\u0000\u0000"+
"\u039b\u039c\u0003\u0102\u0081\u0000\u039c\u039d\u0005 \u0000\u0000\u039d"+
"\u039f\u00034\u001a\u0000\u039e\u03a0\u0005:\u0000\u0000\u039f\u039e\u0001"+
"\u0000\u0000\u0000\u039f\u03a0\u0001\u0000\u0000\u0000\u03a0a\u0001\u0000"+
"\u0000\u0000\u03a1\u03ab\u0003d2\u0000\u03a2\u03a6\u0005$\u0000\u0000"+
"\u03a3\u03a5\u0005\u0006\u0000\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\u03ab\u0003x<\u0000\u03aa\u03a1"+
"\u0001\u0000\u0000\u0000\u03aa\u03a2\u0001\u0000\u0000\u0000\u03abc\u0001"+
"\u0000\u0000\u0000\u03ac\u03ad\u0003f3\u0000\u03ade\u0001\u0000\u0000"+
"\u0000\u03ae\u03af\u0005\u000f\u0000\u0000\u03af\u03b0\u0003j5\u0000\u03b0"+
"\u03b1\u0005\u0010\u0000\u0000\u03b1g\u0001\u0000\u0000\u0000\u03b2\u03b5"+
"\u0003f3\u0000\u03b3\u03b5\u0003x<\u0000\u03b4\u03b2\u0001\u0000\u0000"+
"\u0000\u03b4\u03b3\u0001\u0000\u0000\u0000\u03b5i\u0001\u0000\u0000\u0000"+
"\u03b6\u03b8\u0003\u0106\u0083\u0000\u03b7\u03b6\u0001\u0000\u0000\u0000"+
"\u03b8\u03bb\u0001\u0000\u0000\u0000\u03b9\u03b7\u0001\u0000\u0000\u0000"+
"\u03b9\u03ba\u0001\u0000\u0000\u0000\u03ba\u03ca\u0001\u0000\u0000\u0000"+
"\u03bb\u03b9\u0001\u0000\u0000\u0000\u03bc\u03c7\u0003l6\u0000\u03bd\u03bf"+
"\u0003\u0106\u0083\u0000\u03be\u03bd\u0001\u0000\u0000\u0000\u03bf\u03c0"+
"\u0001\u0000\u0000\u0000\u03c0\u03be\u0001\u0000\u0000\u0000\u03c0\u03c1"+
"\u0001\u0000\u0000\u0000\u03c1\u03c3\u0001\u0000\u0000\u0000\u03c2\u03c4"+
"\u0003l6\u0000\u03c3\u03c2\u0001\u0000\u0000\u0000\u03c3\u03c4\u0001\u0000"+
"\u0000\u0000\u03c4\u03c6\u0001\u0000\u0000\u0000\u03c5\u03be\u0001\u0000"+
"\u0000\u0000\u03c6\u03c9\u0001\u0000\u0000\u0000\u03c7\u03c5\u0001\u0000"+
"\u0000\u0000\u03c7\u03c8\u0001\u0000\u0000\u0000\u03c8\u03cb\u0001\u0000"+
"\u0000\u0000\u03c9\u03c7\u0001\u0000\u0000\u0000\u03ca\u03bc\u0001\u0000"+
"\u0000\u0000\u03ca\u03cb\u0001\u0000\u0000\u0000\u03cbk\u0001\u0000\u0000"+
"\u0000\u03cc\u03cf\u0003n7\u0000\u03cd\u03cf\u0003x<\u0000\u03ce\u03cc"+
"\u0001\u0000\u0000\u0000\u03ce\u03cd\u0001\u0000\u0000\u0000\u03cfm\u0001"+
"\u0000\u0000\u0000\u03d0\u03d4\u0007\u0002\u0000\u0000\u03d1\u03d3\u0005"+
"\u0006\u0000\u0000\u03d2\u03d1\u0001\u0000\u0000\u0000\u03d3\u03d6\u0001"+
"\u0000\u0000\u0000\u03d4\u03d2\u0001\u0000\u0000\u0000\u03d4\u03d5\u0001"+
"\u0000\u0000\u0000\u03d5\u03d7\u0001\u0000\u0000\u0000\u03d6\u03d4\u0001"+
"\u0000\u0000\u0000\u03d7\u03e6\u0003X,\u0000\u03d8\u03da\u0005\u0006\u0000"+
"\u0000\u03d9\u03d8\u0001\u0000\u0000\u0000\u03da\u03dd\u0001\u0000\u0000"+
"\u0000\u03db\u03d9\u0001\u0000\u0000\u0000\u03db\u03dc\u0001\u0000\u0000"+
"\u0000\u03dc\u03de\u0001\u0000\u0000\u0000\u03dd\u03db\u0001\u0000\u0000"+
"\u0000\u03de\u03e2\u0005$\u0000\u0000\u03df\u03e1\u0005\u0006\u0000\u0000"+
"\u03e0\u03df\u0001\u0000\u0000\u0000\u03e1\u03e4\u0001\u0000\u0000\u0000"+
"\u03e2\u03e0\u0001\u0000\u0000\u0000\u03e2\u03e3\u0001\u0000\u0000\u0000"+
"\u03e3\u03e5\u0001\u0000\u0000\u0000\u03e4\u03e2\u0001\u0000\u0000\u0000"+
"\u03e5\u03e7\u0003x<\u0000\u03e6\u03db\u0001\u0000\u0000\u0000\u03e6\u03e7"+
"\u0001\u0000\u0000\u0000\u03e7o\u0001\u0000\u0000\u0000\u03e8\u03ec\u0005"+
"]\u0000\u0000\u03e9\u03eb\u0005\u0006\u0000\u0000\u03ea\u03e9\u0001\u0000"+
"\u0000\u0000\u03eb\u03ee\u0001\u0000\u0000\u0000\u03ec\u03ea\u0001\u0000"+
"\u0000\u0000\u03ec\u03ed\u0001\u0000\u0000\u0000\u03ed\u03ef\u0001\u0000"+
"\u0000\u0000\u03ee\u03ec\u0001\u0000\u0000\u0000\u03ef\u03f0\u0003x<\u0000"+
"\u03f0q\u0001\u0000\u0000\u0000\u03f1\u03f3\u0005Y\u0000\u0000\u03f2\u03f4"+
"\u0003x<\u0000\u03f3\u03f2\u0001\u0000\u0000\u0000\u03f3\u03f4\u0001\u0000"+
"\u0000\u0000\u03f4s\u0001\u0000\u0000\u0000\u03f5\u03f6\u0005B\u0000\u0000"+
"\u03f6u\u0001\u0000\u0000\u0000\u03f7\u03f8\u0005>\u0000\u0000\u03f8w"+
"\u0001\u0000\u0000\u0000\u03f9\u0408\u0003\u00c8d\u0000\u03fa\u0408\u0003"+
"\u00cae\u0000\u03fb\u0408\u0003\u00c2a\u0000\u03fc\u0408\u0003t:\u0000"+
"\u03fd\u0408\u0003v;\u0000\u03fe\u0408\u0003r9\u0000\u03ff\u0404\u0003"+
"z=\u0000\u0400\u0401\u0007\u0005\u0000\u0000\u0401\u0403\u0003z=\u0000"+
"\u0402\u0400\u0001\u0000\u0000\u0000\u0403\u0406\u0001\u0000\u0000\u0000"+
"\u0404\u0402\u0001\u0000\u0000\u0000\u0404\u0405\u0001\u0000\u0000\u0000"+
"\u0405\u0408\u0001\u0000\u0000\u0000\u0406\u0404\u0001\u0000\u0000\u0000"+
"\u0407\u03f9\u0001\u0000\u0000\u0000\u0407\u03fa\u0001\u0000\u0000\u0000"+
"\u0407\u03fb\u0001\u0000\u0000\u0000\u0407\u03fc\u0001\u0000\u0000\u0000"+
"\u0407\u03fd\u0001\u0000\u0000\u0000\u0407\u03fe\u0001\u0000\u0000\u0000"+
"\u0407\u03ff\u0001\u0000\u0000\u0000\u0408y\u0001\u0000\u0000\u0000\u0409"+
"\u040a\u0006=\uffff\uffff\u0000\u040a\u040b\u0003|>\u0000\u040b\u0419"+
"\u0001\u0000\u0000\u0000\u040c\u040d\n\u0002\u0000\u0000\u040d\u0411\u0005"+
" \u0000\u0000\u040e\u0410\u0005\u0006\u0000\u0000\u040f\u040e\u0001\u0000"+
"\u0000\u0000\u0410\u0413\u0001\u0000\u0000\u0000\u0411\u040f\u0001\u0000"+
"\u0000\u0000\u0411\u0412\u0001\u0000\u0000\u0000\u0412\u0414\u0001\u0000"+
"\u0000\u0000\u0413\u0411\u0001\u0000\u0000\u0000\u0414\u0415\u0003\u0102"+
"\u0081\u0000\u0415\u0416\u0003\u00b0X\u0000\u0416\u0418\u0001\u0000\u0000"+
"\u0000\u0417\u040c\u0001\u0000\u0000\u0000\u0418\u041b\u0001\u0000\u0000"+
"\u0000\u0419\u0417\u0001\u0000\u0000\u0000\u0419\u041a\u0001\u0000\u0000"+
"\u0000\u041a{\u0001\u0000\u0000\u0000\u041b\u0419\u0001\u0000\u0000\u0000"+
"\u041c\u041d\u0006>\uffff\uffff\u0000\u041d\u041e\u0003~?\u0000\u041e"+
"\u0430\u0001\u0000\u0000\u0000\u041f\u0423\n\u0002\u0000\u0000\u0420\u0422"+
"\u0005\u0006\u0000\u0000\u0421\u0420\u0001\u0000\u0000\u0000\u0422\u0425"+
"\u0001\u0000\u0000\u0000\u0423\u0421\u0001\u0000\u0000\u0000\u0423\u0424"+
"\u0001\u0000\u0000\u0000\u0424\u0426\u0001\u0000\u0000\u0000\u0425\u0423"+
"\u0001\u0000\u0000\u0000\u0426\u042a\u0005\u001e\u0000\u0000\u0427\u0429"+
"\u0005\u0006\u0000\u0000\u0428\u0427\u0001\u0000\u0000\u0000\u0429\u042c"+
"\u0001\u0000\u0000\u0000\u042a\u0428\u0001\u0000\u0000\u0000\u042a\u042b"+
"\u0001\u0000\u0000\u0000\u042b\u042d\u0001\u0000\u0000\u0000\u042c\u042a"+
"\u0001\u0000\u0000\u0000\u042d\u042f\u0003|>\u0003\u042e\u041f\u0001\u0000"+
"\u0000\u0000\u042f\u0432\u0001\u0000\u0000\u0000\u0430\u042e\u0001\u0000"+
"\u0000\u0000\u0430\u0431\u0001\u0000\u0000\u0000\u0431}\u0001\u0000\u0000"+
"\u0000\u0432\u0430\u0001\u0000\u0000\u0000\u0433\u0434\u0006?\uffff\uffff"+
"\u0000\u0434\u0435\u0003\u0080@\u0000\u0435\u0447\u0001\u0000\u0000\u0000"+
"\u0436\u043a\n\u0002\u0000\u0000\u0437\u0439\u0005\u0006\u0000\u0000\u0438"+
"\u0437\u0001\u0000\u0000\u0000\u0439\u043c\u0001\u0000\u0000\u0000\u043a"+
"\u0438\u0001\u0000\u0000\u0000\u043a\u043b\u0001\u0000\u0000\u0000\u043b"+
"\u043d\u0001\u0000\u0000\u0000\u043c\u043a\u0001\u0000\u0000\u0000\u043d"+
"\u0441\u0005\u001c\u0000\u0000\u043e\u0440\u0005\u0006\u0000\u0000\u043f"+
"\u043e\u0001\u0000\u0000\u0000\u0440\u0443\u0001\u0000\u0000\u0000\u0441"+
"\u043f\u0001\u0000\u0000\u0000\u0441\u0442\u0001\u0000\u0000\u0000\u0442"+
"\u0444\u0001\u0000\u0000\u0000\u0443\u0441\u0001\u0000\u0000\u0000\u0444"+
"\u0446\u0003~?\u0003\u0445\u0436\u0001\u0000\u0000\u0000\u0446\u0449\u0001"+
"\u0000\u0000\u0000\u0447\u0445\u0001\u0000\u0000\u0000\u0447\u0448\u0001"+
"\u0000\u0000\u0000\u0448\u007f\u0001\u0000\u0000\u0000\u0449\u0447\u0001"+
"\u0000\u0000\u0000\u044a\u044b\u0006@\uffff\uffff\u0000\u044b\u044c\u0003"+
"\u0082A\u0000\u044c\u0458\u0001\u0000\u0000\u0000\u044d\u044e\n\u0002"+
"\u0000\u0000\u044e\u0452\u0007\u0006\u0000\u0000\u044f\u0451\u0005\u0006"+
"\u0000\u0000\u0450\u044f\u0001\u0000\u0000\u0000\u0451\u0454\u0001\u0000"+
"\u0000\u0000\u0452\u0450\u0001\u0000\u0000\u0000\u0452\u0453\u0001\u0000"+
"\u0000\u0000\u0453\u0455\u0001\u0000\u0000\u0000\u0454\u0452\u0001\u0000"+
"\u0000\u0000\u0455\u0457\u0003\u0080@\u0003\u0456\u044d\u0001\u0000\u0000"+
"\u0000\u0457\u045a\u0001\u0000\u0000\u0000\u0458\u0456\u0001\u0000\u0000"+
"\u0000\u0458\u0459\u0001\u0000\u0000\u0000\u0459\u0081\u0001\u0000\u0000"+
"\u0000\u045a\u0458\u0001\u0000\u0000\u0000\u045b\u0464\u0003\u0084B\u0000"+
"\u045c\u0460\u0007\u0007\u0000\u0000\u045d\u045f\u0005\u0006\u0000\u0000"+
"\u045e\u045d\u0001\u0000\u0000\u0000\u045f\u0462\u0001\u0000\u0000\u0000"+
"\u0460\u045e\u0001\u0000\u0000\u0000\u0460\u0461\u0001\u0000\u0000\u0000"+
"\u0461\u0463\u0001\u0000\u0000\u0000\u0462\u0460\u0001\u0000\u0000\u0000"+
"\u0463\u0465\u0003\u0084B\u0000\u0464\u045c\u0001\u0000\u0000\u0000\u0464"+
"\u0465\u0001\u0000\u0000\u0000\u0465\u0083\u0001\u0000\u0000\u0000\u0466"+
"\u046f\u0003\u0086C\u0000\u0467\u046b\u0007\b\u0000\u0000\u0468\u046a"+
"\u0005\u0006\u0000\u0000\u0469\u0468\u0001\u0000\u0000\u0000\u046a\u046d"+
"\u0001\u0000\u0000\u0000\u046b\u0469\u0001\u0000\u0000\u0000\u046b\u046c"+
"\u0001\u0000\u0000\u0000\u046c\u046e\u0001\u0000\u0000\u0000\u046d\u046b"+
"\u0001\u0000\u0000\u0000\u046e\u0470\u00034\u001a\u0000\u046f\u0467\u0001"+
"\u0000\u0000\u0000\u046f\u0470\u0001\u0000\u0000\u0000\u0470\u0085\u0001"+
"\u0000\u0000\u0000\u0471\u0472\u0006C\uffff\uffff\u0000\u0472\u0473\u0003"+
"\u0088D\u0000\u0473\u047f\u0001\u0000\u0000\u0000\u0474\u0475\n\u0002"+
"\u0000\u0000\u0475\u0479\u0005-\u0000\u0000\u0476\u0478\u0005\u0006\u0000"+
"\u0000\u0477\u0476\u0001\u0000\u0000\u0000\u0478\u047b\u0001\u0000\u0000"+
"\u0000\u0479\u0477\u0001\u0000\u0000\u0000\u0479\u047a\u0001\u0000\u0000"+
"\u0000\u047a\u047c\u0001\u0000\u0000\u0000\u047b\u0479\u0001\u0000\u0000"+
"\u0000\u047c\u047e\u0003\u0086C\u0003\u047d\u0474\u0001\u0000\u0000\u0000"+
"\u047e\u0481\u0001\u0000\u0000\u0000\u047f\u047d\u0001\u0000\u0000\u0000"+
"\u047f\u0480\u0001\u0000\u0000\u0000\u0480\u0087\u0001\u0000\u0000\u0000"+
"\u0481\u047f\u0001\u0000\u0000\u0000\u0482\u0483\u0006D\uffff\uffff\u0000"+
"\u0483\u0487\u0003\u008aE\u0000\u0484\u0487\u0003\u008cF\u0000\u0485\u0487"+
"\u0003\u008eG\u0000\u0486\u0482\u0001\u0000\u0000\u0000\u0486\u0484\u0001"+
"\u0000\u0000\u0000\u0486\u0485\u0001\u0000\u0000\u0000\u0487\u0494\u0001"+
"\u0000\u0000\u0000\u0488\u0489\n\u0004\u0000\u0000\u0489\u048d\u0003\u0102"+
"\u0081\u0000\u048a\u048c\u0005\u0006\u0000\u0000\u048b\u048a\u0001\u0000"+
"\u0000\u0000\u048c\u048f\u0001\u0000\u0000\u0000\u048d\u048b\u0001\u0000"+
"\u0000\u0000\u048d\u048e\u0001\u0000\u0000\u0000\u048e\u0490\u0001\u0000"+
"\u0000\u0000\u048f\u048d\u0001\u0000\u0000\u0000\u0490\u0491\u0003\u0088"+
"D\u0005\u0491\u0493\u0001\u0000\u0000\u0000\u0492\u0488\u0001\u0000\u0000"+
"\u0000\u0493\u0496\u0001\u0000\u0000\u0000\u0494\u0492\u0001\u0000\u0000"+
"\u0000\u0494\u0495\u0001\u0000\u0000\u0000\u0495\u0089\u0001\u0000\u0000"+
"\u0000\u0496\u0494\u0001\u0000\u0000\u0000\u0497\u0498\u0003\u008eG\u0000"+
"\u0498\u049c\u0007\t\u0000\u0000\u0499\u049b\u0005\u0006\u0000\u0000\u049a"+
"\u0499\u0001\u0000\u0000\u0000\u049b\u049e\u0001\u0000\u0000\u0000\u049c"+
"\u049a\u0001\u0000\u0000\u0000\u049c\u049d\u0001\u0000\u0000\u0000\u049d"+
"\u049f\u0001\u0000\u0000\u0000\u049e\u049c\u0001\u0000\u0000\u0000\u049f"+
"\u04a0\u0003\u008eG\u0000\u04a0\u008b\u0001\u0000\u0000\u0000\u04a1\u04a2"+
"\u0003\u008eG\u0000\u04a2\u04a6\u0007\n\u0000\u0000\u04a3\u04a5\u0005"+
"\u0006\u0000\u0000\u04a4\u04a3\u0001\u0000\u0000\u0000\u04a5\u04a8\u0001"+
"\u0000\u0000\u0000\u04a6\u04a4\u0001\u0000\u0000\u0000\u04a6\u04a7\u0001"+
"\u0000\u0000\u0000\u04a7\u04a9\u0001\u0000\u0000\u0000\u04a8\u04a6\u0001"+
"\u0000\u0000\u0000\u04a9\u04aa\u0003\u008eG\u0000\u04aa\u008d\u0001\u0000"+
"\u0000\u0000\u04ab\u04ac\u0006G\uffff\uffff\u0000\u04ac\u04ad\u0003\u0090"+
"H\u0000\u04ad\u04b9\u0001\u0000\u0000\u0000\u04ae\u04af\n\u0002\u0000"+
"\u0000\u04af\u04b3\u0007\u000b\u0000\u0000\u04b0\u04b2\u0005\u0006\u0000"+
"\u0000\u04b1\u04b0\u0001\u0000\u0000\u0000\u04b2\u04b5\u0001\u0000\u0000"+
"\u0000\u04b3\u04b1\u0001\u0000\u0000\u0000\u04b3\u04b4\u0001\u0000\u0000"+
"\u0000\u04b4\u04b6\u0001\u0000\u0000\u0000\u04b5\u04b3\u0001\u0000\u0000"+
"\u0000\u04b6\u04b8\u0003\u008eG\u0003\u04b7\u04ae\u0001\u0000\u0000\u0000"+
"\u04b8\u04bb\u0001\u0000\u0000\u0000\u04b9\u04b7\u0001\u0000\u0000\u0000"+
"\u04b9\u04ba\u0001\u0000\u0000\u0000\u04ba\u008f\u0001\u0000\u0000\u0000"+
"\u04bb\u04b9\u0001\u0000\u0000\u0000\u04bc\u04bd\u0006H\uffff\uffff\u0000"+
"\u04bd\u04be\u0003\u0092I\u0000\u04be\u04ca\u0001\u0000\u0000\u0000\u04bf"+
"\u04c0\n\u0002\u0000\u0000\u04c0\u04c4\u0007\f\u0000\u0000\u04c1\u04c3"+
"\u0005\u0006\u0000\u0000\u04c2\u04c1\u0001\u0000\u0000\u0000\u04c3\u04c6"+
"\u0001\u0000\u0000\u0000\u04c4\u04c2\u0001\u0000\u0000\u0000\u04c4\u04c5"+
"\u0001\u0000\u0000\u0000\u04c5\u04c7\u0001\u0000\u0000\u0000\u04c6\u04c4"+
"\u0001\u0000\u0000\u0000\u04c7\u04c9\u0003\u0090H\u0003\u04c8\u04bf\u0001"+
"\u0000\u0000\u0000\u04c9\u04cc\u0001\u0000\u0000\u0000\u04ca\u04c8\u0001"+
"\u0000\u0000\u0000\u04ca\u04cb\u0001\u0000\u0000\u0000\u04cb\u0091\u0001"+
"\u0000\u0000\u0000\u04cc\u04ca\u0001\u0000\u0000\u0000\u04cd\u04ce\u0006"+
"I\uffff\uffff\u0000\u04ce\u04cf\u0003\u0094J\u0000\u04cf\u04db\u0001\u0000"+
"\u0000\u0000\u04d0\u04d1\n\u0002\u0000\u0000\u04d1\u04d5\u0005\u0011\u0000"+
"\u0000\u04d2\u04d4\u0005\u0006\u0000\u0000\u04d3\u04d2\u0001\u0000\u0000"+
"\u0000\u04d4\u04d7\u0001\u0000\u0000\u0000\u04d5\u04d3\u0001\u0000\u0000"+
"\u0000\u04d5\u04d6\u0001\u0000\u0000\u0000\u04d6\u04d8\u0001\u0000\u0000"+
"\u0000\u04d7\u04d5\u0001\u0000\u0000\u0000\u04d8\u04da\u0003\u0092I\u0003"+
"\u04d9\u04d0\u0001\u0000\u0000\u0000\u04da\u04dd\u0001\u0000\u0000\u0000"+
"\u04db\u04d9\u0001\u0000\u0000\u0000\u04db\u04dc\u0001\u0000\u0000\u0000"+
"\u04dc\u0093\u0001\u0000\u0000\u0000\u04dd\u04db\u0001\u0000\u0000\u0000"+
"\u04de\u04e7\u0003\u0096K\u0000\u04df\u04e1\u0005\u0006\u0000\u0000\u04e0"+
"\u04df\u0001\u0000\u0000\u0000\u04e1\u04e4\u0001\u0000\u0000\u0000\u04e2"+
"\u04e0\u0001\u0000\u0000\u0000\u04e2\u04e3\u0001\u0000\u0000\u0000\u04e3"+
"\u04e5\u0001\u0000\u0000\u0000\u04e4\u04e2\u0001\u0000\u0000\u0000\u04e5"+
"\u04e6\u0007\r\u0000\u0000\u04e6\u04e8\u00034\u001a\u0000\u04e7\u04e2"+
"\u0001\u0000\u0000\u0000\u04e7\u04e8\u0001\u0000\u0000\u0000\u04e8\u0095"+
"\u0001\u0000\u0000\u0000\u04e9\u04ed\u0007\u000e\u0000\u0000\u04ea\u04ec"+
"\u0005\u0006\u0000\u0000\u04eb\u04ea\u0001\u0000\u0000\u0000\u04ec\u04ef"+
"\u0001\u0000\u0000\u0000\u04ed\u04eb\u0001\u0000\u0000\u0000\u04ed\u04ee"+
"\u0001\u0000\u0000\u0000\u04ee\u04f0\u0001\u0000\u0000\u0000\u04ef\u04ed"+
"\u0001\u0000\u0000\u0000\u04f0\u04f3\u0003\u0096K\u0000\u04f1\u04f3\u0003"+
"\u0098L\u0000\u04f2\u04e9\u0001\u0000\u0000\u0000\u04f2\u04f1\u0001\u0000"+
"\u0000\u0000\u04f3\u0097\u0001\u0000\u0000\u0000\u04f4\u04f6\u0003\u009a"+
"M\u0000\u04f5\u04f7\u0003\u00b0X\u0000\u04f6\u04f5\u0001\u0000\u0000\u0000"+
"\u04f6\u04f7\u0001\u0000\u0000\u0000\u04f7\u0099\u0001\u0000\u0000\u0000"+
"\u04f8\u04f9\u0006M\uffff\uffff\u0000\u04f9\u04fe\u0003\u00a8T\u0000\u04fa"+
"\u04fe\u0003\u009eO\u0000\u04fb\u04fe\u0003\u00b6[\u0000\u04fc\u04fe\u0003"+
"\u00a0P\u0000\u04fd\u04f8\u0001\u0000\u0000\u0000\u04fd\u04fa\u0001\u0000"+
"\u0000\u0000\u04fd\u04fb\u0001\u0000\u0000\u0000\u04fd\u04fc\u0001\u0000"+
"\u0000\u0000\u04fe\u0510\u0001\u0000\u0000\u0000\u04ff\u0503\n\u0005\u0000"+
"\u0000\u0500\u0502\u0005\u0006\u0000\u0000\u0501\u0500\u0001\u0000\u0000"+
"\u0000\u0502\u0505\u0001\u0000\u0000\u0000\u0503\u0501\u0001\u0000\u0000"+
"\u0000\u0503\u0504\u0001\u0000\u0000\u0000\u0504\u050c\u0001\u0000\u0000"+
"\u0000\u0505\u0503\u0001\u0000\u0000\u0000\u0506\u050d\u0007\u000f\u0000"+
"\u0000\u0507\u050d\u0003\u00aeW\u0000\u0508\u050d\u0003\u00a4R\u0000\u0509"+
"\u050d\u0003\u009cN\u0000\u050a\u050d\u0003\u00acV\u0000\u050b\u050d\u0003"+
"\u00a2Q\u0000\u050c\u0506\u0001\u0000\u0000\u0000\u050c\u0507\u0001\u0000"+
"\u0000\u0000\u050c\u0508\u0001\u0000\u0000\u0000\u050c\u0509\u0001\u0000"+
"\u0000\u0000\u050c\u050a\u0001\u0000\u0000\u0000\u050c\u050b\u0001\u0000"+
"\u0000\u0000\u050d\u050f\u0001\u0000\u0000\u0000\u050e\u04ff\u0001\u0000"+
"\u0000\u0000\u050f\u0512\u0001\u0000\u0000\u0000\u0510\u050e\u0001\u0000"+
"\u0000\u0000\u0510\u0511\u0001\u0000\u0000\u0000\u0511\u009b\u0001\u0000"+
"\u0000\u0000\u0512\u0510\u0001\u0000\u0000\u0000\u0513\u0514\u0005\u0007"+
"\u0000\u0000\u0514\u0515\u0003\u0102\u0081\u0000\u0515\u0516\u0003\u00b0"+
"X\u0000\u0516\u009d\u0001\u0000\u0000\u0000\u0517\u0518\u0003\u0102\u0081"+
"\u0000\u0518\u0519\u0003\u00b0X\u0000\u0519\u009f\u0001\u0000\u0000\u0000"+
"\u051a\u051c\u0003\u0102\u0081\u0000\u051b\u051a\u0001\u0000\u0000\u0000"+
"\u051b\u051c\u0001\u0000\u0000\u0000\u051c\u051d\u0001\u0000\u0000\u0000"+
"\u051d\u051e\u0005!\u0000\u0000\u051e\u052b\u0003\u0102\u0081\u0000\u051f"+
"\u0528\u0005.\u0000\u0000\u0520\u0525\u00034\u001a\u0000\u0521\u0522\u0005"+
"\b\u0000\u0000\u0522\u0524\u00034\u001a\u0000\u0523\u0521\u0001\u0000"+
"\u0000\u0000\u0524\u0527\u0001\u0000\u0000\u0000\u0525\u0523\u0001\u0000"+
"\u0000\u0000\u0525\u0526\u0001\u0000\u0000\u0000\u0526\u0529\u0001\u0000"+
"\u0000\u0000\u0527\u0525\u0001\u0000\u0000\u0000\u0528\u0520\u0001\u0000"+
"\u0000\u0000\u0528\u0529\u0001\u0000\u0000\u0000\u0529\u052a\u0001\u0000"+
"\u0000\u0000\u052a\u052c\u0005/\u0000\u0000\u052b\u051f\u0001\u0000\u0000"+
"\u0000\u052b\u052c\u0001\u0000\u0000\u0000\u052c\u00a1\u0001\u0000\u0000"+
"\u0000\u052d\u052e\u0005\"\u0000\u0000\u052e\u053b\u0003\u0102\u0081\u0000"+
"\u052f\u0538\u0005.\u0000\u0000\u0530\u0535\u00034\u001a\u0000\u0531\u0532"+
"\u0005\b\u0000\u0000\u0532\u0534\u00034\u001a\u0000\u0533\u0531\u0001"+
"\u0000\u0000\u0000\u0534\u0537\u0001\u0000\u0000\u0000\u0535\u0533\u0001"+
"\u0000\u0000\u0000\u0535\u0536\u0001\u0000\u0000\u0000\u0536\u0539\u0001"+
"\u0000\u0000\u0000\u0537\u0535\u0001\u0000\u0000\u0000\u0538\u0530\u0001"+
"\u0000\u0000\u0000\u0538\u0539\u0001\u0000\u0000\u0000\u0539\u053a\u0001"+
"\u0000\u0000\u0000\u053a\u053c\u0005/\u0000\u0000\u053b\u052f\u0001\u0000"+
"\u0000\u0000\u053b\u053c\u0001\u0000\u0000\u0000\u053c\u00a3\u0001\u0000"+
"\u0000\u0000\u053d\u0541\u0003\u00a6S\u0000\u053e\u0540\u0005\u0006\u0000"+
"\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\u0545\u0003f3\u0000\u0545\u00a5\u0001\u0000\u0000\u0000\u0546"+
"\u0547\u0005\u0007\u0000\u0000\u0547\u0548\u0005<\u0000\u0000\u0548\u00a7"+
"\u0001\u0000\u0000\u0000\u0549\u054d\u0003\u00aaU\u0000\u054a\u054c\u0005"+
"\u0006\u0000\u0000\u054b\u054a\u0001\u0000\u0000\u0000\u054c\u054f\u0001"+
"\u0000\u0000\u0000\u054d\u054b\u0001\u0000\u0000\u0000\u054d\u054e\u0001"+
"\u0000\u0000\u0000\u054e\u0550\u0001\u0000\u0000\u0000\u054f\u054d\u0001"+
"\u0000\u0000\u0000\u0550\u0551\u0003f3\u0000\u0551\u00a9\u0001\u0000\u0000"+
"\u0000\u0552\u0553\u0005b\u0000\u0000\u0553\u0554\u0005\t\u0000\u0000"+
"\u0554\u0555\u0003x<\u0000\u0555\u0556\u0005\n\u0000\u0000\u0556\u00ab"+
"\u0001\u0000\u0000\u0000\u0557\u0558\u0005\u0007\u0000\u0000\u0558\u0559"+
"\u0003\u0102\u0081\u0000\u0559\u00ad\u0001\u0000\u0000\u0000\u055a\u055b"+
"\u0005\u000b\u0000\u0000\u055b\u055c\u0003x<\u0000\u055c\u055d\u0005\f"+
"\u0000\u0000\u055d\u0563\u0001\u0000\u0000\u0000\u055e\u055f\u0005\r\u0000"+
"\u0000\u055f\u0560\u0003x<\u0000\u0560\u0561\u0005\u000e\u0000\u0000\u0561"+
"\u0563\u0001\u0000\u0000\u0000\u0562\u055a\u0001\u0000\u0000\u0000\u0562"+
"\u055e\u0001\u0000\u0000\u0000\u0563\u00af\u0001\u0000\u0000\u0000\u0564"+
"\u0566\u00030\u0018\u0000\u0565\u0564\u0001\u0000\u0000\u0000\u0565\u0566"+
"\u0001\u0000\u0000\u0000\u0566\u0567\u0001\u0000\u0000\u0000\u0567\u0568"+
"\u0003\u00b2Y\u0000\u0568\u00b1\u0001\u0000\u0000\u0000\u0569\u0572\u0005"+
"\t\u0000\u0000\u056a\u056f\u0003\u00b4Z\u0000\u056b\u056c\u0005\b\u0000"+
"\u0000\u056c\u056e\u0003\u00b4Z\u0000\u056d\u056b\u0001\u0000\u0000\u0000"+
"\u056e\u0571\u0001\u0000\u0000\u0000\u056f\u056d\u0001\u0000\u0000\u0000"+
"\u056f\u0570\u0001\u0000\u0000\u0000\u0570\u0573\u0001\u0000\u0000\u0000"+
"\u0571\u056f\u0001\u0000\u0000\u0000\u0572\u056a\u0001\u0000\u0000\u0000"+
"\u0572\u0573\u0001\u0000\u0000\u0000\u0573\u0574\u0001\u0000\u0000\u0000"+
"\u0574\u0575\u0005\n\u0000\u0000\u0575\u00b3\u0001\u0000\u0000\u0000\u0576"+
"\u0578\u0005\u0006\u0000\u0000\u0577\u0576\u0001\u0000\u0000\u0000\u0578"+
"\u057b\u0001\u0000\u0000\u0000\u0579\u0577\u0001\u0000\u0000\u0000\u0579"+
"\u057a\u0001\u0000\u0000\u0000\u057a\u057c\u0001\u0000\u0000\u0000\u057b"+
"\u0579\u0001\u0000\u0000\u0000\u057c\u057d\u0003x<\u0000\u057d\u00b5\u0001"+
"\u0000\u0000\u0000\u057e\u0589\u0003\u00be_\u0000\u057f\u0589\u0003p8"+
"\u0000\u0580\u0589\u0003\u00d4j\u0000\u0581\u0589\u0003\u00ba]\u0000\u0582"+
"\u0589\u0003\u00b8\\\u0000\u0583\u0589\u0003\u00c0`\u0000\u0584\u0589"+
"\u0003\u00ccf\u0000\u0585\u0589\u0003\u00bc^\u0000\u0586\u0589\u0003t"+
":\u0000\u0587\u0589\u0003v;\u0000\u0588\u057e\u0001\u0000\u0000\u0000"+
"\u0588\u057f\u0001\u0000\u0000\u0000\u0588\u0580\u0001\u0000\u0000\u0000"+
"\u0588\u0581\u0001\u0000\u0000\u0000\u0588\u0582\u0001\u0000\u0000\u0000"+
"\u0588\u0583\u0001\u0000\u0000\u0000\u0588\u0584\u0001\u0000\u0000\u0000"+
"\u0588\u0585\u0001\u0000\u0000\u0000\u0588\u0586\u0001\u0000\u0000\u0000"+
"\u0588\u0587\u0001\u0000\u0000\u0000\u0589\u00b7\u0001\u0000\u0000\u0000"+
"\u058a\u058b\u0003\u0102\u0081\u0000\u058b\u00b9\u0001\u0000\u0000\u0000"+
"\u058c\u058d\u0005\\\u0000\u0000\u058d\u00bb\u0001\u0000\u0000\u0000\u058e"+
"\u058f\u0005[\u0000\u0000\u058f\u00bd\u0001\u0000\u0000\u0000\u0590\u0591"+
"\u0005\t\u0000\u0000\u0591\u0592\u0003x<\u0000\u0592\u0593\u0005\n\u0000"+
"\u0000\u0593\u00bf\u0001\u0000\u0000\u0000\u0594\u0598\u0005K\u0000\u0000"+
"\u0595\u0597\u0005\u0006\u0000\u0000\u0596\u0595\u0001\u0000\u0000\u0000"+
"\u0597\u059a\u0001\u0000\u0000\u0000\u0598\u0596\u0001\u0000\u0000\u0000"+
"\u0598\u0599\u0001\u0000\u0000\u0000\u0599\u059b\u0001\u0000\u0000\u0000"+
"\u059a\u0598\u0001\u0000\u0000\u0000\u059b\u059f\u0003x<\u0000\u059c\u059e"+
"\u0005\u0006\u0000\u0000\u059d\u059c\u0001\u0000\u0000\u0000\u059e\u05a1"+
"\u0001\u0000\u0000\u0000\u059f\u059d\u0001\u0000\u0000\u0000\u059f\u05a0"+
"\u0001\u0000\u0000\u0000\u05a0\u05a5\u0001\u0000\u0000\u0000\u05a1\u059f"+
"\u0001\u0000\u0000\u0000\u05a2\u05a4\u0005\u0006\u0000\u0000\u05a3\u05a2"+
"\u0001\u0000\u0000\u0000\u05a4\u05a7\u0001\u0000\u0000\u0000\u05a5\u05a3"+
"\u0001\u0000\u0000\u0000\u05a5\u05a6\u0001\u0000\u0000\u0000\u05a6\u05a9"+
"\u0001\u0000\u0000\u0000\u05a7\u05a5\u0001\u0000\u0000\u0000\u05a8\u05aa"+
"\u0003h4\u0000\u05a9\u05a8\u0001\u0000\u0000\u0000\u05a9\u05aa\u0001\u0000"+
"\u0000\u0000\u05aa\u05ac\u0001\u0000\u0000\u0000\u05ab\u05ad\u0005#\u0000"+
"\u0000\u05ac\u05ab\u0001\u0000\u0000\u0000\u05ac\u05ad\u0001\u0000\u0000"+
"\u0000\u05ad\u05bc\u0001\u0000\u0000\u0000\u05ae\u05b0\u0005\u0006\u0000"+
"\u0000\u05af\u05ae\u0001\u0000\u0000\u0000\u05b0\u05b3\u0001\u0000\u0000"+
"\u0000\u05b1\u05af\u0001\u0000\u0000\u0000\u05b1\u05b2\u0001\u0000\u0000"+
"\u0000\u05b2\u05b4\u0001\u0000\u0000\u0000\u05b3\u05b1\u0001\u0000\u0000"+
"\u0000\u05b4\u05b8\u0005D\u0000\u0000\u05b5\u05b7\u0005\u0006\u0000\u0000"+
"\u05b6\u05b5\u0001\u0000\u0000\u0000\u05b7\u05ba\u0001\u0000\u0000\u0000"+
"\u05b8\u05b6\u0001\u0000\u0000\u0000\u05b8\u05b9\u0001\u0000\u0000\u0000"+
"\u05b9\u05bb\u0001\u0000\u0000\u0000\u05ba\u05b8\u0001\u0000\u0000\u0000"+
"\u05bb\u05bd\u0003h4\u0000\u05bc\u05b1\u0001\u0000\u0000\u0000\u05bc\u05bd"+
"\u0001\u0000\u0000\u0000\u05bd\u00c1\u0001\u0000\u0000\u0000\u05be\u05bf"+
"\u0003\u00c4b\u0000\u05bf\u05c0\u0003\u00c6c\u0000\u05c0\u00c3\u0001\u0000"+
"\u0000\u0000\u05c1\u05c2\u0005H\u0000\u0000\u05c2\u05c6\u0003\u0102\u0081"+
"\u0000\u05c3\u05c5\u0005\u0006\u0000\u0000\u05c4\u05c3\u0001\u0000\u0000"+
"\u0000\u05c5\u05c8\u0001\u0000\u0000\u0000\u05c6\u05c4\u0001\u0000\u0000"+
"\u0000\u05c6\u05c7\u0001\u0000\u0000\u0000\u05c7\u05c9\u0001\u0000\u0000"+
"\u0000\u05c8\u05c6\u0001\u0000\u0000\u0000\u05c9\u05cd\u0005L\u0000\u0000"+
"\u05ca\u05cc\u0005\u0006\u0000\u0000\u05cb\u05ca\u0001\u0000\u0000\u0000"+
"\u05cc\u05cf\u0001\u0000\u0000\u0000\u05cd\u05cb\u0001\u0000\u0000\u0000"+
"\u05cd\u05ce\u0001\u0000\u0000\u0000\u05ce\u05d0\u0001\u0000\u0000\u0000"+
"\u05cf\u05cd\u0001\u0000\u0000\u0000\u05d0\u05d1\u0003x<\u0000\u05d1\u060e"+
"\u0001\u0000\u0000\u0000\u05d2\u05d3\u0005H\u0000\u0000\u05d3\u05d4\u0005"+
"\t\u0000\u0000\u05d4\u05d8\u0003\u0102\u0081\u0000\u05d5\u05d7\u0005\u0006"+
"\u0000\u0000\u05d6\u05d5\u0001\u0000\u0000\u0000\u05d7\u05da\u0001\u0000"+
"\u0000\u0000\u05d8\u05d6\u0001\u0000\u0000\u0000\u05d8\u05d9\u0001\u0000"+
"\u0000\u0000\u05d9\u05db\u0001\u0000\u0000\u0000\u05da\u05d8\u0001\u0000"+
"\u0000\u0000\u05db\u05df\u0005L\u0000\u0000\u05dc\u05de\u0005\u0006\u0000"+
"\u0000\u05dd\u05dc\u0001\u0000\u0000\u0000\u05de\u05e1\u0001\u0000\u0000"+
"\u0000\u05df\u05dd\u0001\u0000\u0000\u0000\u05df\u05e0\u0001\u0000\u0000"+
"\u0000\u05e0\u05e2\u0001\u0000\u0000\u0000\u05e1\u05df\u0001\u0000\u0000"+
"\u0000\u05e2\u05e3\u0003x<\u0000\u05e3\u05e4\u0005\n\u0000\u0000\u05e4"+
"\u060e\u0001\u0000\u0000\u0000\u05e5\u05e6\u0005H\u0000\u0000\u05e6\u05e7"+
"\u0003\u0102\u0081\u0000\u05e7\u05e8\u0005\b\u0000\u0000\u05e8\u05ec\u0003"+
"\u0102\u0081\u0000\u05e9\u05eb\u0005\u0006\u0000\u0000\u05ea\u05e9\u0001"+
"\u0000\u0000\u0000\u05eb\u05ee\u0001\u0000\u0000\u0000\u05ec\u05ea\u0001"+
"\u0000\u0000\u0000\u05ec\u05ed\u0001\u0000\u0000\u0000\u05ed\u05ef\u0001"+
"\u0000\u0000\u0000\u05ee\u05ec\u0001\u0000\u0000\u0000\u05ef\u05f3\u0005"+
"L\u0000\u0000\u05f0\u05f2\u0005\u0006\u0000\u0000\u05f1\u05f0\u0001\u0000"+
"\u0000\u0000\u05f2\u05f5\u0001\u0000\u0000\u0000\u05f3\u05f1\u0001\u0000"+
"\u0000\u0000\u05f3\u05f4\u0001\u0000\u0000\u0000\u05f4\u05f6\u0001\u0000"+
"\u0000\u0000\u05f5\u05f3\u0001\u0000\u0000\u0000\u05f6\u05f7\u0003x<\u0000"+
"\u05f7\u060e\u0001\u0000\u0000\u0000\u05f8\u05f9\u0005H\u0000\u0000\u05f9"+
"\u05fa\u0005\t\u0000\u0000\u05fa\u05fb\u0003\u0102\u0081\u0000\u05fb\u05fc"+
"\u0005\b\u0000\u0000\u05fc\u0600\u0003\u0102\u0081\u0000\u05fd\u05ff\u0005"+
"\u0006\u0000\u0000\u05fe\u05fd\u0001\u0000\u0000\u0000\u05ff\u0602\u0001"+
"\u0000\u0000\u0000\u0600\u05fe\u0001\u0000\u0000\u0000\u0600\u0601\u0001"+
"\u0000\u0000\u0000\u0601\u0603\u0001\u0000\u0000\u0000\u0602\u0600\u0001"+
"\u0000\u0000\u0000\u0603\u0607\u0005L\u0000\u0000\u0604\u0606\u0005\u0006"+
"\u0000\u0000\u0605\u0604\u0001\u0000\u0000\u0000\u0606\u0609\u0001\u0000"+
"\u0000\u0000\u0607\u0605\u0001\u0000\u0000\u0000\u0607\u0608\u0001\u0000"+
"\u0000\u0000\u0608\u060a\u0001\u0000\u0000\u0000\u0609\u0607\u0001\u0000"+
"\u0000\u0000\u060a\u060b\u0003x<\u0000\u060b\u060c\u0005\n\u0000\u0000"+
"\u060c\u060e\u0001\u0000\u0000\u0000\u060d\u05c1\u0001\u0000\u0000\u0000"+
"\u060d\u05d2\u0001\u0000\u0000\u0000\u060d\u05e5\u0001\u0000\u0000\u0000"+
"\u060d\u05f8\u0001\u0000\u0000\u0000\u060e\u00c5\u0001\u0000\u0000\u0000"+
"\u060f\u0611\u0003h4\u0000\u0610\u060f\u0001\u0000\u0000\u0000\u0610\u0611"+
"\u0001\u0000\u0000\u0000\u0611\u00c7\u0001\u0000\u0000\u0000\u0612\u0616"+
"\u0005a\u0000\u0000\u0613\u0615\u0005\u0006\u0000\u0000\u0614\u0613\u0001"+
"\u0000\u0000\u0000\u0615\u0618\u0001\u0000\u0000\u0000\u0616\u0614\u0001"+
"\u0000\u0000\u0000\u0616\u0617\u0001\u0000\u0000\u0000\u0617\u0619\u0001"+
"\u0000\u0000\u0000\u0618\u0616\u0001\u0000\u0000\u0000\u0619\u061a\u0005"+
"\t\u0000\u0000\u061a\u061b\u0003x<\u0000\u061b\u061f\u0005\n\u0000\u0000"+
"\u061c\u061e\u0005\u0006\u0000\u0000\u061d\u061c\u0001\u0000\u0000\u0000"+
"\u061e\u0621\u0001\u0000\u0000\u0000\u061f\u061d\u0001\u0000\u0000\u0000"+
"\u061f\u0620\u0001\u0000\u0000\u0000\u0620\u0622\u0001\u0000\u0000\u0000"+
"\u0621\u061f\u0001\u0000\u0000\u0000\u0622\u0623\u0003h4\u0000\u0623\u00c9"+
"\u0001\u0000\u0000\u0000\u0624\u0628\u0005C\u0000\u0000\u0625\u0627\u0005"+
"\u0006\u0000\u0000\u0626\u0625\u0001\u0000\u0000\u0000\u0627\u062a\u0001"+
"\u0000\u0000\u0000\u0628\u0626\u0001\u0000\u0000\u0000\u0628\u0629\u0001"+
"\u0000\u0000\u0000\u0629\u062b\u0001\u0000\u0000\u0000\u062a\u0628\u0001"+
"\u0000\u0000\u0000\u062b\u062f\u0003h4\u0000\u062c\u062e\u0005\u0006\u0000"+
"\u0000\u062d\u062c\u0001\u0000\u0000\u0000\u062e\u0631\u0001\u0000\u0000"+
"\u0000\u062f\u062d\u0001\u0000\u0000\u0000\u062f\u0630\u0001\u0000\u0000"+
"\u0000\u0630\u063d\u0001\u0000\u0000\u0000\u0631\u062f\u0001\u0000\u0000"+
"\u0000\u0632\u0636\u0005a\u0000\u0000\u0633\u0635\u0005\u0006\u0000\u0000"+
"\u0634\u0633\u0001\u0000\u0000\u0000\u0635\u0638\u0001\u0000\u0000\u0000"+
"\u0636\u0634\u0001\u0000\u0000\u0000\u0636\u0637\u0001\u0000\u0000\u0000"+
"\u0637\u0639\u0001\u0000\u0000\u0000\u0638\u0636\u0001\u0000\u0000\u0000"+
"\u0639\u063a\u0005\t\u0000\u0000\u063a\u063b\u0003x<\u0000\u063b\u063c"+
"\u0005\n\u0000\u0000\u063c\u063e\u0001\u0000\u0000\u0000\u063d\u0632\u0001"+
"\u0000\u0000\u0000\u063d\u063e\u0001\u0000\u0000\u0000\u063e\u00cb\u0001"+
"\u0000\u0000\u0000\u063f\u0643\u0005^\u0000\u0000\u0640\u0642\u0005\u0006"+
"\u0000\u0000\u0641\u0640\u0001\u0000\u0000\u0000\u0642\u0645\u0001\u0000"+
"\u0000\u0000\u0643\u0641\u0001\u0000\u0000\u0000\u0643\u0644\u0001\u0000"+
"\u0000\u0000\u0644\u0646\u0001\u0000\u0000\u0000\u0645\u0643\u0001\u0000"+
"\u0000\u0000\u0646\u0650\u0003\u00ceg\u0000\u0647\u0649\u0005\u0006\u0000"+
"\u0000\u0648\u0647\u0001\u0000\u0000\u0000\u0649\u064c\u0001\u0000\u0000"+
"\u0000\u064a\u0648\u0001\u0000\u0000\u0000\u064a\u064b\u0001\u0000\u0000"+
"\u0000\u064b\u064d\u0001\u0000\u0000\u0000\u064c\u064a\u0001\u0000\u0000"+
"\u0000\u064d\u064f\u0003\u00d0h\u0000\u064e\u064a\u0001\u0000\u0000\u0000"+
"\u064f\u0652\u0001\u0000\u0000\u0000\u0650\u064e\u0001\u0000\u0000\u0000"+
"\u0650\u0651\u0001\u0000\u0000\u0000\u0651\u065a\u0001\u0000\u0000\u0000"+
"\u0652\u0650\u0001\u0000\u0000\u0000\u0653\u0655\u0005\u0006\u0000\u0000"+
"\u0654\u0653\u0001\u0000\u0000\u0000\u0655\u0658\u0001\u0000\u0000\u0000"+
"\u0656\u0654\u0001\u0000\u0000\u0000\u0656\u0657\u0001\u0000\u0000\u0000"+
"\u0657\u0659\u0001\u0000\u0000\u0000\u0658\u0656\u0001\u0000\u0000\u0000"+
"\u0659\u065b\u0003\u00d2i\u0000\u065a\u0656\u0001\u0000\u0000\u0000\u065a"+
"\u065b\u0001\u0000\u0000\u0000\u065b\u00cd\u0001\u0000\u0000\u0000\u065c"+
"\u065d\u0003f3\u0000\u065d\u00cf\u0001\u0000\u0000\u0000\u065e\u0662\u0005"+
"?\u0000\u0000\u065f\u0661\u0005\u0006\u0000\u0000\u0660\u065f\u0001\u0000"+
"\u0000\u0000\u0661\u0664\u0001\u0000\u0000\u0000\u0662\u0660\u0001\u0000"+
"\u0000\u0000\u0662\u0663\u0001\u0000\u0000\u0000\u0663\u0665\u0001\u0000"+
"\u0000\u0000\u0664\u0662\u0001\u0000\u0000\u0000\u0665\u0666\u0005\t\u0000"+
"\u0000\u0666\u0667\u0003\u0102\u0081\u0000\u0667\u0668\u0005 \u0000\u0000"+
"\u0668\u0669\u0003\u0102\u0081\u0000\u0669\u066d\u0005\n\u0000\u0000\u066a"+
"\u066c\u0005\u0006\u0000\u0000\u066b\u066a\u0001\u0000\u0000\u0000\u066c"+
"\u066f\u0001\u0000\u0000\u0000\u066d\u066b\u0001\u0000\u0000\u0000\u066d"+
"\u066e\u0001\u0000\u0000\u0000\u066e\u0670\u0001\u0000\u0000\u0000\u066f"+
"\u066d\u0001\u0000\u0000\u0000\u0670\u0671\u0003f3\u0000\u0671\u00d1\u0001"+
"\u0000\u0000\u0000\u0672\u0676\u0005G\u0000\u0000\u0673\u0675\u0005\u0006"+
"\u0000\u0000\u0674\u0673\u0001\u0000\u0000\u0000\u0675\u0678\u0001\u0000"+
"\u0000\u0000\u0676\u0674\u0001\u0000\u0000\u0000\u0676\u0677\u0001\u0000"+
"\u0000\u0000\u0677\u0679\u0001\u0000\u0000\u0000\u0678\u0676\u0001\u0000"+
"\u0000\u0000\u0679\u067a\u0003f3\u0000\u067a\u00d3\u0001\u0000\u0000\u0000"+
"\u067b\u0688\u0003\u00d6k\u0000\u067c\u0688\u0003\u00d8l\u0000\u067d\u0688"+
"\u0003\u00dam\u0000\u067e\u0688\u0003\u00dcn\u0000\u067f\u0688\u0003\u00de"+
"o\u0000\u0680\u0688\u0003\u00e0p\u0000\u0681\u0688\u0003\u00e2q\u0000"+
"\u0682\u0688\u0003\u00e4r\u0000\u0683\u0688\u0003\u00e6s\u0000\u0684\u0688"+
"\u0003\u00e8t\u0000\u0685\u0688\u0003\u00eau\u0000\u0686\u0688\u0003\u00fa"+
"}\u0000\u0687\u067b\u0001\u0000\u0000\u0000\u0687\u067c\u0001\u0000\u0000"+
"\u0000\u0687\u067d\u0001\u0000\u0000\u0000\u0687\u067e\u0001\u0000\u0000"+
"\u0000\u0687\u067f\u0001\u0000\u0000\u0000\u0687\u0680\u0001\u0000\u0000"+
"\u0000\u0687\u0681\u0001\u0000\u0000\u0000\u0687\u0682\u0001\u0000\u0000"+
"\u0000\u0687\u0683\u0001\u0000\u0000\u0000\u0687\u0684\u0001\u0000\u0000"+
"\u0000\u0687\u0685\u0001\u0000\u0000\u0000\u0687\u0686\u0001\u0000\u0000"+
"\u0000\u0688\u00d5\u0001\u0000\u0000\u0000\u0689\u068a\u0005q\u0000\u0000"+
"\u068a\u00d7\u0001\u0000\u0000\u0000\u068b\u068c\u0005p\u0000\u0000\u068c"+
"\u00d9\u0001\u0000\u0000\u0000\u068d\u068e\u0005v\u0000\u0000\u068e\u00db"+
"\u0001\u0000\u0000\u0000\u068f\u0690\u0005i\u0000\u0000\u0690\u00dd\u0001"+
"\u0000\u0000\u0000\u0691\u0692\u0005j\u0000\u0000\u0692\u00df\u0001\u0000"+
"\u0000\u0000\u0693\u0694\u0005k\u0000\u0000\u0694\u00e1\u0001\u0000\u0000"+
"\u0000\u0695\u0696\u0005h\u0000\u0000\u0696\u00e3\u0001\u0000\u0000\u0000"+
"\u0697\u0698\u0005f\u0000\u0000\u0698\u00e5\u0001\u0000\u0000\u0000\u0699"+
"\u069a\u0005g\u0000\u0000\u069a\u00e7\u0001\u0000\u0000\u0000\u069b\u069c"+
"\u0005l\u0000\u0000\u069c\u00e9\u0001\u0000\u0000\u0000\u069d\u06a0\u0003"+
"\u00ecv\u0000\u069e\u06a0\u0003\u00eew\u0000\u069f\u069d\u0001\u0000\u0000"+
"\u0000\u069f\u069e\u0001\u0000\u0000\u0000\u06a0\u00eb\u0001\u0000\u0000"+
"\u0000\u06a1\u06a6\u0005c\u0000\u0000\u06a2\u06a5\u0003\u00f0x\u0000\u06a3"+
"\u06a5\u0003\u00f2y\u0000\u06a4\u06a2\u0001\u0000\u0000\u0000\u06a4\u06a3"+
"\u0001\u0000\u0000\u0000\u06a5\u06a8\u0001\u0000\u0000\u0000\u06a6\u06a4"+
"\u0001\u0000\u0000\u0000\u06a6\u06a7\u0001\u0000\u0000\u0000\u06a7\u06a9"+
"\u0001\u0000\u0000\u0000\u06a8\u06a6\u0001\u0000\u0000\u0000\u06a9\u06aa"+
"\u0005\u0082\u0000\u0000\u06aa\u00ed\u0001\u0000\u0000\u0000\u06ab\u06b1"+
"\u0005d\u0000\u0000\u06ac\u06b0\u0003\u00f4z\u0000\u06ad\u06b0\u0003\u00f6"+
"{\u0000\u06ae\u06b0\u0003\u00f8|\u0000\u06af\u06ac\u0001\u0000\u0000\u0000"+
"\u06af\u06ad\u0001\u0000\u0000\u0000\u06af\u06ae\u0001\u0000\u0000\u0000"+
"\u06b0\u06b3\u0001\u0000\u0000\u0000\u06b1\u06af\u0001\u0000\u0000\u0000"+
"\u06b1\u06b2\u0001\u0000\u0000\u0000\u06b2\u06b4\u0001\u0000\u0000\u0000"+
"\u06b3\u06b1\u0001\u0000\u0000\u0000\u06b4\u06b5\u0005\u0087\u0000\u0000"+
"\u06b5\u00ef\u0001\u0000\u0000\u0000\u06b6\u06b8\u0007\u0010\u0000\u0000"+
"\u06b7\u06b6\u0001\u0000\u0000\u0000\u06b8\u06b9\u0001\u0000\u0000\u0000"+
"\u06b9\u06b7\u0001\u0000\u0000\u0000\u06b9\u06ba\u0001\u0000\u0000\u0000"+
"\u06ba\u06bd\u0001\u0000\u0000\u0000\u06bb\u06bd\u0005\u0083\u0000\u0000"+
"\u06bc\u06b7\u0001\u0000\u0000\u0000\u06bc\u06bb\u0001\u0000\u0000\u0000"+
"\u06bd\u00f1\u0001\u0000\u0000\u0000\u06be\u06bf\u0005\u0086\u0000\u0000"+
"\u06bf\u06c0\u0003x<\u0000\u06c0\u06c1\u0005\u0010\u0000\u0000\u06c1\u00f3"+
"\u0001\u0000\u0000\u0000\u06c2\u06c4\u0007\u0011\u0000\u0000\u06c3\u06c2"+
"\u0001\u0000\u0000\u0000\u06c4\u06c5\u0001\u0000\u0000\u0000\u06c5\u06c3"+
"\u0001\u0000\u0000\u0000\u06c5\u06c6\u0001\u0000\u0000\u0000\u06c6\u06c9"+
"\u0001\u0000\u0000\u0000\u06c7\u06c9\u0005\u0089\u0000\u0000\u06c8\u06c3"+
"\u0001\u0000\u0000\u0000\u06c8\u06c7\u0001\u0000\u0000\u0000\u06c9\u00f5"+
"\u0001\u0000\u0000\u0000\u06ca\u06cb\u0005\u008c\u0000\u0000\u06cb\u06cc"+
"\u0003x<\u0000\u06cc\u06cd\u0005\u0010\u0000\u0000\u06cd\u00f7\u0001\u0000"+
"\u0000\u0000\u06ce\u06cf\u0005\u0088\u0000\u0000\u06cf\u00f9\u0001\u0000"+
"\u0000\u0000\u06d0\u06d5\u0005e\u0000\u0000\u06d1\u06d4\u0003\u00fc~\u0000"+
"\u06d2\u06d4\u0003\u00fe\u007f\u0000\u06d3\u06d1\u0001\u0000\u0000\u0000"+
"\u06d3\u06d2\u0001\u0000\u0000\u0000\u06d4\u06d7\u0001\u0000\u0000\u0000"+
"\u06d5\u06d3\u0001\u0000\u0000\u0000\u06d5\u06d6\u0001\u0000\u0000\u0000"+
"\u06d6\u06d8\u0001\u0000\u0000\u0000\u06d7\u06d5\u0001\u0000\u0000\u0000"+
"\u06d8\u06d9\u0005\u0092\u0000\u0000\u06d9\u00fb\u0001\u0000\u0000\u0000"+
"\u06da\u06dc\u0007\u0012\u0000\u0000\u06db\u06da\u0001\u0000\u0000\u0000"+
"\u06dc\u06dd\u0001\u0000\u0000\u0000\u06dd\u06db\u0001\u0000\u0000\u0000"+
"\u06dd\u06de\u0001\u0000\u0000\u0000\u06de\u06e1\u0001\u0000\u0000\u0000"+
"\u06df\u06e1\u0005\u0093\u0000\u0000\u06e0\u06db\u0001\u0000\u0000\u0000"+
"\u06e0\u06df\u0001\u0000\u0000\u0000\u06e1\u00fd\u0001\u0000\u0000\u0000"+
"\u06e2\u06e3\u0005\u0096\u0000\u0000\u06e3\u06e4\u0003x<\u0000\u06e4\u06e5"+
"\u0005\u0010\u0000\u0000\u06e5\u00ff\u0001\u0000\u0000\u0000\u06e6\u06f1"+
"\u0003\u0102\u0081\u0000\u06e7\u06e9\u0005\u0006\u0000\u0000\u06e8\u06e7"+
"\u0001\u0000\u0000\u0000\u06e9\u06ec\u0001\u0000\u0000\u0000\u06ea\u06e8"+
"\u0001\u0000\u0000\u0000\u06ea\u06eb\u0001\u0000\u0000\u0000\u06eb\u06ed"+
"\u0001\u0000\u0000\u0000\u06ec\u06ea\u0001\u0000\u0000\u0000\u06ed\u06ee"+
"\u0005\u0007\u0000\u0000\u06ee\u06f0\u0003\u0102\u0081\u0000\u06ef\u06ea"+
"\u0001\u0000\u0000\u0000\u06f0\u06f3\u0001\u0000\u0000\u0000\u06f1\u06ef"+
"\u0001\u0000\u0000\u0000\u06f1\u06f2\u0001\u0000\u0000\u0000\u06f2\u0101"+
"\u0001\u0000\u0000\u0000\u06f3\u06f1\u0001\u0000\u0000\u0000\u06f4\u06f5"+
"\u0007\u0013\u0000\u0000\u06f5\u0103\u0001\u0000\u0000\u0000\u06f6\u06f8"+
"\u0005\u0006\u0000\u0000\u06f7\u06f6\u0001\u0000\u0000\u0000\u06f8\u06f9"+
"\u0001\u0000\u0000\u0000\u06f9\u06f7\u0001\u0000\u0000\u0000\u06f9\u06fa"+
"\u0001\u0000\u0000\u0000\u06fa\u0709\u0001\u0000\u0000\u0000\u06fb\u06fd"+
"\u0005\u0006\u0000\u0000\u06fc\u06fb\u0001\u0000\u0000\u0000\u06fd\u0700"+
"\u0001\u0000\u0000\u0000\u06fe\u06fc\u0001\u0000\u0000\u0000\u06fe\u06ff"+
"\u0001\u0000\u0000\u0000\u06ff\u0701\u0001\u0000\u0000\u0000\u0700\u06fe"+
"\u0001\u0000\u0000\u0000\u0701\u0705\u0005#\u0000\u0000\u0702\u0704\u0005"+
"\u0006\u0000\u0000\u0703\u0702\u0001\u0000\u0000\u0000\u0704\u0707\u0001"+
"\u0000\u0000\u0000\u0705\u0703\u0001\u0000\u0000\u0000\u0705\u0706\u0001"+
"\u0000\u0000\u0000\u0706\u0709\u0001\u0000\u0000\u0000\u0707\u0705\u0001"+
"\u0000\u0000\u0000\u0708\u06f7\u0001\u0000\u0000\u0000\u0708\u06fe\u0001"+
"\u0000\u0000\u0000\u0709\u0105\u0001\u0000\u0000\u0000\u070a\u070b\u0007"+
"\u0014\u0000\u0000\u070b\u0107\u0001\u0000\u0000\u0000\u00ed\u0109\u010e"+
"\u0114\u011b\u0121\u0128\u012b\u012f\u0132\u013e\u0140\u0145\u0147\u014d"+
"\u0151\u0157\u015a\u015f\u0167\u016d\u0176\u017a\u0181\u0187\u018e\u0192"+
"\u0195\u0198\u019c\u01a1\u01a4\u01a9\u01b2\u01b5\u01ba\u01be\u01c3\u01ca"+
"\u01d0\u01d7\u01dd\u01e2\u01e8\u01f1\u01f5\u01fa\u0200\u0206\u020f\u0216"+
"\u021c\u0222\u0226\u0231\u0234\u0237\u023d\u0244\u024b\u0251\u0258\u025c"+
"\u0260\u0268\u026b\u0272\u0279\u0280\u0286\u0291\u0296\u029d\u02a1\u02a4"+
"\u02ab\u02b2\u02b9\u02bd\u02c5\u02c8\u02d0\u02d8\u02dc\u02e2\u02e9\u02ed"+
"\u02f0\u02f4\u02fa\u0302\u0309\u030d\u0313\u031a\u0321\u0327\u032d\u0334"+
"\u033b\u0342\u034b\u0353\u0359\u035d\u0360\u0364\u0367\u036a\u036d\u0373"+
"\u037a\u0381\u0388\u038c\u0394\u0397\u039f\u03a6\u03aa\u03b4\u03b9\u03c0"+
"\u03c3\u03c7\u03ca\u03ce\u03d4\u03db\u03e2\u03e6\u03ec\u03f3\u0404\u0407"+
"\u0411\u0419\u0423\u042a\u0430\u043a\u0441\u0447\u0452\u0458\u0460\u0464"+
"\u046b\u046f\u0479\u047f\u0486\u048d\u0494\u049c\u04a6\u04b3\u04b9\u04c4"+
"\u04ca\u04d5\u04db\u04e2\u04e7\u04ed\u04f2\u04f6\u04fd\u0503\u050c\u0510"+
"\u051b\u0525\u0528\u052b\u0535\u0538\u053b\u0541\u054d\u0562\u0565\u056f"+
"\u0572\u0579\u0588\u0598\u059f\u05a5\u05a9\u05ac\u05b1\u05b8\u05bc\u05c6"+
"\u05cd\u05d8\u05df\u05ec\u05f3\u0600\u0607\u060d\u0610\u0616\u061f\u0628"+
"\u062f\u0636\u063d\u0643\u064a\u0650\u0656\u065a\u0662\u066d\u0676\u0687"+
"\u069f\u06a4\u06a6\u06af\u06b1\u06b9\u06bc\u06c5\u06c8\u06d3\u06d5\u06dd"+
"\u06e0\u06ea\u06f1\u06f9\u06fe\u0705\u0708";
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);
}
}
}