// Generated from /Users/jeason/projects/github.com/jeasonstudio/solidity-antlr4/grammar/SolidityParser.g4 by ANTLR 4.13.1 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"}) public class SolidityParser extends Parser { static { RuntimeMetaData.checkVersion("4.13.1", RuntimeMetaData.VERSION); } protected static final DFA[] _decisionToDFA; protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache(); public static final int ReservedKeywords=1, Abstract=2, Address=3, Anonymous=4, As=5, Assembly=6, Bool=7, Break=8, Bytes=9, Calldata=10, Catch=11, Constant=12, Constructor=13, Continue=14, Contract=15, Delete=16, Do=17, Else=18, Emit=19, Enum=20, Error=21, Event=22, External=23, Fallback=24, False=25, Fixed=26, FixedBytes=27, For=28, From=29, Function=30, Global=31, Hex=32, If=33, Immutable=34, Import=35, Indexed=36, Interface=37, Internal=38, Is=39, Library=40, Mapping=41, Memory=42, Modifier=43, New=44, SubDenomination=45, Override=46, Payable=47, Pragma=48, Private=49, Public=50, Pure=51, Receive=52, Return=53, Returns=54, Revert=55, SignedIntegerType=56, Storage=57, String=58, Struct=59, True=60, Try=61, Type=62, Ufixed=63, Unchecked=64, Unicode=65, UnsignedIntegerType=66, Using=67, View=68, Virtual=69, While=70, LParen=71, RParen=72, LBrack=73, RBrack=74, LBrace=75, RBrace=76, Colon=77, Semicolon=78, Period=79, Conditional=80, DoubleArrow=81, RightArrow=82, Assign=83, AssignBitOr=84, AssignBitXor=85, AssignBitAnd=86, AssignShl=87, AssignSar=88, AssignShr=89, AssignAdd=90, AssignSub=91, AssignMul=92, AssignDiv=93, AssignMod=94, Comma=95, Or=96, And=97, BitOr=98, BitXor=99, BitAnd=100, Shl=101, Sar=102, Shr=103, Add=104, Sub=105, Mul=106, Div=107, Mod=108, Exp=109, Equal=110, NotEqual=111, LessThan=112, GreaterThan=113, LessThanOrEqual=114, GreaterThanOrEqual=115, Not=116, BitNot=117, Inc=118, Dec=119, DoubleQuote=120, SingleQuote=121, NonEmptyStringLiteral=122, EmptyStringLiteral=123, UnicodeStringLiteral=124, HexString=125, HexNumber=126, OctalNumber=127, DecimalNumber=128, DecimalNumberFollowedByIdentifier=129, Identifier=130, WS=131, COMMENT=132, LINE_COMMENT=133, AssemblyDialect=134, AssemblyLBrace=135, AssemblyFlagString=136, AssemblyBlockLParen=137, AssemblyBlockRParen=138, AssemblyBlockComma=139, AssemblyBlockWS=140, AssemblyBlockCOMMENT=141, AssemblyBlockLINE_COMMENT=142, YulBreak=143, YulCase=144, YulContinue=145, YulDefault=146, YulFalse=147, YulFor=148, YulFunction=149, YulIf=150, YulLeave=151, YulLet=152, YulSwitch=153, YulTrue=154, YulHex=155, YulEVMBuiltin=156, YulLBrace=157, YulRBrace=158, YulLParen=159, YulRParen=160, YulAssign=161, YulPeriod=162, YulComma=163, YulArrow=164, YulIdentifier=165, YulHexNumber=166, YulDecimalNumber=167, YulStringLiteral=168, YulHexStringLiteral=169, YulWS=170, YulCOMMENT=171, YulLINE_COMMENT=172, PragmaToken=173, PragmaSemicolon=174, PragmaWS=175, PragmaCOMMENT=176, PragmaLINE_COMMENT=177; public static final int RULE_sourceUnit = 0, RULE_pragmaDirective = 1, RULE_importDirective = 2, RULE_importAliases = 3, RULE_path = 4, RULE_symbolAliases = 5, RULE_contractDefinition = 6, RULE_interfaceDefinition = 7, RULE_libraryDefinition = 8, RULE_inheritanceSpecifierList = 9, RULE_inheritanceSpecifier = 10, RULE_contractBodyElement = 11, RULE_namedArgument = 12, RULE_callArgumentList = 13, RULE_identifierPath = 14, RULE_modifierInvocation = 15, RULE_visibility = 16, RULE_parameterList = 17, RULE_parameterDeclaration = 18, RULE_constructorDefinition = 19, RULE_stateMutability = 20, RULE_overrideSpecifier = 21, RULE_functionDefinition = 22, RULE_modifierDefinition = 23, RULE_fallbackFunctionDefinition = 24, RULE_receiveFunctionDefinition = 25, RULE_structDefinition = 26, RULE_structMember = 27, RULE_enumDefinition = 28, RULE_userDefinedValueTypeDefinition = 29, RULE_stateVariableDeclaration = 30, RULE_constantVariableDeclaration = 31, RULE_eventParameter = 32, RULE_eventDefinition = 33, RULE_errorParameter = 34, RULE_errorDefinition = 35, RULE_userDefinableOperator = 36, RULE_usingDirective = 37, RULE_usingAliases = 38, RULE_typeName = 39, RULE_elementaryTypeName = 40, RULE_functionTypeName = 41, RULE_variableDeclaration = 42, RULE_dataLocation = 43, RULE_expression = 44, RULE_assignOp = 45, RULE_tupleExpression = 46, RULE_inlineArrayExpression = 47, RULE_identifier = 48, RULE_literal = 49, RULE_literalWithSubDenomination = 50, RULE_booleanLiteral = 51, RULE_stringLiteral = 52, RULE_hexStringLiteral = 53, RULE_unicodeStringLiteral = 54, RULE_numberLiteral = 55, RULE_block = 56, RULE_uncheckedBlock = 57, RULE_statement = 58, RULE_simpleStatement = 59, RULE_ifStatement = 60, RULE_forStatement = 61, RULE_whileStatement = 62, RULE_doWhileStatement = 63, RULE_continueStatement = 64, RULE_breakStatement = 65, RULE_tryStatement = 66, RULE_catchClause = 67, RULE_returnStatement = 68, RULE_emitStatement = 69, RULE_revertStatement = 70, RULE_assemblyStatement = 71, RULE_assemblyFlags = 72, RULE_variableDeclarationList = 73, RULE_variableDeclarationTuple = 74, RULE_variableDeclarationStatement = 75, RULE_expressionStatement = 76, RULE_mappingType = 77, RULE_mappingKeyType = 78, RULE_yulStatement = 79, RULE_yulBlock = 80, RULE_yulVariableDeclaration = 81, RULE_yulAssignment = 82, RULE_yulIfStatement = 83, RULE_yulForStatement = 84, RULE_yulSwitchCase = 85, RULE_yulSwitchStatement = 86, RULE_yulFunctionDefinition = 87, RULE_yulPath = 88, RULE_yulFunctionCall = 89, RULE_yulBoolean = 90, RULE_yulLiteral = 91, RULE_yulExpression = 92; private static String[] makeRuleNames() { return new String[] { "sourceUnit", "pragmaDirective", "importDirective", "importAliases", "path", "symbolAliases", "contractDefinition", "interfaceDefinition", "libraryDefinition", "inheritanceSpecifierList", "inheritanceSpecifier", "contractBodyElement", "namedArgument", "callArgumentList", "identifierPath", "modifierInvocation", "visibility", "parameterList", "parameterDeclaration", "constructorDefinition", "stateMutability", "overrideSpecifier", "functionDefinition", "modifierDefinition", "fallbackFunctionDefinition", "receiveFunctionDefinition", "structDefinition", "structMember", "enumDefinition", "userDefinedValueTypeDefinition", "stateVariableDeclaration", "constantVariableDeclaration", "eventParameter", "eventDefinition", "errorParameter", "errorDefinition", "userDefinableOperator", "usingDirective", "usingAliases", "typeName", "elementaryTypeName", "functionTypeName", "variableDeclaration", "dataLocation", "expression", "assignOp", "tupleExpression", "inlineArrayExpression", "identifier", "literal", "literalWithSubDenomination", "booleanLiteral", "stringLiteral", "hexStringLiteral", "unicodeStringLiteral", "numberLiteral", "block", "uncheckedBlock", "statement", "simpleStatement", "ifStatement", "forStatement", "whileStatement", "doWhileStatement", "continueStatement", "breakStatement", "tryStatement", "catchClause", "returnStatement", "emitStatement", "revertStatement", "assemblyStatement", "assemblyFlags", "variableDeclarationList", "variableDeclarationTuple", "variableDeclarationStatement", "expressionStatement", "mappingType", "mappingKeyType", "yulStatement", "yulBlock", "yulVariableDeclaration", "yulAssignment", "yulIfStatement", "yulForStatement", "yulSwitchCase", "yulSwitchStatement", "yulFunctionDefinition", "yulPath", "yulFunctionCall", "yulBoolean", "yulLiteral", "yulExpression" }; } public static final String[] ruleNames = makeRuleNames(); private static String[] makeLiteralNames() { return new String[] { null, null, "'abstract'", "'address'", "'anonymous'", "'as'", "'assembly'", "'bool'", null, "'bytes'", "'calldata'", "'catch'", "'constant'", "'constructor'", null, "'contract'", "'delete'", "'do'", "'else'", "'emit'", "'enum'", "'error'", "'event'", "'external'", "'fallback'", null, null, null, null, "'from'", null, "'global'", null, null, "'immutable'", "'import'", "'indexed'", "'interface'", "'internal'", "'is'", "'library'", "'mapping'", "'memory'", "'modifier'", "'new'", null, "'override'", "'payable'", "'pragma'", "'private'", "'public'", "'pure'", "'receive'", "'return'", "'returns'", "'revert'", null, "'storage'", "'string'", "'struct'", null, "'try'", "'type'", null, "'unchecked'", "'unicode'", null, "'using'", "'view'", "'virtual'", "'while'", null, null, "'['", "']'", null, null, "':'", null, null, "'?'", "'=>'", null, "'='", "'|='", "'^='", "'&='", "'<<='", "'>>='", "'>>>='", "'+='", "'-='", "'*='", "'/='", "'%='", null, "'||'", "'&&'", "'|'", "'^'", "'&'", "'<<'", "'>>'", "'>>>'", "'+'", "'-'", "'*'", "'/'", "'%'", "'**'", "'=='", "'!='", "'<'", "'>'", "'<='", "'>='", "'!'", "'~'", "'++'", "'--'", "'\"'", "'''", null, null, null, null, null, null, null, null, null, null, null, null, "'\"evmasm\"'", null, null, null, null, null, null, null, null, null, "'case'", null, "'default'", null, null, null, null, "'leave'", "'let'", "'switch'", null, null, null, null, null, null, null, "':='" }; } private static final String[] _LITERAL_NAMES = makeLiteralNames(); private static String[] makeSymbolicNames() { return new String[] { null, "ReservedKeywords", "Abstract", "Address", "Anonymous", "As", "Assembly", "Bool", "Break", "Bytes", "Calldata", "Catch", "Constant", "Constructor", "Continue", "Contract", "Delete", "Do", "Else", "Emit", "Enum", "Error", "Event", "External", "Fallback", "False", "Fixed", "FixedBytes", "For", "From", "Function", "Global", "Hex", "If", "Immutable", "Import", "Indexed", "Interface", "Internal", "Is", "Library", "Mapping", "Memory", "Modifier", "New", "SubDenomination", "Override", "Payable", "Pragma", "Private", "Public", "Pure", "Receive", "Return", "Returns", "Revert", "SignedIntegerType", "Storage", "String", "Struct", "True", "Try", "Type", "Ufixed", "Unchecked", "Unicode", "UnsignedIntegerType", "Using", "View", "Virtual", "While", "LParen", "RParen", "LBrack", "RBrack", "LBrace", "RBrace", "Colon", "Semicolon", "Period", "Conditional", "DoubleArrow", "RightArrow", "Assign", "AssignBitOr", "AssignBitXor", "AssignBitAnd", "AssignShl", "AssignSar", "AssignShr", "AssignAdd", "AssignSub", "AssignMul", "AssignDiv", "AssignMod", "Comma", "Or", "And", "BitOr", "BitXor", "BitAnd", "Shl", "Sar", "Shr", "Add", "Sub", "Mul", "Div", "Mod", "Exp", "Equal", "NotEqual", "LessThan", "GreaterThan", "LessThanOrEqual", "GreaterThanOrEqual", "Not", "BitNot", "Inc", "Dec", "DoubleQuote", "SingleQuote", "NonEmptyStringLiteral", "EmptyStringLiteral", "UnicodeStringLiteral", "HexString", "HexNumber", "OctalNumber", "DecimalNumber", "DecimalNumberFollowedByIdentifier", "Identifier", "WS", "COMMENT", "LINE_COMMENT", "AssemblyDialect", "AssemblyLBrace", "AssemblyFlagString", "AssemblyBlockLParen", "AssemblyBlockRParen", "AssemblyBlockComma", "AssemblyBlockWS", "AssemblyBlockCOMMENT", "AssemblyBlockLINE_COMMENT", "YulBreak", "YulCase", "YulContinue", "YulDefault", "YulFalse", "YulFor", "YulFunction", "YulIf", "YulLeave", "YulLet", "YulSwitch", "YulTrue", "YulHex", "YulEVMBuiltin", "YulLBrace", "YulRBrace", "YulLParen", "YulRParen", "YulAssign", "YulPeriod", "YulComma", "YulArrow", "YulIdentifier", "YulHexNumber", "YulDecimalNumber", "YulStringLiteral", "YulHexStringLiteral", "YulWS", "YulCOMMENT", "YulLINE_COMMENT", "PragmaToken", "PragmaSemicolon", "PragmaWS", "PragmaCOMMENT", "PragmaLINE_COMMENT" }; } private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); /** * @deprecated Use {@link #VOCABULARY} instead. */ @Deprecated public static final String[] tokenNames; static { tokenNames = new String[_SYMBOLIC_NAMES.length]; for (int i = 0; i < tokenNames.length; i++) { tokenNames[i] = VOCABULARY.getLiteralName(i); if (tokenNames[i] == null) { tokenNames[i] = VOCABULARY.getSymbolicName(i); } if (tokenNames[i] == null) { tokenNames[i] = ""; } } } @Override @Deprecated public String[] getTokenNames() { return tokenNames; } @Override public Vocabulary getVocabulary() { return VOCABULARY; } @Override public String getGrammarFileName() { return "SolidityParser.g4"; } @Override public String[] getRuleNames() { return ruleNames; } @Override public String getSerializedATN() { return _serializedATN; } @Override public ATN getATN() { return _ATN; } public SolidityParser(TokenStream input) { super(input); _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); } @SuppressWarnings("CheckReturnValue") public static class SourceUnitContext extends ParserRuleContext { public TerminalNode EOF() { return getToken(SolidityParser.EOF, 0); } public List pragmaDirective() { return getRuleContexts(PragmaDirectiveContext.class); } public PragmaDirectiveContext pragmaDirective(int i) { return getRuleContext(PragmaDirectiveContext.class,i); } public List importDirective() { return getRuleContexts(ImportDirectiveContext.class); } public ImportDirectiveContext importDirective(int i) { return getRuleContext(ImportDirectiveContext.class,i); } public List usingDirective() { return getRuleContexts(UsingDirectiveContext.class); } public UsingDirectiveContext usingDirective(int i) { return getRuleContext(UsingDirectiveContext.class,i); } public List contractDefinition() { return getRuleContexts(ContractDefinitionContext.class); } public ContractDefinitionContext contractDefinition(int i) { return getRuleContext(ContractDefinitionContext.class,i); } public List interfaceDefinition() { return getRuleContexts(InterfaceDefinitionContext.class); } public InterfaceDefinitionContext interfaceDefinition(int i) { return getRuleContext(InterfaceDefinitionContext.class,i); } public List libraryDefinition() { return getRuleContexts(LibraryDefinitionContext.class); } public LibraryDefinitionContext libraryDefinition(int i) { return getRuleContext(LibraryDefinitionContext.class,i); } public List functionDefinition() { return getRuleContexts(FunctionDefinitionContext.class); } public FunctionDefinitionContext functionDefinition(int i) { return getRuleContext(FunctionDefinitionContext.class,i); } public List constantVariableDeclaration() { return getRuleContexts(ConstantVariableDeclarationContext.class); } public ConstantVariableDeclarationContext constantVariableDeclaration(int i) { return getRuleContext(ConstantVariableDeclarationContext.class,i); } public List structDefinition() { return getRuleContexts(StructDefinitionContext.class); } public StructDefinitionContext structDefinition(int i) { return getRuleContext(StructDefinitionContext.class,i); } public List enumDefinition() { return getRuleContexts(EnumDefinitionContext.class); } public EnumDefinitionContext enumDefinition(int i) { return getRuleContext(EnumDefinitionContext.class,i); } public List userDefinedValueTypeDefinition() { return getRuleContexts(UserDefinedValueTypeDefinitionContext.class); } public UserDefinedValueTypeDefinitionContext userDefinedValueTypeDefinition(int i) { return getRuleContext(UserDefinedValueTypeDefinitionContext.class,i); } public List errorDefinition() { return getRuleContexts(ErrorDefinitionContext.class); } public ErrorDefinitionContext errorDefinition(int i) { return getRuleContext(ErrorDefinitionContext.class,i); } public List eventDefinition() { return getRuleContexts(EventDefinitionContext.class); } public EventDefinitionContext eventDefinition(int i) { return getRuleContext(EventDefinitionContext.class,i); } public SourceUnitContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_sourceUnit; } } public final SourceUnitContext sourceUnit() throws RecognitionException { SourceUnitContext _localctx = new SourceUnitContext(_ctx, getState()); enterRule(_localctx, 0, RULE_sourceUnit); try { int _alt; enterOuterAlt(_localctx, 1); { setState(201); _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(199); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) { case 1: { setState(186); pragmaDirective(); } break; case 2: { setState(187); importDirective(); } break; case 3: { setState(188); usingDirective(); } break; case 4: { setState(189); contractDefinition(); } break; case 5: { setState(190); interfaceDefinition(); } break; case 6: { setState(191); libraryDefinition(); } break; case 7: { setState(192); functionDefinition(); } break; case 8: { setState(193); constantVariableDeclaration(); } break; case 9: { setState(194); structDefinition(); } break; case 10: { setState(195); enumDefinition(); } break; case 11: { setState(196); userDefinedValueTypeDefinition(); } break; case 12: { setState(197); errorDefinition(); } break; case 13: { setState(198); eventDefinition(); } break; } } } setState(203); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,1,_ctx); } setState(204); 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 PragmaDirectiveContext extends ParserRuleContext { public TerminalNode Pragma() { return getToken(SolidityParser.Pragma, 0); } public TerminalNode PragmaSemicolon() { return getToken(SolidityParser.PragmaSemicolon, 0); } public List PragmaToken() { return getTokens(SolidityParser.PragmaToken); } public TerminalNode PragmaToken(int i) { return getToken(SolidityParser.PragmaToken, i); } public PragmaDirectiveContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_pragmaDirective; } } public final PragmaDirectiveContext pragmaDirective() throws RecognitionException { PragmaDirectiveContext _localctx = new PragmaDirectiveContext(_ctx, getState()); enterRule(_localctx, 2, RULE_pragmaDirective); int _la; try { enterOuterAlt(_localctx, 1); { setState(206); match(Pragma); setState(208); _errHandler.sync(this); _la = _input.LA(1); do { { { setState(207); match(PragmaToken); } } setState(210); _errHandler.sync(this); _la = _input.LA(1); } while ( _la==PragmaToken ); setState(212); match(PragmaSemicolon); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class ImportDirectiveContext extends ParserRuleContext { public IdentifierContext unitAlias; public TerminalNode Import() { return getToken(SolidityParser.Import, 0); } public TerminalNode Semicolon() { return getToken(SolidityParser.Semicolon, 0); } public PathContext path() { return getRuleContext(PathContext.class,0); } public SymbolAliasesContext symbolAliases() { return getRuleContext(SymbolAliasesContext.class,0); } public TerminalNode From() { return getToken(SolidityParser.From, 0); } public TerminalNode Mul() { return getToken(SolidityParser.Mul, 0); } public TerminalNode As() { return getToken(SolidityParser.As, 0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public ImportDirectiveContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_importDirective; } } public final ImportDirectiveContext importDirective() throws RecognitionException { ImportDirectiveContext _localctx = new ImportDirectiveContext(_ctx, getState()); enterRule(_localctx, 4, RULE_importDirective); int _la; try { enterOuterAlt(_localctx, 1); { setState(214); match(Import); setState(230); _errHandler.sync(this); switch (_input.LA(1)) { case NonEmptyStringLiteral: { { setState(215); path(); setState(218); _errHandler.sync(this); _la = _input.LA(1); if (_la==As) { { setState(216); match(As); setState(217); ((ImportDirectiveContext)_localctx).unitAlias = identifier(); } } } } break; case LBrace: { { setState(220); symbolAliases(); setState(221); match(From); setState(222); path(); } } break; case Mul: { { setState(224); match(Mul); setState(225); match(As); setState(226); ((ImportDirectiveContext)_localctx).unitAlias = identifier(); setState(227); match(From); setState(228); path(); } } break; default: throw new NoViableAltException(this); } setState(232); 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 ImportAliasesContext extends ParserRuleContext { public IdentifierContext symbol; public IdentifierContext alias; public List identifier() { return getRuleContexts(IdentifierContext.class); } public IdentifierContext identifier(int i) { return getRuleContext(IdentifierContext.class,i); } public TerminalNode As() { return getToken(SolidityParser.As, 0); } public ImportAliasesContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_importAliases; } } public final ImportAliasesContext importAliases() throws RecognitionException { ImportAliasesContext _localctx = new ImportAliasesContext(_ctx, getState()); enterRule(_localctx, 6, RULE_importAliases); int _la; try { enterOuterAlt(_localctx, 1); { setState(234); ((ImportAliasesContext)_localctx).symbol = identifier(); setState(237); _errHandler.sync(this); _la = _input.LA(1); if (_la==As) { { setState(235); match(As); setState(236); ((ImportAliasesContext)_localctx).alias = identifier(); } } } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class PathContext extends ParserRuleContext { public TerminalNode NonEmptyStringLiteral() { return getToken(SolidityParser.NonEmptyStringLiteral, 0); } public PathContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_path; } } public final PathContext path() throws RecognitionException { PathContext _localctx = new PathContext(_ctx, getState()); enterRule(_localctx, 8, RULE_path); try { enterOuterAlt(_localctx, 1); { setState(239); match(NonEmptyStringLiteral); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class SymbolAliasesContext extends ParserRuleContext { public ImportAliasesContext importAliases; public List aliases = new ArrayList(); public TerminalNode LBrace() { return getToken(SolidityParser.LBrace, 0); } public TerminalNode RBrace() { return getToken(SolidityParser.RBrace, 0); } public List importAliases() { return getRuleContexts(ImportAliasesContext.class); } public ImportAliasesContext importAliases(int i) { return getRuleContext(ImportAliasesContext.class,i); } public List Comma() { return getTokens(SolidityParser.Comma); } public TerminalNode Comma(int i) { return getToken(SolidityParser.Comma, i); } public SymbolAliasesContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_symbolAliases; } } public final SymbolAliasesContext symbolAliases() throws RecognitionException { SymbolAliasesContext _localctx = new SymbolAliasesContext(_ctx, getState()); enterRule(_localctx, 10, RULE_symbolAliases); int _la; try { enterOuterAlt(_localctx, 1); { setState(241); match(LBrace); setState(242); ((SymbolAliasesContext)_localctx).importAliases = importAliases(); ((SymbolAliasesContext)_localctx).aliases.add(((SymbolAliasesContext)_localctx).importAliases); setState(247); _errHandler.sync(this); _la = _input.LA(1); while (_la==Comma) { { { setState(243); match(Comma); setState(244); ((SymbolAliasesContext)_localctx).importAliases = importAliases(); ((SymbolAliasesContext)_localctx).aliases.add(((SymbolAliasesContext)_localctx).importAliases); } } setState(249); _errHandler.sync(this); _la = _input.LA(1); } setState(250); match(RBrace); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class ContractDefinitionContext extends ParserRuleContext { public IdentifierContext name; public TerminalNode Contract() { return getToken(SolidityParser.Contract, 0); } public TerminalNode LBrace() { return getToken(SolidityParser.LBrace, 0); } public TerminalNode RBrace() { return getToken(SolidityParser.RBrace, 0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public TerminalNode Abstract() { return getToken(SolidityParser.Abstract, 0); } public InheritanceSpecifierListContext inheritanceSpecifierList() { return getRuleContext(InheritanceSpecifierListContext.class,0); } public List contractBodyElement() { return getRuleContexts(ContractBodyElementContext.class); } public ContractBodyElementContext contractBodyElement(int i) { return getRuleContext(ContractBodyElementContext.class,i); } public ContractDefinitionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_contractDefinition; } } public final ContractDefinitionContext contractDefinition() throws RecognitionException { ContractDefinitionContext _localctx = new ContractDefinitionContext(_ctx, getState()); enterRule(_localctx, 12, RULE_contractDefinition); int _la; try { int _alt; enterOuterAlt(_localctx, 1); { setState(253); _errHandler.sync(this); _la = _input.LA(1); if (_la==Abstract) { { setState(252); match(Abstract); } } setState(255); match(Contract); setState(256); ((ContractDefinitionContext)_localctx).name = identifier(); setState(258); _errHandler.sync(this); _la = _input.LA(1); if (_la==Is) { { setState(257); inheritanceSpecifierList(); } } setState(260); match(LBrace); setState(264); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,9,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(261); contractBodyElement(); } } } setState(266); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,9,_ctx); } setState(267); match(RBrace); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class InterfaceDefinitionContext extends ParserRuleContext { public IdentifierContext name; public TerminalNode Interface() { return getToken(SolidityParser.Interface, 0); } public TerminalNode LBrace() { return getToken(SolidityParser.LBrace, 0); } public TerminalNode RBrace() { return getToken(SolidityParser.RBrace, 0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public InheritanceSpecifierListContext inheritanceSpecifierList() { return getRuleContext(InheritanceSpecifierListContext.class,0); } public List contractBodyElement() { return getRuleContexts(ContractBodyElementContext.class); } public ContractBodyElementContext contractBodyElement(int i) { return getRuleContext(ContractBodyElementContext.class,i); } public InterfaceDefinitionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_interfaceDefinition; } } public final InterfaceDefinitionContext interfaceDefinition() throws RecognitionException { InterfaceDefinitionContext _localctx = new InterfaceDefinitionContext(_ctx, getState()); enterRule(_localctx, 14, RULE_interfaceDefinition); int _la; try { int _alt; enterOuterAlt(_localctx, 1); { setState(269); match(Interface); setState(270); ((InterfaceDefinitionContext)_localctx).name = identifier(); setState(272); _errHandler.sync(this); _la = _input.LA(1); if (_la==Is) { { setState(271); inheritanceSpecifierList(); } } setState(274); match(LBrace); setState(278); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,11,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(275); contractBodyElement(); } } } setState(280); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,11,_ctx); } setState(281); match(RBrace); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class LibraryDefinitionContext extends ParserRuleContext { public IdentifierContext name; public TerminalNode Library() { return getToken(SolidityParser.Library, 0); } public TerminalNode LBrace() { return getToken(SolidityParser.LBrace, 0); } public TerminalNode RBrace() { return getToken(SolidityParser.RBrace, 0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public List contractBodyElement() { return getRuleContexts(ContractBodyElementContext.class); } public ContractBodyElementContext contractBodyElement(int i) { return getRuleContext(ContractBodyElementContext.class,i); } public LibraryDefinitionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_libraryDefinition; } } public final LibraryDefinitionContext libraryDefinition() throws RecognitionException { LibraryDefinitionContext _localctx = new LibraryDefinitionContext(_ctx, getState()); enterRule(_localctx, 16, RULE_libraryDefinition); try { int _alt; enterOuterAlt(_localctx, 1); { setState(283); match(Library); setState(284); ((LibraryDefinitionContext)_localctx).name = identifier(); setState(285); match(LBrace); setState(289); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,12,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(286); contractBodyElement(); } } } setState(291); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,12,_ctx); } setState(292); match(RBrace); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class InheritanceSpecifierListContext extends ParserRuleContext { public InheritanceSpecifierContext inheritanceSpecifier; public List inheritanceSpecifiers = new ArrayList(); public TerminalNode Is() { return getToken(SolidityParser.Is, 0); } public List inheritanceSpecifier() { return getRuleContexts(InheritanceSpecifierContext.class); } public InheritanceSpecifierContext inheritanceSpecifier(int i) { return getRuleContext(InheritanceSpecifierContext.class,i); } public List Comma() { return getTokens(SolidityParser.Comma); } public TerminalNode Comma(int i) { return getToken(SolidityParser.Comma, i); } public InheritanceSpecifierListContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_inheritanceSpecifierList; } } public final InheritanceSpecifierListContext inheritanceSpecifierList() throws RecognitionException { InheritanceSpecifierListContext _localctx = new InheritanceSpecifierListContext(_ctx, getState()); enterRule(_localctx, 18, RULE_inheritanceSpecifierList); try { int _alt; enterOuterAlt(_localctx, 1); { setState(294); match(Is); setState(295); ((InheritanceSpecifierListContext)_localctx).inheritanceSpecifier = inheritanceSpecifier(); ((InheritanceSpecifierListContext)_localctx).inheritanceSpecifiers.add(((InheritanceSpecifierListContext)_localctx).inheritanceSpecifier); setState(300); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,13,_ctx); while ( _alt!=1 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1+1 ) { { { setState(296); match(Comma); setState(297); ((InheritanceSpecifierListContext)_localctx).inheritanceSpecifier = inheritanceSpecifier(); ((InheritanceSpecifierListContext)_localctx).inheritanceSpecifiers.add(((InheritanceSpecifierListContext)_localctx).inheritanceSpecifier); } } } setState(302); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,13,_ctx); } } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class InheritanceSpecifierContext extends ParserRuleContext { public IdentifierPathContext name; public CallArgumentListContext arguments; public IdentifierPathContext identifierPath() { return getRuleContext(IdentifierPathContext.class,0); } public CallArgumentListContext callArgumentList() { return getRuleContext(CallArgumentListContext.class,0); } public InheritanceSpecifierContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_inheritanceSpecifier; } } public final InheritanceSpecifierContext inheritanceSpecifier() throws RecognitionException { InheritanceSpecifierContext _localctx = new InheritanceSpecifierContext(_ctx, getState()); enterRule(_localctx, 20, RULE_inheritanceSpecifier); int _la; try { enterOuterAlt(_localctx, 1); { setState(303); ((InheritanceSpecifierContext)_localctx).name = identifierPath(); setState(305); _errHandler.sync(this); _la = _input.LA(1); if (_la==LParen) { { setState(304); ((InheritanceSpecifierContext)_localctx).arguments = callArgumentList(); } } } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class ContractBodyElementContext extends ParserRuleContext { public ConstructorDefinitionContext constructorDefinition() { return getRuleContext(ConstructorDefinitionContext.class,0); } public FunctionDefinitionContext functionDefinition() { return getRuleContext(FunctionDefinitionContext.class,0); } public ModifierDefinitionContext modifierDefinition() { return getRuleContext(ModifierDefinitionContext.class,0); } public FallbackFunctionDefinitionContext fallbackFunctionDefinition() { return getRuleContext(FallbackFunctionDefinitionContext.class,0); } public ReceiveFunctionDefinitionContext receiveFunctionDefinition() { return getRuleContext(ReceiveFunctionDefinitionContext.class,0); } public StructDefinitionContext structDefinition() { return getRuleContext(StructDefinitionContext.class,0); } public EnumDefinitionContext enumDefinition() { return getRuleContext(EnumDefinitionContext.class,0); } public UserDefinedValueTypeDefinitionContext userDefinedValueTypeDefinition() { return getRuleContext(UserDefinedValueTypeDefinitionContext.class,0); } public StateVariableDeclarationContext stateVariableDeclaration() { return getRuleContext(StateVariableDeclarationContext.class,0); } public EventDefinitionContext eventDefinition() { return getRuleContext(EventDefinitionContext.class,0); } public ErrorDefinitionContext errorDefinition() { return getRuleContext(ErrorDefinitionContext.class,0); } public UsingDirectiveContext usingDirective() { return getRuleContext(UsingDirectiveContext.class,0); } public ContractBodyElementContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_contractBodyElement; } } public final ContractBodyElementContext contractBodyElement() throws RecognitionException { ContractBodyElementContext _localctx = new ContractBodyElementContext(_ctx, getState()); enterRule(_localctx, 22, RULE_contractBodyElement); try { setState(319); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { setState(307); constructorDefinition(); } break; case 2: enterOuterAlt(_localctx, 2); { setState(308); functionDefinition(); } break; case 3: enterOuterAlt(_localctx, 3); { setState(309); modifierDefinition(); } break; case 4: enterOuterAlt(_localctx, 4); { setState(310); fallbackFunctionDefinition(); } break; case 5: enterOuterAlt(_localctx, 5); { setState(311); receiveFunctionDefinition(); } break; case 6: enterOuterAlt(_localctx, 6); { setState(312); structDefinition(); } break; case 7: enterOuterAlt(_localctx, 7); { setState(313); enumDefinition(); } break; case 8: enterOuterAlt(_localctx, 8); { setState(314); userDefinedValueTypeDefinition(); } break; case 9: enterOuterAlt(_localctx, 9); { setState(315); stateVariableDeclaration(); } break; case 10: enterOuterAlt(_localctx, 10); { setState(316); eventDefinition(); } break; case 11: enterOuterAlt(_localctx, 11); { setState(317); errorDefinition(); } break; case 12: enterOuterAlt(_localctx, 12); { setState(318); usingDirective(); } break; } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class NamedArgumentContext extends ParserRuleContext { public IdentifierContext name; public ExpressionContext value; public TerminalNode Colon() { return getToken(SolidityParser.Colon, 0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } public NamedArgumentContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_namedArgument; } } public final NamedArgumentContext namedArgument() throws RecognitionException { NamedArgumentContext _localctx = new NamedArgumentContext(_ctx, getState()); enterRule(_localctx, 24, RULE_namedArgument); try { enterOuterAlt(_localctx, 1); { setState(321); ((NamedArgumentContext)_localctx).name = identifier(); setState(322); match(Colon); setState(323); ((NamedArgumentContext)_localctx).value = expression(0); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class CallArgumentListContext extends ParserRuleContext { public TerminalNode LParen() { return getToken(SolidityParser.LParen, 0); } public TerminalNode RParen() { return getToken(SolidityParser.RParen, 0); } public TerminalNode LBrace() { return getToken(SolidityParser.LBrace, 0); } public TerminalNode RBrace() { return getToken(SolidityParser.RBrace, 0); } public List expression() { return getRuleContexts(ExpressionContext.class); } public ExpressionContext expression(int i) { return getRuleContext(ExpressionContext.class,i); } public List namedArgument() { return getRuleContexts(NamedArgumentContext.class); } public NamedArgumentContext namedArgument(int i) { return getRuleContext(NamedArgumentContext.class,i); } public List Comma() { return getTokens(SolidityParser.Comma); } public TerminalNode Comma(int i) { return getToken(SolidityParser.Comma, i); } public CallArgumentListContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_callArgumentList; } } public final CallArgumentListContext callArgumentList() throws RecognitionException { CallArgumentListContext _localctx = new CallArgumentListContext(_ctx, getState()); enterRule(_localctx, 26, RULE_callArgumentList); int _la; try { enterOuterAlt(_localctx, 1); { setState(325); match(LParen); setState(348); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) { case 1: { setState(334); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) { case 1: { setState(326); expression(0); setState(331); _errHandler.sync(this); _la = _input.LA(1); while (_la==Comma) { { { setState(327); match(Comma); setState(328); expression(0); } } setState(333); _errHandler.sync(this); _la = _input.LA(1); } } break; } } break; case 2: { setState(336); match(LBrace); setState(345); _errHandler.sync(this); _la = _input.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 36028799705415680L) != 0) || _la==Identifier) { { setState(337); namedArgument(); setState(342); _errHandler.sync(this); _la = _input.LA(1); while (_la==Comma) { { { setState(338); match(Comma); setState(339); namedArgument(); } } setState(344); _errHandler.sync(this); _la = _input.LA(1); } } } setState(347); match(RBrace); } break; } setState(350); 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 IdentifierPathContext extends ParserRuleContext { public List identifier() { return getRuleContexts(IdentifierContext.class); } public IdentifierContext identifier(int i) { return getRuleContext(IdentifierContext.class,i); } public List Period() { return getTokens(SolidityParser.Period); } public TerminalNode Period(int i) { return getToken(SolidityParser.Period, i); } public IdentifierPathContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_identifierPath; } } public final IdentifierPathContext identifierPath() throws RecognitionException { IdentifierPathContext _localctx = new IdentifierPathContext(_ctx, getState()); enterRule(_localctx, 28, RULE_identifierPath); try { int _alt; enterOuterAlt(_localctx, 1); { setState(352); identifier(); setState(357); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,21,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(353); match(Period); setState(354); identifier(); } } } setState(359); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,21,_ctx); } } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class ModifierInvocationContext extends ParserRuleContext { public IdentifierPathContext identifierPath() { return getRuleContext(IdentifierPathContext.class,0); } public CallArgumentListContext callArgumentList() { return getRuleContext(CallArgumentListContext.class,0); } public ModifierInvocationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_modifierInvocation; } } public final ModifierInvocationContext modifierInvocation() throws RecognitionException { ModifierInvocationContext _localctx = new ModifierInvocationContext(_ctx, getState()); enterRule(_localctx, 30, RULE_modifierInvocation); try { enterOuterAlt(_localctx, 1); { setState(360); identifierPath(); setState(362); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) { case 1: { setState(361); callArgumentList(); } break; } } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class VisibilityContext extends ParserRuleContext { public TerminalNode Internal() { return getToken(SolidityParser.Internal, 0); } public TerminalNode External() { return getToken(SolidityParser.External, 0); } public TerminalNode Private() { return getToken(SolidityParser.Private, 0); } public TerminalNode Public() { return getToken(SolidityParser.Public, 0); } public VisibilityContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_visibility; } } public final VisibilityContext visibility() throws RecognitionException { VisibilityContext _localctx = new VisibilityContext(_ctx, getState()); enterRule(_localctx, 32, RULE_visibility); int _la; try { enterOuterAlt(_localctx, 1); { setState(364); _la = _input.LA(1); if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 1689124746559488L) != 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 ParameterListContext extends ParserRuleContext { public ParameterDeclarationContext parameterDeclaration; public List parameters = new ArrayList(); public List parameterDeclaration() { return getRuleContexts(ParameterDeclarationContext.class); } public ParameterDeclarationContext parameterDeclaration(int i) { return getRuleContext(ParameterDeclarationContext.class,i); } public List Comma() { return getTokens(SolidityParser.Comma); } public TerminalNode Comma(int i) { return getToken(SolidityParser.Comma, i); } public ParameterListContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_parameterList; } } public final ParameterListContext parameterList() throws RecognitionException { ParameterListContext _localctx = new ParameterListContext(_ctx, getState()); enterRule(_localctx, 34, RULE_parameterList); int _la; try { enterOuterAlt(_localctx, 1); { setState(366); ((ParameterListContext)_localctx).parameterDeclaration = parameterDeclaration(); ((ParameterListContext)_localctx).parameters.add(((ParameterListContext)_localctx).parameterDeclaration); setState(371); _errHandler.sync(this); _la = _input.LA(1); while (_la==Comma) { { { setState(367); match(Comma); setState(368); ((ParameterListContext)_localctx).parameterDeclaration = parameterDeclaration(); ((ParameterListContext)_localctx).parameters.add(((ParameterListContext)_localctx).parameterDeclaration); } } setState(373); _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 ParameterDeclarationContext extends ParserRuleContext { public TypeNameContext type; public DataLocationContext location; public IdentifierContext name; public TypeNameContext typeName() { return getRuleContext(TypeNameContext.class,0); } public DataLocationContext dataLocation() { return getRuleContext(DataLocationContext.class,0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public ParameterDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_parameterDeclaration; } } public final ParameterDeclarationContext parameterDeclaration() throws RecognitionException { ParameterDeclarationContext _localctx = new ParameterDeclarationContext(_ctx, getState()); enterRule(_localctx, 36, RULE_parameterDeclaration); int _la; try { enterOuterAlt(_localctx, 1); { setState(374); ((ParameterDeclarationContext)_localctx).type = typeName(0); setState(376); _errHandler.sync(this); _la = _input.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 144119586122368000L) != 0)) { { setState(375); ((ParameterDeclarationContext)_localctx).location = dataLocation(); } } setState(379); _errHandler.sync(this); _la = _input.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 36028799705415680L) != 0) || _la==Identifier) { { setState(378); ((ParameterDeclarationContext)_localctx).name = identifier(); } } } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class ConstructorDefinitionContext extends ParserRuleContext { public boolean payableSet = false; public boolean visibilitySet = false; public ParameterListContext arguments; public BlockContext body; public TerminalNode Constructor() { return getToken(SolidityParser.Constructor, 0); } public TerminalNode LParen() { return getToken(SolidityParser.LParen, 0); } public TerminalNode RParen() { return getToken(SolidityParser.RParen, 0); } public BlockContext block() { return getRuleContext(BlockContext.class,0); } public List modifierInvocation() { return getRuleContexts(ModifierInvocationContext.class); } public ModifierInvocationContext modifierInvocation(int i) { return getRuleContext(ModifierInvocationContext.class,i); } public List Payable() { return getTokens(SolidityParser.Payable); } public TerminalNode Payable(int i) { return getToken(SolidityParser.Payable, i); } public List Internal() { return getTokens(SolidityParser.Internal); } public TerminalNode Internal(int i) { return getToken(SolidityParser.Internal, i); } public List Public() { return getTokens(SolidityParser.Public); } public TerminalNode Public(int i) { return getToken(SolidityParser.Public, i); } public ParameterListContext parameterList() { return getRuleContext(ParameterListContext.class,0); } public ConstructorDefinitionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_constructorDefinition; } } public final ConstructorDefinitionContext constructorDefinition() throws RecognitionException { ConstructorDefinitionContext _localctx = new ConstructorDefinitionContext(_ctx, getState()); enterRule(_localctx, 38, RULE_constructorDefinition); try { int _alt; enterOuterAlt(_localctx, 1); { setState(381); match(Constructor); setState(382); match(LParen); setState(384); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) { case 1: { setState(383); ((ConstructorDefinitionContext)_localctx).arguments = parameterList(); } break; } setState(386); match(RParen); setState(399); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,28,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { setState(397); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) { case 1: { setState(387); modifierInvocation(); } break; case 2: { setState(388); if (!(!_localctx.payableSet)) throw new FailedPredicateException(this, "!$payableSet"); setState(389); match(Payable); ((ConstructorDefinitionContext)_localctx).payableSet = true; } break; case 3: { setState(391); if (!(!_localctx.visibilitySet)) throw new FailedPredicateException(this, "!$visibilitySet"); setState(392); match(Internal); ((ConstructorDefinitionContext)_localctx).visibilitySet = true; } break; case 4: { setState(394); if (!(!_localctx.visibilitySet)) throw new FailedPredicateException(this, "!$visibilitySet"); setState(395); match(Public); ((ConstructorDefinitionContext)_localctx).visibilitySet = true; } break; } } } setState(401); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,28,_ctx); } setState(402); ((ConstructorDefinitionContext)_localctx).body = block(); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class StateMutabilityContext extends ParserRuleContext { public TerminalNode Pure() { return getToken(SolidityParser.Pure, 0); } public TerminalNode View() { return getToken(SolidityParser.View, 0); } public TerminalNode Payable() { return getToken(SolidityParser.Payable, 0); } public StateMutabilityContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_stateMutability; } } public final StateMutabilityContext stateMutability() throws RecognitionException { StateMutabilityContext _localctx = new StateMutabilityContext(_ctx, getState()); enterRule(_localctx, 40, RULE_stateMutability); int _la; try { enterOuterAlt(_localctx, 1); { setState(404); _la = _input.LA(1); if ( !(((((_la - 47)) & ~0x3f) == 0 && ((1L << (_la - 47)) & 2097169L) != 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 OverrideSpecifierContext extends ParserRuleContext { public IdentifierPathContext identifierPath; public List overrides = new ArrayList(); public TerminalNode Override() { return getToken(SolidityParser.Override, 0); } public TerminalNode LParen() { return getToken(SolidityParser.LParen, 0); } public TerminalNode RParen() { return getToken(SolidityParser.RParen, 0); } public List identifierPath() { return getRuleContexts(IdentifierPathContext.class); } public IdentifierPathContext identifierPath(int i) { return getRuleContext(IdentifierPathContext.class,i); } public List Comma() { return getTokens(SolidityParser.Comma); } public TerminalNode Comma(int i) { return getToken(SolidityParser.Comma, i); } public OverrideSpecifierContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_overrideSpecifier; } } public final OverrideSpecifierContext overrideSpecifier() throws RecognitionException { OverrideSpecifierContext _localctx = new OverrideSpecifierContext(_ctx, getState()); enterRule(_localctx, 42, RULE_overrideSpecifier); int _la; try { enterOuterAlt(_localctx, 1); { setState(406); match(Override); setState(418); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) { case 1: { setState(407); match(LParen); setState(408); ((OverrideSpecifierContext)_localctx).identifierPath = identifierPath(); ((OverrideSpecifierContext)_localctx).overrides.add(((OverrideSpecifierContext)_localctx).identifierPath); setState(413); _errHandler.sync(this); _la = _input.LA(1); while (_la==Comma) { { { setState(409); match(Comma); setState(410); ((OverrideSpecifierContext)_localctx).identifierPath = identifierPath(); ((OverrideSpecifierContext)_localctx).overrides.add(((OverrideSpecifierContext)_localctx).identifierPath); } } setState(415); _errHandler.sync(this); _la = _input.LA(1); } setState(416); 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 FunctionDefinitionContext extends ParserRuleContext { public boolean visibilitySet = false; public boolean mutabilitySet = false; public boolean virtualSet = false; public boolean overrideSpecifierSet = false; public ParameterListContext arguments; public ParameterListContext returnParameters; public BlockContext body; public TerminalNode Function() { return getToken(SolidityParser.Function, 0); } public List LParen() { return getTokens(SolidityParser.LParen); } public TerminalNode LParen(int i) { return getToken(SolidityParser.LParen, i); } public List RParen() { return getTokens(SolidityParser.RParen); } public TerminalNode RParen(int i) { return getToken(SolidityParser.RParen, i); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public TerminalNode Fallback() { return getToken(SolidityParser.Fallback, 0); } public TerminalNode Receive() { return getToken(SolidityParser.Receive, 0); } public TerminalNode Semicolon() { return getToken(SolidityParser.Semicolon, 0); } public List visibility() { return getRuleContexts(VisibilityContext.class); } public VisibilityContext visibility(int i) { return getRuleContext(VisibilityContext.class,i); } public List stateMutability() { return getRuleContexts(StateMutabilityContext.class); } public StateMutabilityContext stateMutability(int i) { return getRuleContext(StateMutabilityContext.class,i); } public List modifierInvocation() { return getRuleContexts(ModifierInvocationContext.class); } public ModifierInvocationContext modifierInvocation(int i) { return getRuleContext(ModifierInvocationContext.class,i); } public List Virtual() { return getTokens(SolidityParser.Virtual); } public TerminalNode Virtual(int i) { return getToken(SolidityParser.Virtual, i); } public List overrideSpecifier() { return getRuleContexts(OverrideSpecifierContext.class); } public OverrideSpecifierContext overrideSpecifier(int i) { return getRuleContext(OverrideSpecifierContext.class,i); } public TerminalNode Returns() { return getToken(SolidityParser.Returns, 0); } public BlockContext block() { return getRuleContext(BlockContext.class,0); } public List parameterList() { return getRuleContexts(ParameterListContext.class); } public ParameterListContext parameterList(int i) { return getRuleContext(ParameterListContext.class,i); } public FunctionDefinitionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_functionDefinition; } } public final FunctionDefinitionContext functionDefinition() throws RecognitionException { FunctionDefinitionContext _localctx = new FunctionDefinitionContext(_ctx, getState()); enterRule(_localctx, 44, RULE_functionDefinition); int _la; try { int _alt; enterOuterAlt(_localctx, 1); { setState(420); match(Function); setState(424); _errHandler.sync(this); switch (_input.LA(1)) { case Error: case From: case Global: case Revert: case Identifier: { setState(421); identifier(); } break; case Fallback: { setState(422); match(Fallback); } break; case Receive: { setState(423); match(Receive); } break; default: throw new NoViableAltException(this); } setState(426); match(LParen); setState(428); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,32,_ctx) ) { case 1: { setState(427); ((FunctionDefinitionContext)_localctx).arguments = parameterList(); } break; } setState(430); match(RParen); setState(449); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,34,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { setState(447); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) { case 1: { setState(431); if (!(!_localctx.visibilitySet)) throw new FailedPredicateException(this, "!$visibilitySet"); setState(432); visibility(); ((FunctionDefinitionContext)_localctx).visibilitySet = true; } break; case 2: { setState(435); if (!(!_localctx.mutabilitySet)) throw new FailedPredicateException(this, "!$mutabilitySet"); setState(436); stateMutability(); ((FunctionDefinitionContext)_localctx).mutabilitySet = true; } break; case 3: { setState(439); modifierInvocation(); } break; case 4: { setState(440); if (!(!_localctx.virtualSet)) throw new FailedPredicateException(this, "!$virtualSet"); setState(441); match(Virtual); ((FunctionDefinitionContext)_localctx).virtualSet = true; } break; case 5: { setState(443); if (!(!_localctx.overrideSpecifierSet)) throw new FailedPredicateException(this, "!$overrideSpecifierSet"); setState(444); overrideSpecifier(); ((FunctionDefinitionContext)_localctx).overrideSpecifierSet = true; } break; } } } setState(451); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,34,_ctx); } setState(457); _errHandler.sync(this); _la = _input.LA(1); if (_la==Returns) { { setState(452); match(Returns); setState(453); match(LParen); setState(454); ((FunctionDefinitionContext)_localctx).returnParameters = parameterList(); setState(455); match(RParen); } } setState(461); _errHandler.sync(this); switch (_input.LA(1)) { case Semicolon: { setState(459); match(Semicolon); } break; case LBrace: { setState(460); ((FunctionDefinitionContext)_localctx).body = block(); } break; default: throw new NoViableAltException(this); } } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class ModifierDefinitionContext extends ParserRuleContext { public boolean virtualSet = false; public boolean overrideSpecifierSet = false; public IdentifierContext name; public ParameterListContext arguments; public BlockContext body; public TerminalNode Modifier() { return getToken(SolidityParser.Modifier, 0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public TerminalNode Semicolon() { return getToken(SolidityParser.Semicolon, 0); } public TerminalNode LParen() { return getToken(SolidityParser.LParen, 0); } public TerminalNode RParen() { return getToken(SolidityParser.RParen, 0); } public List Virtual() { return getTokens(SolidityParser.Virtual); } public TerminalNode Virtual(int i) { return getToken(SolidityParser.Virtual, i); } public List overrideSpecifier() { return getRuleContexts(OverrideSpecifierContext.class); } public OverrideSpecifierContext overrideSpecifier(int i) { return getRuleContext(OverrideSpecifierContext.class,i); } public BlockContext block() { return getRuleContext(BlockContext.class,0); } public ParameterListContext parameterList() { return getRuleContext(ParameterListContext.class,0); } public ModifierDefinitionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_modifierDefinition; } } public final ModifierDefinitionContext modifierDefinition() throws RecognitionException { ModifierDefinitionContext _localctx = new ModifierDefinitionContext(_ctx, getState()); enterRule(_localctx, 46, RULE_modifierDefinition); try { int _alt; enterOuterAlt(_localctx, 1); { setState(463); match(Modifier); setState(464); ((ModifierDefinitionContext)_localctx).name = identifier(); setState(470); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,38,_ctx) ) { case 1: { setState(465); match(LParen); setState(467); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) { case 1: { setState(466); ((ModifierDefinitionContext)_localctx).arguments = parameterList(); } break; } setState(469); match(RParen); } break; } setState(481); _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(479); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,39,_ctx) ) { case 1: { setState(472); if (!(!_localctx.virtualSet)) throw new FailedPredicateException(this, "!$virtualSet"); setState(473); match(Virtual); ((ModifierDefinitionContext)_localctx).virtualSet = true; } break; case 2: { setState(475); if (!(!_localctx.overrideSpecifierSet)) throw new FailedPredicateException(this, "!$overrideSpecifierSet"); setState(476); overrideSpecifier(); ((ModifierDefinitionContext)_localctx).overrideSpecifierSet = true; } break; } } } setState(483); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,40,_ctx); } setState(486); _errHandler.sync(this); switch (_input.LA(1)) { case Semicolon: { setState(484); match(Semicolon); } break; case LBrace: { setState(485); ((ModifierDefinitionContext)_localctx).body = block(); } break; default: throw new NoViableAltException(this); } } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class FallbackFunctionDefinitionContext extends ParserRuleContext { public boolean visibilitySet = false; public boolean mutabilitySet = false; public boolean virtualSet = false; public boolean overrideSpecifierSet = false; public boolean hasParameters = false; public Token kind; public ParameterListContext returnParameters; public BlockContext body; public List LParen() { return getTokens(SolidityParser.LParen); } public TerminalNode LParen(int i) { return getToken(SolidityParser.LParen, i); } public List RParen() { return getTokens(SolidityParser.RParen); } public TerminalNode RParen(int i) { return getToken(SolidityParser.RParen, i); } public TerminalNode Fallback() { return getToken(SolidityParser.Fallback, 0); } public TerminalNode Returns() { return getToken(SolidityParser.Returns, 0); } public TerminalNode Semicolon() { return getToken(SolidityParser.Semicolon, 0); } public List parameterList() { return getRuleContexts(ParameterListContext.class); } public ParameterListContext parameterList(int i) { return getRuleContext(ParameterListContext.class,i); } public List External() { return getTokens(SolidityParser.External); } public TerminalNode External(int i) { return getToken(SolidityParser.External, i); } public List stateMutability() { return getRuleContexts(StateMutabilityContext.class); } public StateMutabilityContext stateMutability(int i) { return getRuleContext(StateMutabilityContext.class,i); } public List modifierInvocation() { return getRuleContexts(ModifierInvocationContext.class); } public ModifierInvocationContext modifierInvocation(int i) { return getRuleContext(ModifierInvocationContext.class,i); } public List Virtual() { return getTokens(SolidityParser.Virtual); } public TerminalNode Virtual(int i) { return getToken(SolidityParser.Virtual, i); } public List overrideSpecifier() { return getRuleContexts(OverrideSpecifierContext.class); } public OverrideSpecifierContext overrideSpecifier(int i) { return getRuleContext(OverrideSpecifierContext.class,i); } public BlockContext block() { return getRuleContext(BlockContext.class,0); } public FallbackFunctionDefinitionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_fallbackFunctionDefinition; } } public final FallbackFunctionDefinitionContext fallbackFunctionDefinition() throws RecognitionException { FallbackFunctionDefinitionContext _localctx = new FallbackFunctionDefinitionContext(_ctx, getState()); enterRule(_localctx, 48, RULE_fallbackFunctionDefinition); try { int _alt; enterOuterAlt(_localctx, 1); { setState(488); ((FallbackFunctionDefinitionContext)_localctx).kind = match(Fallback); setState(489); match(LParen); setState(493); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) { case 1: { setState(490); parameterList(); ((FallbackFunctionDefinitionContext)_localctx).hasParameters = true; } break; } setState(495); match(RParen); setState(513); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,44,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { setState(511); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,43,_ctx) ) { case 1: { setState(496); if (!(!_localctx.visibilitySet)) throw new FailedPredicateException(this, "!$visibilitySet"); setState(497); match(External); ((FallbackFunctionDefinitionContext)_localctx).visibilitySet = true; } break; case 2: { setState(499); if (!(!_localctx.mutabilitySet)) throw new FailedPredicateException(this, "!$mutabilitySet"); setState(500); stateMutability(); ((FallbackFunctionDefinitionContext)_localctx).mutabilitySet = true; } break; case 3: { setState(503); modifierInvocation(); } break; case 4: { setState(504); if (!(!_localctx.virtualSet)) throw new FailedPredicateException(this, "!$virtualSet"); setState(505); match(Virtual); ((FallbackFunctionDefinitionContext)_localctx).virtualSet = true; } break; case 5: { setState(507); if (!(!_localctx.overrideSpecifierSet)) throw new FailedPredicateException(this, "!$overrideSpecifierSet"); setState(508); overrideSpecifier(); ((FallbackFunctionDefinitionContext)_localctx).overrideSpecifierSet = true; } break; } } } setState(515); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,44,_ctx); } setState(523); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) { case 1: { setState(516); if (!(_localctx.hasParameters)) throw new FailedPredicateException(this, "$hasParameters"); setState(517); match(Returns); setState(518); match(LParen); setState(519); ((FallbackFunctionDefinitionContext)_localctx).returnParameters = parameterList(); setState(520); match(RParen); } break; case 2: { setState(522); if (!(!_localctx.hasParameters)) throw new FailedPredicateException(this, "!$hasParameters"); } break; } setState(527); _errHandler.sync(this); switch (_input.LA(1)) { case Semicolon: { setState(525); match(Semicolon); } break; case LBrace: { setState(526); ((FallbackFunctionDefinitionContext)_localctx).body = block(); } break; default: throw new NoViableAltException(this); } } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class ReceiveFunctionDefinitionContext extends ParserRuleContext { public boolean visibilitySet = false; public boolean mutabilitySet = false; public boolean virtualSet = false; public boolean overrideSpecifierSet = false; public Token kind; public BlockContext body; public TerminalNode LParen() { return getToken(SolidityParser.LParen, 0); } public TerminalNode RParen() { return getToken(SolidityParser.RParen, 0); } public TerminalNode Receive() { return getToken(SolidityParser.Receive, 0); } public TerminalNode Semicolon() { return getToken(SolidityParser.Semicolon, 0); } public List External() { return getTokens(SolidityParser.External); } public TerminalNode External(int i) { return getToken(SolidityParser.External, i); } public List Payable() { return getTokens(SolidityParser.Payable); } public TerminalNode Payable(int i) { return getToken(SolidityParser.Payable, i); } public List modifierInvocation() { return getRuleContexts(ModifierInvocationContext.class); } public ModifierInvocationContext modifierInvocation(int i) { return getRuleContext(ModifierInvocationContext.class,i); } public List Virtual() { return getTokens(SolidityParser.Virtual); } public TerminalNode Virtual(int i) { return getToken(SolidityParser.Virtual, i); } public List overrideSpecifier() { return getRuleContexts(OverrideSpecifierContext.class); } public OverrideSpecifierContext overrideSpecifier(int i) { return getRuleContext(OverrideSpecifierContext.class,i); } public BlockContext block() { return getRuleContext(BlockContext.class,0); } public ReceiveFunctionDefinitionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_receiveFunctionDefinition; } } public final ReceiveFunctionDefinitionContext receiveFunctionDefinition() throws RecognitionException { ReceiveFunctionDefinitionContext _localctx = new ReceiveFunctionDefinitionContext(_ctx, getState()); enterRule(_localctx, 50, RULE_receiveFunctionDefinition); try { int _alt; enterOuterAlt(_localctx, 1); { setState(529); ((ReceiveFunctionDefinitionContext)_localctx).kind = match(Receive); setState(530); match(LParen); setState(531); match(RParen); setState(548); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,48,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { setState(546); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,47,_ctx) ) { case 1: { setState(532); if (!(!_localctx.visibilitySet)) throw new FailedPredicateException(this, "!$visibilitySet"); setState(533); match(External); ((ReceiveFunctionDefinitionContext)_localctx).visibilitySet = true; } break; case 2: { setState(535); if (!(!_localctx.mutabilitySet)) throw new FailedPredicateException(this, "!$mutabilitySet"); setState(536); match(Payable); ((ReceiveFunctionDefinitionContext)_localctx).mutabilitySet = true; } break; case 3: { setState(538); modifierInvocation(); } break; case 4: { setState(539); if (!(!_localctx.virtualSet)) throw new FailedPredicateException(this, "!$virtualSet"); setState(540); match(Virtual); ((ReceiveFunctionDefinitionContext)_localctx).virtualSet = true; } break; case 5: { setState(542); if (!(!_localctx.overrideSpecifierSet)) throw new FailedPredicateException(this, "!$overrideSpecifierSet"); setState(543); overrideSpecifier(); ((ReceiveFunctionDefinitionContext)_localctx).overrideSpecifierSet = true; } break; } } } setState(550); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,48,_ctx); } setState(553); _errHandler.sync(this); switch (_input.LA(1)) { case Semicolon: { setState(551); match(Semicolon); } break; case LBrace: { setState(552); ((ReceiveFunctionDefinitionContext)_localctx).body = block(); } break; default: throw new NoViableAltException(this); } } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class StructDefinitionContext extends ParserRuleContext { public IdentifierContext name; public StructMemberContext members; public TerminalNode Struct() { return getToken(SolidityParser.Struct, 0); } public TerminalNode LBrace() { return getToken(SolidityParser.LBrace, 0); } public TerminalNode RBrace() { return getToken(SolidityParser.RBrace, 0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public List structMember() { return getRuleContexts(StructMemberContext.class); } public StructMemberContext structMember(int i) { return getRuleContext(StructMemberContext.class,i); } public StructDefinitionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_structDefinition; } } public final StructDefinitionContext structDefinition() throws RecognitionException { StructDefinitionContext _localctx = new StructDefinitionContext(_ctx, getState()); enterRule(_localctx, 52, RULE_structDefinition); try { int _alt; enterOuterAlt(_localctx, 1); { setState(555); match(Struct); setState(556); ((StructDefinitionContext)_localctx).name = identifier(); setState(557); match(LBrace); setState(559); _errHandler.sync(this); _alt = 1; do { switch (_alt) { case 1: { { setState(558); ((StructDefinitionContext)_localctx).members = structMember(); } } break; default: throw new NoViableAltException(this); } setState(561); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,50,_ctx); } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); setState(563); match(RBrace); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class StructMemberContext extends ParserRuleContext { public TypeNameContext type; public IdentifierContext name; public TerminalNode Semicolon() { return getToken(SolidityParser.Semicolon, 0); } public TypeNameContext typeName() { return getRuleContext(TypeNameContext.class,0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public StructMemberContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_structMember; } } public final StructMemberContext structMember() throws RecognitionException { StructMemberContext _localctx = new StructMemberContext(_ctx, getState()); enterRule(_localctx, 54, RULE_structMember); try { enterOuterAlt(_localctx, 1); { setState(565); ((StructMemberContext)_localctx).type = typeName(0); setState(566); ((StructMemberContext)_localctx).name = identifier(); setState(567); 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 EnumDefinitionContext extends ParserRuleContext { public IdentifierContext name; public IdentifierContext identifier; public List enumValues = new ArrayList(); public TerminalNode Enum() { return getToken(SolidityParser.Enum, 0); } public TerminalNode LBrace() { return getToken(SolidityParser.LBrace, 0); } public TerminalNode RBrace() { return getToken(SolidityParser.RBrace, 0); } public List identifier() { return getRuleContexts(IdentifierContext.class); } public IdentifierContext identifier(int i) { return getRuleContext(IdentifierContext.class,i); } public List Comma() { return getTokens(SolidityParser.Comma); } public TerminalNode Comma(int i) { return getToken(SolidityParser.Comma, i); } public EnumDefinitionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_enumDefinition; } } public final EnumDefinitionContext enumDefinition() throws RecognitionException { EnumDefinitionContext _localctx = new EnumDefinitionContext(_ctx, getState()); enterRule(_localctx, 56, RULE_enumDefinition); int _la; try { enterOuterAlt(_localctx, 1); { setState(569); match(Enum); setState(570); ((EnumDefinitionContext)_localctx).name = identifier(); setState(571); match(LBrace); setState(572); ((EnumDefinitionContext)_localctx).identifier = identifier(); ((EnumDefinitionContext)_localctx).enumValues.add(((EnumDefinitionContext)_localctx).identifier); setState(577); _errHandler.sync(this); _la = _input.LA(1); while (_la==Comma) { { { setState(573); match(Comma); setState(574); ((EnumDefinitionContext)_localctx).identifier = identifier(); ((EnumDefinitionContext)_localctx).enumValues.add(((EnumDefinitionContext)_localctx).identifier); } } setState(579); _errHandler.sync(this); _la = _input.LA(1); } setState(580); match(RBrace); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class UserDefinedValueTypeDefinitionContext extends ParserRuleContext { public IdentifierContext name; public TerminalNode Type() { return getToken(SolidityParser.Type, 0); } public TerminalNode Is() { return getToken(SolidityParser.Is, 0); } public ElementaryTypeNameContext elementaryTypeName() { return getRuleContext(ElementaryTypeNameContext.class,0); } public TerminalNode Semicolon() { return getToken(SolidityParser.Semicolon, 0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public UserDefinedValueTypeDefinitionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_userDefinedValueTypeDefinition; } } public final UserDefinedValueTypeDefinitionContext userDefinedValueTypeDefinition() throws RecognitionException { UserDefinedValueTypeDefinitionContext _localctx = new UserDefinedValueTypeDefinitionContext(_ctx, getState()); enterRule(_localctx, 58, RULE_userDefinedValueTypeDefinition); try { enterOuterAlt(_localctx, 1); { setState(582); match(Type); setState(583); ((UserDefinedValueTypeDefinitionContext)_localctx).name = identifier(); setState(584); match(Is); setState(585); elementaryTypeName(true); setState(586); 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 StateVariableDeclarationContext extends ParserRuleContext { public boolean constantnessSet = false; public boolean visibilitySet = false; public boolean overrideSpecifierSet = false; public TypeNameContext type; public IdentifierContext name; public ExpressionContext initialValue; public TerminalNode Semicolon() { return getToken(SolidityParser.Semicolon, 0); } public TypeNameContext typeName() { return getRuleContext(TypeNameContext.class,0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public List Public() { return getTokens(SolidityParser.Public); } public TerminalNode Public(int i) { return getToken(SolidityParser.Public, i); } public List Private() { return getTokens(SolidityParser.Private); } public TerminalNode Private(int i) { return getToken(SolidityParser.Private, i); } public List Internal() { return getTokens(SolidityParser.Internal); } public TerminalNode Internal(int i) { return getToken(SolidityParser.Internal, i); } public List Constant() { return getTokens(SolidityParser.Constant); } public TerminalNode Constant(int i) { return getToken(SolidityParser.Constant, i); } public List overrideSpecifier() { return getRuleContexts(OverrideSpecifierContext.class); } public OverrideSpecifierContext overrideSpecifier(int i) { return getRuleContext(OverrideSpecifierContext.class,i); } public List Immutable() { return getTokens(SolidityParser.Immutable); } public TerminalNode Immutable(int i) { return getToken(SolidityParser.Immutable, i); } public TerminalNode Assign() { return getToken(SolidityParser.Assign, 0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } public StateVariableDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_stateVariableDeclaration; } } public final StateVariableDeclarationContext stateVariableDeclaration() throws RecognitionException { StateVariableDeclarationContext _localctx = new StateVariableDeclarationContext(_ctx, getState()); enterRule(_localctx, 60, RULE_stateVariableDeclaration); int _la; try { int _alt; enterOuterAlt(_localctx, 1); { setState(588); ((StateVariableDeclarationContext)_localctx).type = typeName(0); setState(610); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,53,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { setState(608); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,52,_ctx) ) { case 1: { setState(589); if (!(!_localctx.visibilitySet)) throw new FailedPredicateException(this, "!$visibilitySet"); setState(590); match(Public); ((StateVariableDeclarationContext)_localctx).visibilitySet = true; } break; case 2: { setState(592); if (!(!_localctx.visibilitySet)) throw new FailedPredicateException(this, "!$visibilitySet"); setState(593); match(Private); ((StateVariableDeclarationContext)_localctx).visibilitySet = true; } break; case 3: { setState(595); if (!(!_localctx.visibilitySet)) throw new FailedPredicateException(this, "!$visibilitySet"); setState(596); match(Internal); ((StateVariableDeclarationContext)_localctx).visibilitySet = true; } break; case 4: { setState(598); if (!(!_localctx.constantnessSet)) throw new FailedPredicateException(this, "!$constantnessSet"); setState(599); match(Constant); ((StateVariableDeclarationContext)_localctx).constantnessSet = true; } break; case 5: { setState(601); if (!(!_localctx.overrideSpecifierSet)) throw new FailedPredicateException(this, "!$overrideSpecifierSet"); setState(602); overrideSpecifier(); ((StateVariableDeclarationContext)_localctx).overrideSpecifierSet = true; } break; case 6: { setState(605); if (!(!_localctx.constantnessSet)) throw new FailedPredicateException(this, "!$constantnessSet"); setState(606); match(Immutable); ((StateVariableDeclarationContext)_localctx).constantnessSet = true; } break; } } } setState(612); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,53,_ctx); } setState(613); ((StateVariableDeclarationContext)_localctx).name = identifier(); setState(616); _errHandler.sync(this); _la = _input.LA(1); if (_la==Assign) { { setState(614); match(Assign); setState(615); ((StateVariableDeclarationContext)_localctx).initialValue = expression(0); } } setState(618); 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 ConstantVariableDeclarationContext extends ParserRuleContext { public TypeNameContext type; public IdentifierContext name; public ExpressionContext initialValue; public TerminalNode Constant() { return getToken(SolidityParser.Constant, 0); } public TerminalNode Assign() { return getToken(SolidityParser.Assign, 0); } public TerminalNode Semicolon() { return getToken(SolidityParser.Semicolon, 0); } public TypeNameContext typeName() { return getRuleContext(TypeNameContext.class,0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } public ConstantVariableDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_constantVariableDeclaration; } } public final ConstantVariableDeclarationContext constantVariableDeclaration() throws RecognitionException { ConstantVariableDeclarationContext _localctx = new ConstantVariableDeclarationContext(_ctx, getState()); enterRule(_localctx, 62, RULE_constantVariableDeclaration); try { enterOuterAlt(_localctx, 1); { setState(620); ((ConstantVariableDeclarationContext)_localctx).type = typeName(0); setState(621); match(Constant); setState(622); ((ConstantVariableDeclarationContext)_localctx).name = identifier(); setState(623); match(Assign); setState(624); ((ConstantVariableDeclarationContext)_localctx).initialValue = expression(0); setState(625); 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 EventParameterContext extends ParserRuleContext { public TypeNameContext type; public IdentifierContext name; public TypeNameContext typeName() { return getRuleContext(TypeNameContext.class,0); } public TerminalNode Indexed() { return getToken(SolidityParser.Indexed, 0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public EventParameterContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_eventParameter; } } public final EventParameterContext eventParameter() throws RecognitionException { EventParameterContext _localctx = new EventParameterContext(_ctx, getState()); enterRule(_localctx, 64, RULE_eventParameter); int _la; try { enterOuterAlt(_localctx, 1); { setState(627); ((EventParameterContext)_localctx).type = typeName(0); setState(629); _errHandler.sync(this); _la = _input.LA(1); if (_la==Indexed) { { setState(628); match(Indexed); } } setState(632); _errHandler.sync(this); _la = _input.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 36028799705415680L) != 0) || _la==Identifier) { { setState(631); ((EventParameterContext)_localctx).name = identifier(); } } } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class EventDefinitionContext extends ParserRuleContext { public IdentifierContext name; public EventParameterContext eventParameter; public List parameters = new ArrayList(); public TerminalNode Event() { return getToken(SolidityParser.Event, 0); } public TerminalNode LParen() { return getToken(SolidityParser.LParen, 0); } public TerminalNode RParen() { return getToken(SolidityParser.RParen, 0); } public TerminalNode Semicolon() { return getToken(SolidityParser.Semicolon, 0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public TerminalNode Anonymous() { return getToken(SolidityParser.Anonymous, 0); } public List eventParameter() { return getRuleContexts(EventParameterContext.class); } public EventParameterContext eventParameter(int i) { return getRuleContext(EventParameterContext.class,i); } public List Comma() { return getTokens(SolidityParser.Comma); } public TerminalNode Comma(int i) { return getToken(SolidityParser.Comma, i); } public EventDefinitionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_eventDefinition; } } public final EventDefinitionContext eventDefinition() throws RecognitionException { EventDefinitionContext _localctx = new EventDefinitionContext(_ctx, getState()); enterRule(_localctx, 66, RULE_eventDefinition); int _la; try { enterOuterAlt(_localctx, 1); { setState(634); match(Event); setState(635); ((EventDefinitionContext)_localctx).name = identifier(); setState(636); match(LParen); setState(645); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,58,_ctx) ) { case 1: { setState(637); ((EventDefinitionContext)_localctx).eventParameter = eventParameter(); ((EventDefinitionContext)_localctx).parameters.add(((EventDefinitionContext)_localctx).eventParameter); setState(642); _errHandler.sync(this); _la = _input.LA(1); while (_la==Comma) { { { setState(638); match(Comma); setState(639); ((EventDefinitionContext)_localctx).eventParameter = eventParameter(); ((EventDefinitionContext)_localctx).parameters.add(((EventDefinitionContext)_localctx).eventParameter); } } setState(644); _errHandler.sync(this); _la = _input.LA(1); } } break; } setState(647); match(RParen); setState(649); _errHandler.sync(this); _la = _input.LA(1); if (_la==Anonymous) { { setState(648); match(Anonymous); } } setState(651); 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 ErrorParameterContext extends ParserRuleContext { public TypeNameContext type; public IdentifierContext name; public TypeNameContext typeName() { return getRuleContext(TypeNameContext.class,0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public ErrorParameterContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_errorParameter; } } public final ErrorParameterContext errorParameter() throws RecognitionException { ErrorParameterContext _localctx = new ErrorParameterContext(_ctx, getState()); enterRule(_localctx, 68, RULE_errorParameter); int _la; try { enterOuterAlt(_localctx, 1); { setState(653); ((ErrorParameterContext)_localctx).type = typeName(0); setState(655); _errHandler.sync(this); _la = _input.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 36028799705415680L) != 0) || _la==Identifier) { { setState(654); ((ErrorParameterContext)_localctx).name = identifier(); } } } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class ErrorDefinitionContext extends ParserRuleContext { public IdentifierContext name; public ErrorParameterContext errorParameter; public List parameters = new ArrayList(); public TerminalNode Error() { return getToken(SolidityParser.Error, 0); } public TerminalNode LParen() { return getToken(SolidityParser.LParen, 0); } public TerminalNode RParen() { return getToken(SolidityParser.RParen, 0); } public TerminalNode Semicolon() { return getToken(SolidityParser.Semicolon, 0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public List errorParameter() { return getRuleContexts(ErrorParameterContext.class); } public ErrorParameterContext errorParameter(int i) { return getRuleContext(ErrorParameterContext.class,i); } public List Comma() { return getTokens(SolidityParser.Comma); } public TerminalNode Comma(int i) { return getToken(SolidityParser.Comma, i); } public ErrorDefinitionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_errorDefinition; } } public final ErrorDefinitionContext errorDefinition() throws RecognitionException { ErrorDefinitionContext _localctx = new ErrorDefinitionContext(_ctx, getState()); enterRule(_localctx, 70, RULE_errorDefinition); int _la; try { enterOuterAlt(_localctx, 1); { setState(657); match(Error); setState(658); ((ErrorDefinitionContext)_localctx).name = identifier(); setState(659); match(LParen); setState(668); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) { case 1: { setState(660); ((ErrorDefinitionContext)_localctx).errorParameter = errorParameter(); ((ErrorDefinitionContext)_localctx).parameters.add(((ErrorDefinitionContext)_localctx).errorParameter); setState(665); _errHandler.sync(this); _la = _input.LA(1); while (_la==Comma) { { { setState(661); match(Comma); setState(662); ((ErrorDefinitionContext)_localctx).errorParameter = errorParameter(); ((ErrorDefinitionContext)_localctx).parameters.add(((ErrorDefinitionContext)_localctx).errorParameter); } } setState(667); _errHandler.sync(this); _la = _input.LA(1); } } break; } setState(670); match(RParen); setState(671); 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 UserDefinableOperatorContext extends ParserRuleContext { public TerminalNode BitAnd() { return getToken(SolidityParser.BitAnd, 0); } public TerminalNode BitNot() { return getToken(SolidityParser.BitNot, 0); } public TerminalNode BitOr() { return getToken(SolidityParser.BitOr, 0); } public TerminalNode BitXor() { return getToken(SolidityParser.BitXor, 0); } public TerminalNode Add() { return getToken(SolidityParser.Add, 0); } public TerminalNode Div() { return getToken(SolidityParser.Div, 0); } public TerminalNode Mod() { return getToken(SolidityParser.Mod, 0); } public TerminalNode Mul() { return getToken(SolidityParser.Mul, 0); } public TerminalNode Sub() { return getToken(SolidityParser.Sub, 0); } public TerminalNode Equal() { return getToken(SolidityParser.Equal, 0); } public TerminalNode GreaterThan() { return getToken(SolidityParser.GreaterThan, 0); } public TerminalNode GreaterThanOrEqual() { return getToken(SolidityParser.GreaterThanOrEqual, 0); } public TerminalNode LessThan() { return getToken(SolidityParser.LessThan, 0); } public TerminalNode LessThanOrEqual() { return getToken(SolidityParser.LessThanOrEqual, 0); } public TerminalNode NotEqual() { return getToken(SolidityParser.NotEqual, 0); } public UserDefinableOperatorContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_userDefinableOperator; } } public final UserDefinableOperatorContext userDefinableOperator() throws RecognitionException { UserDefinableOperatorContext _localctx = new UserDefinableOperatorContext(_ctx, getState()); enterRule(_localctx, 72, RULE_userDefinableOperator); int _la; try { enterOuterAlt(_localctx, 1); { setState(673); _la = _input.LA(1); if ( !(((((_la - 98)) & ~0x3f) == 0 && ((1L << (_la - 98)) & 784327L) != 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 UsingDirectiveContext extends ParserRuleContext { public TerminalNode Using() { return getToken(SolidityParser.Using, 0); } public TerminalNode For() { return getToken(SolidityParser.For, 0); } public TerminalNode Semicolon() { return getToken(SolidityParser.Semicolon, 0); } public IdentifierPathContext identifierPath() { return getRuleContext(IdentifierPathContext.class,0); } public TerminalNode Mul() { return getToken(SolidityParser.Mul, 0); } public TypeNameContext typeName() { return getRuleContext(TypeNameContext.class,0); } public TerminalNode Global() { return getToken(SolidityParser.Global, 0); } public TerminalNode LBrace() { return getToken(SolidityParser.LBrace, 0); } public List usingAliases() { return getRuleContexts(UsingAliasesContext.class); } public UsingAliasesContext usingAliases(int i) { return getRuleContext(UsingAliasesContext.class,i); } public TerminalNode RBrace() { return getToken(SolidityParser.RBrace, 0); } public List Comma() { return getTokens(SolidityParser.Comma); } public TerminalNode Comma(int i) { return getToken(SolidityParser.Comma, i); } public UsingDirectiveContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_usingDirective; } } public final UsingDirectiveContext usingDirective() throws RecognitionException { UsingDirectiveContext _localctx = new UsingDirectiveContext(_ctx, getState()); enterRule(_localctx, 74, RULE_usingDirective); int _la; try { enterOuterAlt(_localctx, 1); { setState(675); match(Using); setState(688); _errHandler.sync(this); switch (_input.LA(1)) { case Error: case From: case Global: case Revert: case Identifier: { setState(676); identifierPath(); } break; case LBrace: { { setState(677); match(LBrace); setState(678); usingAliases(); setState(683); _errHandler.sync(this); _la = _input.LA(1); while (_la==Comma) { { { setState(679); match(Comma); setState(680); usingAliases(); } } setState(685); _errHandler.sync(this); _la = _input.LA(1); } setState(686); match(RBrace); } } break; default: throw new NoViableAltException(this); } setState(690); match(For); setState(693); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) { case 1: { setState(691); match(Mul); } break; case 2: { setState(692); typeName(0); } break; } setState(696); _errHandler.sync(this); _la = _input.LA(1); if (_la==Global) { { setState(695); match(Global); } } setState(698); 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 UsingAliasesContext extends ParserRuleContext { public IdentifierPathContext identifierPath() { return getRuleContext(IdentifierPathContext.class,0); } public TerminalNode As() { return getToken(SolidityParser.As, 0); } public UserDefinableOperatorContext userDefinableOperator() { return getRuleContext(UserDefinableOperatorContext.class,0); } public UsingAliasesContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_usingAliases; } } public final UsingAliasesContext usingAliases() throws RecognitionException { UsingAliasesContext _localctx = new UsingAliasesContext(_ctx, getState()); enterRule(_localctx, 76, RULE_usingAliases); int _la; try { enterOuterAlt(_localctx, 1); { setState(700); identifierPath(); setState(703); _errHandler.sync(this); _la = _input.LA(1); if (_la==As) { { setState(701); match(As); setState(702); userDefinableOperator(); } } } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class TypeNameContext extends ParserRuleContext { public ElementaryTypeNameContext elementaryTypeName() { return getRuleContext(ElementaryTypeNameContext.class,0); } public FunctionTypeNameContext functionTypeName() { return getRuleContext(FunctionTypeNameContext.class,0); } public MappingTypeContext mappingType() { return getRuleContext(MappingTypeContext.class,0); } public IdentifierPathContext identifierPath() { return getRuleContext(IdentifierPathContext.class,0); } public TypeNameContext typeName() { return getRuleContext(TypeNameContext.class,0); } public TerminalNode LBrack() { return getToken(SolidityParser.LBrack, 0); } public TerminalNode RBrack() { return getToken(SolidityParser.RBrack, 0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } public TypeNameContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_typeName; } } public final TypeNameContext typeName() throws RecognitionException { return typeName(0); } private TypeNameContext typeName(int _p) throws RecognitionException { ParserRuleContext _parentctx = _ctx; int _parentState = getState(); TypeNameContext _localctx = new TypeNameContext(_ctx, _parentState); TypeNameContext _prevctx = _localctx; int _startState = 78; enterRecursionRule(_localctx, 78, RULE_typeName, _p); try { int _alt; enterOuterAlt(_localctx, 1); { setState(710); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,68,_ctx) ) { case 1: { setState(706); elementaryTypeName(true); } break; case 2: { setState(707); functionTypeName(); } break; case 3: { setState(708); mappingType(); } break; case 4: { setState(709); identifierPath(); } break; } _ctx.stop = _input.LT(-1); setState(720); _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 ) { if ( _parseListeners!=null ) triggerExitRuleEvent(); _prevctx = _localctx; { { _localctx = new TypeNameContext(_parentctx, _parentState); pushNewRecursionContext(_localctx, _startState, RULE_typeName); setState(712); if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); setState(713); match(LBrack); setState(715); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,69,_ctx) ) { case 1: { setState(714); expression(0); } break; } setState(717); match(RBrack); } } } setState(722); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,70,_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 ElementaryTypeNameContext extends ParserRuleContext { public boolean allowAddressPayable; public TerminalNode Address() { return getToken(SolidityParser.Address, 0); } public TerminalNode Payable() { return getToken(SolidityParser.Payable, 0); } public TerminalNode Bool() { return getToken(SolidityParser.Bool, 0); } public TerminalNode String() { return getToken(SolidityParser.String, 0); } public TerminalNode Bytes() { return getToken(SolidityParser.Bytes, 0); } public TerminalNode SignedIntegerType() { return getToken(SolidityParser.SignedIntegerType, 0); } public TerminalNode UnsignedIntegerType() { return getToken(SolidityParser.UnsignedIntegerType, 0); } public TerminalNode FixedBytes() { return getToken(SolidityParser.FixedBytes, 0); } public TerminalNode Fixed() { return getToken(SolidityParser.Fixed, 0); } public TerminalNode Ufixed() { return getToken(SolidityParser.Ufixed, 0); } public ElementaryTypeNameContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } public ElementaryTypeNameContext(ParserRuleContext parent, int invokingState, boolean allowAddressPayable) { super(parent, invokingState); this.allowAddressPayable = allowAddressPayable; } @Override public int getRuleIndex() { return RULE_elementaryTypeName; } } public final ElementaryTypeNameContext elementaryTypeName(boolean allowAddressPayable) throws RecognitionException { ElementaryTypeNameContext _localctx = new ElementaryTypeNameContext(_ctx, getState(), allowAddressPayable); enterRule(_localctx, 80, RULE_elementaryTypeName); try { setState(735); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,71,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { setState(723); match(Address); } break; case 2: enterOuterAlt(_localctx, 2); { setState(724); if (!(_localctx.allowAddressPayable)) throw new FailedPredicateException(this, "$allowAddressPayable"); setState(725); match(Address); setState(726); match(Payable); } break; case 3: enterOuterAlt(_localctx, 3); { setState(727); match(Bool); } break; case 4: enterOuterAlt(_localctx, 4); { setState(728); match(String); } break; case 5: enterOuterAlt(_localctx, 5); { setState(729); match(Bytes); } break; case 6: enterOuterAlt(_localctx, 6); { setState(730); match(SignedIntegerType); } break; case 7: enterOuterAlt(_localctx, 7); { setState(731); match(UnsignedIntegerType); } break; case 8: enterOuterAlt(_localctx, 8); { setState(732); match(FixedBytes); } break; case 9: enterOuterAlt(_localctx, 9); { setState(733); match(Fixed); } break; case 10: enterOuterAlt(_localctx, 10); { setState(734); match(Ufixed); } break; } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class FunctionTypeNameContext extends ParserRuleContext { public boolean visibilitySet = false; public boolean mutabilitySet = false; public ParameterListContext arguments; public ParameterListContext returnParameters; public TerminalNode Function() { return getToken(SolidityParser.Function, 0); } public List LParen() { return getTokens(SolidityParser.LParen); } public TerminalNode LParen(int i) { return getToken(SolidityParser.LParen, i); } public List RParen() { return getTokens(SolidityParser.RParen); } public TerminalNode RParen(int i) { return getToken(SolidityParser.RParen, i); } public List visibility() { return getRuleContexts(VisibilityContext.class); } public VisibilityContext visibility(int i) { return getRuleContext(VisibilityContext.class,i); } public List stateMutability() { return getRuleContexts(StateMutabilityContext.class); } public StateMutabilityContext stateMutability(int i) { return getRuleContext(StateMutabilityContext.class,i); } public TerminalNode Returns() { return getToken(SolidityParser.Returns, 0); } public List parameterList() { return getRuleContexts(ParameterListContext.class); } public ParameterListContext parameterList(int i) { return getRuleContext(ParameterListContext.class,i); } public FunctionTypeNameContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_functionTypeName; } } public final FunctionTypeNameContext functionTypeName() throws RecognitionException { FunctionTypeNameContext _localctx = new FunctionTypeNameContext(_ctx, getState()); enterRule(_localctx, 82, RULE_functionTypeName); try { int _alt; enterOuterAlt(_localctx, 1); { setState(737); match(Function); setState(738); match(LParen); setState(740); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,72,_ctx) ) { case 1: { setState(739); ((FunctionTypeNameContext)_localctx).arguments = parameterList(); } break; } setState(742); match(RParen); setState(753); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,74,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { setState(751); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,73,_ctx) ) { case 1: { setState(743); if (!(!_localctx.visibilitySet)) throw new FailedPredicateException(this, "!$visibilitySet"); setState(744); visibility(); ((FunctionTypeNameContext)_localctx).visibilitySet = true; } break; case 2: { setState(747); if (!(!_localctx.mutabilitySet)) throw new FailedPredicateException(this, "!$mutabilitySet"); setState(748); stateMutability(); ((FunctionTypeNameContext)_localctx).mutabilitySet = true; } break; } } } setState(755); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,74,_ctx); } setState(761); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) { case 1: { setState(756); match(Returns); setState(757); match(LParen); setState(758); ((FunctionTypeNameContext)_localctx).returnParameters = parameterList(); setState(759); 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 VariableDeclarationContext extends ParserRuleContext { public TypeNameContext type; public DataLocationContext location; public IdentifierContext name; public TypeNameContext typeName() { return getRuleContext(TypeNameContext.class,0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public DataLocationContext dataLocation() { return getRuleContext(DataLocationContext.class,0); } public VariableDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_variableDeclaration; } } public final VariableDeclarationContext variableDeclaration() throws RecognitionException { VariableDeclarationContext _localctx = new VariableDeclarationContext(_ctx, getState()); enterRule(_localctx, 84, RULE_variableDeclaration); int _la; try { enterOuterAlt(_localctx, 1); { setState(763); ((VariableDeclarationContext)_localctx).type = typeName(0); setState(765); _errHandler.sync(this); _la = _input.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 144119586122368000L) != 0)) { { setState(764); ((VariableDeclarationContext)_localctx).location = dataLocation(); } } setState(767); ((VariableDeclarationContext)_localctx).name = identifier(); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class DataLocationContext extends ParserRuleContext { public TerminalNode Memory() { return getToken(SolidityParser.Memory, 0); } public TerminalNode Storage() { return getToken(SolidityParser.Storage, 0); } public TerminalNode Calldata() { return getToken(SolidityParser.Calldata, 0); } public DataLocationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_dataLocation; } } public final DataLocationContext dataLocation() throws RecognitionException { DataLocationContext _localctx = new DataLocationContext(_ctx, getState()); enterRule(_localctx, 86, RULE_dataLocation); int _la; try { enterOuterAlt(_localctx, 1); { setState(769); _la = _input.LA(1); if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 144119586122368000L) != 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 ExpressionContext extends ParserRuleContext { public ExpressionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_expression; } public ExpressionContext() { } public void copyFrom(ExpressionContext ctx) { super.copyFrom(ctx); } } @SuppressWarnings("CheckReturnValue") public static class UnaryPrefixOperationContext extends ExpressionContext { public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } public TerminalNode Inc() { return getToken(SolidityParser.Inc, 0); } public TerminalNode Dec() { return getToken(SolidityParser.Dec, 0); } public TerminalNode Not() { return getToken(SolidityParser.Not, 0); } public TerminalNode BitNot() { return getToken(SolidityParser.BitNot, 0); } public TerminalNode Delete() { return getToken(SolidityParser.Delete, 0); } public TerminalNode Sub() { return getToken(SolidityParser.Sub, 0); } public UnaryPrefixOperationContext(ExpressionContext ctx) { copyFrom(ctx); } } @SuppressWarnings("CheckReturnValue") public static class PrimaryExpressionContext extends ExpressionContext { public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public LiteralContext literal() { return getRuleContext(LiteralContext.class,0); } public LiteralWithSubDenominationContext literalWithSubDenomination() { return getRuleContext(LiteralWithSubDenominationContext.class,0); } public ElementaryTypeNameContext elementaryTypeName() { return getRuleContext(ElementaryTypeNameContext.class,0); } public PrimaryExpressionContext(ExpressionContext ctx) { copyFrom(ctx); } } @SuppressWarnings("CheckReturnValue") public static class OrderComparisonContext extends ExpressionContext { public List expression() { return getRuleContexts(ExpressionContext.class); } public ExpressionContext expression(int i) { return getRuleContext(ExpressionContext.class,i); } public TerminalNode LessThan() { return getToken(SolidityParser.LessThan, 0); } public TerminalNode GreaterThan() { return getToken(SolidityParser.GreaterThan, 0); } public TerminalNode LessThanOrEqual() { return getToken(SolidityParser.LessThanOrEqual, 0); } public TerminalNode GreaterThanOrEqual() { return getToken(SolidityParser.GreaterThanOrEqual, 0); } public OrderComparisonContext(ExpressionContext ctx) { copyFrom(ctx); } } @SuppressWarnings("CheckReturnValue") public static class ConditionalContext extends ExpressionContext { public List expression() { return getRuleContexts(ExpressionContext.class); } public ExpressionContext expression(int i) { return getRuleContext(ExpressionContext.class,i); } public TerminalNode Conditional() { return getToken(SolidityParser.Conditional, 0); } public TerminalNode Colon() { return getToken(SolidityParser.Colon, 0); } public ConditionalContext(ExpressionContext ctx) { copyFrom(ctx); } } @SuppressWarnings("CheckReturnValue") public static class PayableConversionContext extends ExpressionContext { public TerminalNode Payable() { return getToken(SolidityParser.Payable, 0); } public CallArgumentListContext callArgumentList() { return getRuleContext(CallArgumentListContext.class,0); } public PayableConversionContext(ExpressionContext ctx) { copyFrom(ctx); } } @SuppressWarnings("CheckReturnValue") public static class AssignmentContext extends ExpressionContext { public List expression() { return getRuleContexts(ExpressionContext.class); } public ExpressionContext expression(int i) { return getRuleContext(ExpressionContext.class,i); } public AssignOpContext assignOp() { return getRuleContext(AssignOpContext.class,0); } public AssignmentContext(ExpressionContext ctx) { copyFrom(ctx); } } @SuppressWarnings("CheckReturnValue") public static class UnarySuffixOperationContext extends ExpressionContext { public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } public TerminalNode Inc() { return getToken(SolidityParser.Inc, 0); } public TerminalNode Dec() { return getToken(SolidityParser.Dec, 0); } public UnarySuffixOperationContext(ExpressionContext ctx) { copyFrom(ctx); } } @SuppressWarnings("CheckReturnValue") public static class ShiftOperationContext extends ExpressionContext { public List expression() { return getRuleContexts(ExpressionContext.class); } public ExpressionContext expression(int i) { return getRuleContext(ExpressionContext.class,i); } public TerminalNode Shl() { return getToken(SolidityParser.Shl, 0); } public TerminalNode Sar() { return getToken(SolidityParser.Sar, 0); } public TerminalNode Shr() { return getToken(SolidityParser.Shr, 0); } public ShiftOperationContext(ExpressionContext ctx) { copyFrom(ctx); } } @SuppressWarnings("CheckReturnValue") public static class BitAndOperationContext extends ExpressionContext { public List expression() { return getRuleContexts(ExpressionContext.class); } public ExpressionContext expression(int i) { return getRuleContext(ExpressionContext.class,i); } public TerminalNode BitAnd() { return getToken(SolidityParser.BitAnd, 0); } public BitAndOperationContext(ExpressionContext ctx) { copyFrom(ctx); } } @SuppressWarnings("CheckReturnValue") public static class FunctionCallContext extends ExpressionContext { public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } public CallArgumentListContext callArgumentList() { return getRuleContext(CallArgumentListContext.class,0); } public FunctionCallContext(ExpressionContext ctx) { copyFrom(ctx); } } @SuppressWarnings("CheckReturnValue") public static class IndexRangeAccessContext extends ExpressionContext { public ExpressionContext startIndex; public ExpressionContext endIndex; public List expression() { return getRuleContexts(ExpressionContext.class); } public ExpressionContext expression(int i) { return getRuleContext(ExpressionContext.class,i); } public TerminalNode LBrack() { return getToken(SolidityParser.LBrack, 0); } public TerminalNode Colon() { return getToken(SolidityParser.Colon, 0); } public TerminalNode RBrack() { return getToken(SolidityParser.RBrack, 0); } public IndexRangeAccessContext(ExpressionContext ctx) { copyFrom(ctx); } } @SuppressWarnings("CheckReturnValue") public static class IndexAccessContext extends ExpressionContext { public ExpressionContext index; public List expression() { return getRuleContexts(ExpressionContext.class); } public ExpressionContext expression(int i) { return getRuleContext(ExpressionContext.class,i); } public TerminalNode LBrack() { return getToken(SolidityParser.LBrack, 0); } public TerminalNode RBrack() { return getToken(SolidityParser.RBrack, 0); } public IndexAccessContext(ExpressionContext ctx) { copyFrom(ctx); } } @SuppressWarnings("CheckReturnValue") public static class AddSubOperationContext extends ExpressionContext { public List expression() { return getRuleContexts(ExpressionContext.class); } public ExpressionContext expression(int i) { return getRuleContext(ExpressionContext.class,i); } public TerminalNode Add() { return getToken(SolidityParser.Add, 0); } public TerminalNode Sub() { return getToken(SolidityParser.Sub, 0); } public AddSubOperationContext(ExpressionContext ctx) { copyFrom(ctx); } } @SuppressWarnings("CheckReturnValue") public static class BitOrOperationContext extends ExpressionContext { public List expression() { return getRuleContexts(ExpressionContext.class); } public ExpressionContext expression(int i) { return getRuleContext(ExpressionContext.class,i); } public TerminalNode BitOr() { return getToken(SolidityParser.BitOr, 0); } public BitOrOperationContext(ExpressionContext ctx) { copyFrom(ctx); } } @SuppressWarnings("CheckReturnValue") public static class ExpOperationContext extends ExpressionContext { public List expression() { return getRuleContexts(ExpressionContext.class); } public ExpressionContext expression(int i) { return getRuleContext(ExpressionContext.class,i); } public TerminalNode Exp() { return getToken(SolidityParser.Exp, 0); } public ExpOperationContext(ExpressionContext ctx) { copyFrom(ctx); } } @SuppressWarnings("CheckReturnValue") public static class AndOperationContext extends ExpressionContext { public List expression() { return getRuleContexts(ExpressionContext.class); } public ExpressionContext expression(int i) { return getRuleContext(ExpressionContext.class,i); } public TerminalNode And() { return getToken(SolidityParser.And, 0); } public AndOperationContext(ExpressionContext ctx) { copyFrom(ctx); } } @SuppressWarnings("CheckReturnValue") public static class InlineArrayContext extends ExpressionContext { public InlineArrayExpressionContext inlineArrayExpression() { return getRuleContext(InlineArrayExpressionContext.class,0); } public InlineArrayContext(ExpressionContext ctx) { copyFrom(ctx); } } @SuppressWarnings("CheckReturnValue") public static class OrOperationContext extends ExpressionContext { public List expression() { return getRuleContexts(ExpressionContext.class); } public ExpressionContext expression(int i) { return getRuleContext(ExpressionContext.class,i); } public TerminalNode Or() { return getToken(SolidityParser.Or, 0); } public OrOperationContext(ExpressionContext ctx) { copyFrom(ctx); } } @SuppressWarnings("CheckReturnValue") public static class MemberAccessContext extends ExpressionContext { public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } public TerminalNode Period() { return getToken(SolidityParser.Period, 0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public TerminalNode Address() { return getToken(SolidityParser.Address, 0); } public MemberAccessContext(ExpressionContext ctx) { copyFrom(ctx); } } @SuppressWarnings("CheckReturnValue") public static class MulDivModOperationContext extends ExpressionContext { public List expression() { return getRuleContexts(ExpressionContext.class); } public ExpressionContext expression(int i) { return getRuleContext(ExpressionContext.class,i); } public TerminalNode Mul() { return getToken(SolidityParser.Mul, 0); } public TerminalNode Div() { return getToken(SolidityParser.Div, 0); } public TerminalNode Mod() { return getToken(SolidityParser.Mod, 0); } public MulDivModOperationContext(ExpressionContext ctx) { copyFrom(ctx); } } @SuppressWarnings("CheckReturnValue") public static class FunctionCallOptionsContext extends ExpressionContext { public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } public TerminalNode LBrace() { return getToken(SolidityParser.LBrace, 0); } public TerminalNode RBrace() { return getToken(SolidityParser.RBrace, 0); } public List namedArgument() { return getRuleContexts(NamedArgumentContext.class); } public NamedArgumentContext namedArgument(int i) { return getRuleContext(NamedArgumentContext.class,i); } public List Comma() { return getTokens(SolidityParser.Comma); } public TerminalNode Comma(int i) { return getToken(SolidityParser.Comma, i); } public FunctionCallOptionsContext(ExpressionContext ctx) { copyFrom(ctx); } } @SuppressWarnings("CheckReturnValue") public static class NewExprContext extends ExpressionContext { public TerminalNode New() { return getToken(SolidityParser.New, 0); } public TypeNameContext typeName() { return getRuleContext(TypeNameContext.class,0); } public NewExprContext(ExpressionContext ctx) { copyFrom(ctx); } } @SuppressWarnings("CheckReturnValue") public static class BitXorOperationContext extends ExpressionContext { public List expression() { return getRuleContexts(ExpressionContext.class); } public ExpressionContext expression(int i) { return getRuleContext(ExpressionContext.class,i); } public TerminalNode BitXor() { return getToken(SolidityParser.BitXor, 0); } public BitXorOperationContext(ExpressionContext ctx) { copyFrom(ctx); } } @SuppressWarnings("CheckReturnValue") public static class TupleContext extends ExpressionContext { public TupleExpressionContext tupleExpression() { return getRuleContext(TupleExpressionContext.class,0); } public TupleContext(ExpressionContext ctx) { copyFrom(ctx); } } @SuppressWarnings("CheckReturnValue") public static class EqualityComparisonContext extends ExpressionContext { public List expression() { return getRuleContexts(ExpressionContext.class); } public ExpressionContext expression(int i) { return getRuleContext(ExpressionContext.class,i); } public TerminalNode Equal() { return getToken(SolidityParser.Equal, 0); } public TerminalNode NotEqual() { return getToken(SolidityParser.NotEqual, 0); } public EqualityComparisonContext(ExpressionContext ctx) { copyFrom(ctx); } } @SuppressWarnings("CheckReturnValue") public static class MetaTypeContext extends ExpressionContext { public TerminalNode Type() { return getToken(SolidityParser.Type, 0); } public TerminalNode LParen() { return getToken(SolidityParser.LParen, 0); } public TypeNameContext typeName() { return getRuleContext(TypeNameContext.class,0); } public TerminalNode RParen() { return getToken(SolidityParser.RParen, 0); } public MetaTypeContext(ExpressionContext ctx) { copyFrom(ctx); } } public final ExpressionContext expression() throws RecognitionException { return expression(0); } private ExpressionContext expression(int _p) throws RecognitionException { ParserRuleContext _parentctx = _ctx; int _parentState = getState(); ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState); ExpressionContext _prevctx = _localctx; int _startState = 88; enterRecursionRule(_localctx, 88, RULE_expression, _p); int _la; try { int _alt; enterOuterAlt(_localctx, 1); { setState(791); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,78,_ctx) ) { case 1: { _localctx = new PayableConversionContext(_localctx); _ctx = _localctx; _prevctx = _localctx; setState(772); match(Payable); setState(773); callArgumentList(); } break; case 2: { _localctx = new MetaTypeContext(_localctx); _ctx = _localctx; _prevctx = _localctx; setState(774); match(Type); setState(775); match(LParen); setState(776); typeName(0); setState(777); match(RParen); } break; case 3: { _localctx = new UnaryPrefixOperationContext(_localctx); _ctx = _localctx; _prevctx = _localctx; setState(779); _la = _input.LA(1); if ( !(_la==Delete || ((((_la - 105)) & ~0x3f) == 0 && ((1L << (_la - 105)) & 30721L) != 0)) ) { _errHandler.recoverInline(this); } else { if ( _input.LA(1)==Token.EOF ) matchedEOF = true; _errHandler.reportMatch(this); consume(); } setState(780); expression(19); } break; case 4: { _localctx = new NewExprContext(_localctx); _ctx = _localctx; _prevctx = _localctx; setState(781); match(New); setState(782); typeName(0); } break; case 5: { _localctx = new TupleContext(_localctx); _ctx = _localctx; _prevctx = _localctx; setState(783); tupleExpression(); } break; case 6: { _localctx = new InlineArrayContext(_localctx); _ctx = _localctx; _prevctx = _localctx; setState(784); inlineArrayExpression(); } break; case 7: { _localctx = new PrimaryExpressionContext(_localctx); _ctx = _localctx; _prevctx = _localctx; setState(789); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) { case 1: { setState(785); identifier(); } break; case 2: { setState(786); literal(); } break; case 3: { setState(787); literalWithSubDenomination(); } break; case 4: { setState(788); elementaryTypeName(false); } break; } } break; } _ctx.stop = _input.LT(-1); setState(877); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,86,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { if ( _parseListeners!=null ) triggerExitRuleEvent(); _prevctx = _localctx; { setState(875); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) { case 1: { _localctx = new ExpOperationContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(793); if (!(precpred(_ctx, 17))) throw new FailedPredicateException(this, "precpred(_ctx, 17)"); setState(794); match(Exp); setState(795); expression(17); } break; case 2: { _localctx = new MulDivModOperationContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(796); if (!(precpred(_ctx, 16))) throw new FailedPredicateException(this, "precpred(_ctx, 16)"); setState(797); _la = _input.LA(1); if ( !(((((_la - 106)) & ~0x3f) == 0 && ((1L << (_la - 106)) & 7L) != 0)) ) { _errHandler.recoverInline(this); } else { if ( _input.LA(1)==Token.EOF ) matchedEOF = true; _errHandler.reportMatch(this); consume(); } setState(798); expression(17); } break; case 3: { _localctx = new AddSubOperationContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(799); if (!(precpred(_ctx, 15))) throw new FailedPredicateException(this, "precpred(_ctx, 15)"); setState(800); _la = _input.LA(1); if ( !(_la==Add || _la==Sub) ) { _errHandler.recoverInline(this); } else { if ( _input.LA(1)==Token.EOF ) matchedEOF = true; _errHandler.reportMatch(this); consume(); } setState(801); expression(16); } break; case 4: { _localctx = new ShiftOperationContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(802); if (!(precpred(_ctx, 14))) throw new FailedPredicateException(this, "precpred(_ctx, 14)"); setState(803); _la = _input.LA(1); if ( !(((((_la - 101)) & ~0x3f) == 0 && ((1L << (_la - 101)) & 7L) != 0)) ) { _errHandler.recoverInline(this); } else { if ( _input.LA(1)==Token.EOF ) matchedEOF = true; _errHandler.reportMatch(this); consume(); } setState(804); expression(15); } break; case 5: { _localctx = new BitAndOperationContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(805); if (!(precpred(_ctx, 13))) throw new FailedPredicateException(this, "precpred(_ctx, 13)"); setState(806); match(BitAnd); setState(807); expression(14); } break; case 6: { _localctx = new BitXorOperationContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(808); if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)"); setState(809); match(BitXor); setState(810); expression(13); } break; case 7: { _localctx = new BitOrOperationContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(811); if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)"); setState(812); match(BitOr); setState(813); expression(12); } break; case 8: { _localctx = new OrderComparisonContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(814); if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)"); setState(815); _la = _input.LA(1); if ( !(((((_la - 112)) & ~0x3f) == 0 && ((1L << (_la - 112)) & 15L) != 0)) ) { _errHandler.recoverInline(this); } else { if ( _input.LA(1)==Token.EOF ) matchedEOF = true; _errHandler.reportMatch(this); consume(); } setState(816); expression(11); } break; case 9: { _localctx = new EqualityComparisonContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(817); if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)"); setState(818); _la = _input.LA(1); if ( !(_la==Equal || _la==NotEqual) ) { _errHandler.recoverInline(this); } else { if ( _input.LA(1)==Token.EOF ) matchedEOF = true; _errHandler.reportMatch(this); consume(); } setState(819); expression(10); } break; case 10: { _localctx = new AndOperationContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(820); if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)"); setState(821); match(And); setState(822); expression(9); } break; case 11: { _localctx = new OrOperationContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(823); if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)"); setState(824); match(Or); setState(825); expression(8); } break; case 12: { _localctx = new ConditionalContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(826); if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)"); setState(827); match(Conditional); setState(828); expression(0); setState(829); match(Colon); setState(830); expression(6); } break; case 13: { _localctx = new AssignmentContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(832); if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)"); setState(833); assignOp(); setState(834); expression(5); } break; case 14: { _localctx = new IndexAccessContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(836); if (!(precpred(_ctx, 26))) throw new FailedPredicateException(this, "precpred(_ctx, 26)"); setState(837); match(LBrack); setState(839); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,79,_ctx) ) { case 1: { setState(838); ((IndexAccessContext)_localctx).index = expression(0); } break; } setState(841); match(RBrack); } break; case 15: { _localctx = new IndexRangeAccessContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(842); if (!(precpred(_ctx, 25))) throw new FailedPredicateException(this, "precpred(_ctx, 25)"); setState(843); match(LBrack); setState(845); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) { case 1: { setState(844); ((IndexRangeAccessContext)_localctx).startIndex = expression(0); } break; } setState(847); match(Colon); setState(849); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,81,_ctx) ) { case 1: { setState(848); ((IndexRangeAccessContext)_localctx).endIndex = expression(0); } break; } setState(851); match(RBrack); } break; case 16: { _localctx = new MemberAccessContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(852); if (!(precpred(_ctx, 24))) throw new FailedPredicateException(this, "precpred(_ctx, 24)"); setState(853); match(Period); setState(856); _errHandler.sync(this); switch (_input.LA(1)) { case Error: case From: case Global: case Revert: case Identifier: { setState(854); identifier(); } break; case Address: { setState(855); match(Address); } break; default: throw new NoViableAltException(this); } } break; case 17: { _localctx = new FunctionCallOptionsContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(858); if (!(precpred(_ctx, 23))) throw new FailedPredicateException(this, "precpred(_ctx, 23)"); setState(859); match(LBrace); setState(868); _errHandler.sync(this); _la = _input.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 36028799705415680L) != 0) || _la==Identifier) { { setState(860); namedArgument(); setState(865); _errHandler.sync(this); _la = _input.LA(1); while (_la==Comma) { { { setState(861); match(Comma); setState(862); namedArgument(); } } setState(867); _errHandler.sync(this); _la = _input.LA(1); } } } setState(870); match(RBrace); } break; case 18: { _localctx = new FunctionCallContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(871); if (!(precpred(_ctx, 22))) throw new FailedPredicateException(this, "precpred(_ctx, 22)"); setState(872); callArgumentList(); } break; case 19: { _localctx = new UnarySuffixOperationContext(new ExpressionContext(_parentctx, _parentState)); pushNewRecursionContext(_localctx, _startState, RULE_expression); setState(873); if (!(precpred(_ctx, 18))) throw new FailedPredicateException(this, "precpred(_ctx, 18)"); setState(874); _la = _input.LA(1); if ( !(_la==Inc || _la==Dec) ) { _errHandler.recoverInline(this); } else { if ( _input.LA(1)==Token.EOF ) matchedEOF = true; _errHandler.reportMatch(this); consume(); } } break; } } } setState(879); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,86,_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 AssignOpContext extends ParserRuleContext { public TerminalNode Assign() { return getToken(SolidityParser.Assign, 0); } public TerminalNode AssignBitOr() { return getToken(SolidityParser.AssignBitOr, 0); } public TerminalNode AssignBitXor() { return getToken(SolidityParser.AssignBitXor, 0); } public TerminalNode AssignBitAnd() { return getToken(SolidityParser.AssignBitAnd, 0); } public TerminalNode AssignShl() { return getToken(SolidityParser.AssignShl, 0); } public TerminalNode AssignSar() { return getToken(SolidityParser.AssignSar, 0); } public TerminalNode AssignShr() { return getToken(SolidityParser.AssignShr, 0); } public TerminalNode AssignAdd() { return getToken(SolidityParser.AssignAdd, 0); } public TerminalNode AssignSub() { return getToken(SolidityParser.AssignSub, 0); } public TerminalNode AssignMul() { return getToken(SolidityParser.AssignMul, 0); } public TerminalNode AssignDiv() { return getToken(SolidityParser.AssignDiv, 0); } public TerminalNode AssignMod() { return getToken(SolidityParser.AssignMod, 0); } public AssignOpContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_assignOp; } } public final AssignOpContext assignOp() throws RecognitionException { AssignOpContext _localctx = new AssignOpContext(_ctx, getState()); enterRule(_localctx, 90, RULE_assignOp); int _la; try { enterOuterAlt(_localctx, 1); { setState(880); _la = _input.LA(1); if ( !(((((_la - 83)) & ~0x3f) == 0 && ((1L << (_la - 83)) & 4095L) != 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 TupleExpressionContext extends ParserRuleContext { public TerminalNode LParen() { return getToken(SolidityParser.LParen, 0); } public TerminalNode RParen() { return getToken(SolidityParser.RParen, 0); } public List expression() { return getRuleContexts(ExpressionContext.class); } public ExpressionContext expression(int i) { return getRuleContext(ExpressionContext.class,i); } public List Comma() { return getTokens(SolidityParser.Comma); } public TerminalNode Comma(int i) { return getToken(SolidityParser.Comma, i); } public TupleExpressionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_tupleExpression; } } public final TupleExpressionContext tupleExpression() throws RecognitionException { TupleExpressionContext _localctx = new TupleExpressionContext(_ctx, getState()); enterRule(_localctx, 92, RULE_tupleExpression); int _la; try { enterOuterAlt(_localctx, 1); { setState(882); match(LParen); { setState(884); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) { case 1: { setState(883); expression(0); } break; } setState(892); _errHandler.sync(this); _la = _input.LA(1); while (_la==Comma) { { { setState(886); match(Comma); setState(888); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,88,_ctx) ) { case 1: { setState(887); expression(0); } break; } } } setState(894); _errHandler.sync(this); _la = _input.LA(1); } } setState(895); 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 InlineArrayExpressionContext extends ParserRuleContext { public TerminalNode LBrack() { return getToken(SolidityParser.LBrack, 0); } public TerminalNode RBrack() { return getToken(SolidityParser.RBrack, 0); } public List expression() { return getRuleContexts(ExpressionContext.class); } public ExpressionContext expression(int i) { return getRuleContext(ExpressionContext.class,i); } public List Comma() { return getTokens(SolidityParser.Comma); } public TerminalNode Comma(int i) { return getToken(SolidityParser.Comma, i); } public InlineArrayExpressionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_inlineArrayExpression; } } public final InlineArrayExpressionContext inlineArrayExpression() throws RecognitionException { InlineArrayExpressionContext _localctx = new InlineArrayExpressionContext(_ctx, getState()); enterRule(_localctx, 94, RULE_inlineArrayExpression); int _la; try { enterOuterAlt(_localctx, 1); { setState(897); match(LBrack); { setState(898); expression(0); setState(903); _errHandler.sync(this); _la = _input.LA(1); while (_la==Comma) { { { setState(899); match(Comma); setState(900); expression(0); } } setState(905); _errHandler.sync(this); _la = _input.LA(1); } } setState(906); match(RBrack); } } 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 TerminalNode Identifier() { return getToken(SolidityParser.Identifier, 0); } public TerminalNode From() { return getToken(SolidityParser.From, 0); } public TerminalNode Error() { return getToken(SolidityParser.Error, 0); } public TerminalNode Revert() { return getToken(SolidityParser.Revert, 0); } public TerminalNode Global() { return getToken(SolidityParser.Global, 0); } public IdentifierContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_identifier; } } public final IdentifierContext identifier() throws RecognitionException { IdentifierContext _localctx = new IdentifierContext(_ctx, getState()); enterRule(_localctx, 96, RULE_identifier); int _la; try { enterOuterAlt(_localctx, 1); { setState(908); _la = _input.LA(1); if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 36028799705415680L) != 0) || _la==Identifier) ) { _errHandler.recoverInline(this); } else { if ( _input.LA(1)==Token.EOF ) matchedEOF = true; _errHandler.reportMatch(this); consume(); } } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class LiteralContext extends ParserRuleContext { public StringLiteralContext stringLiteral() { return getRuleContext(StringLiteralContext.class,0); } public NumberLiteralContext numberLiteral() { return getRuleContext(NumberLiteralContext.class,0); } public BooleanLiteralContext booleanLiteral() { return getRuleContext(BooleanLiteralContext.class,0); } public HexStringLiteralContext hexStringLiteral() { return getRuleContext(HexStringLiteralContext.class,0); } public UnicodeStringLiteralContext unicodeStringLiteral() { return getRuleContext(UnicodeStringLiteralContext.class,0); } public LiteralContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_literal; } } public final LiteralContext literal() throws RecognitionException { LiteralContext _localctx = new LiteralContext(_ctx, getState()); enterRule(_localctx, 98, RULE_literal); try { setState(915); _errHandler.sync(this); switch (_input.LA(1)) { case NonEmptyStringLiteral: case EmptyStringLiteral: enterOuterAlt(_localctx, 1); { setState(910); stringLiteral(); } break; case HexNumber: case DecimalNumber: enterOuterAlt(_localctx, 2); { setState(911); numberLiteral(); } break; case False: case True: enterOuterAlt(_localctx, 3); { setState(912); booleanLiteral(); } break; case HexString: enterOuterAlt(_localctx, 4); { setState(913); hexStringLiteral(); } break; case UnicodeStringLiteral: enterOuterAlt(_localctx, 5); { setState(914); unicodeStringLiteral(); } 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 LiteralWithSubDenominationContext extends ParserRuleContext { public NumberLiteralContext numberLiteral() { return getRuleContext(NumberLiteralContext.class,0); } public TerminalNode SubDenomination() { return getToken(SolidityParser.SubDenomination, 0); } public LiteralWithSubDenominationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_literalWithSubDenomination; } } public final LiteralWithSubDenominationContext literalWithSubDenomination() throws RecognitionException { LiteralWithSubDenominationContext _localctx = new LiteralWithSubDenominationContext(_ctx, getState()); enterRule(_localctx, 100, RULE_literalWithSubDenomination); try { enterOuterAlt(_localctx, 1); { setState(917); numberLiteral(); setState(918); match(SubDenomination); } } 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 True() { return getToken(SolidityParser.True, 0); } public TerminalNode False() { return getToken(SolidityParser.False, 0); } public BooleanLiteralContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_booleanLiteral; } } public final BooleanLiteralContext booleanLiteral() throws RecognitionException { BooleanLiteralContext _localctx = new BooleanLiteralContext(_ctx, getState()); enterRule(_localctx, 102, RULE_booleanLiteral); int _la; try { enterOuterAlt(_localctx, 1); { setState(920); _la = _input.LA(1); if ( !(_la==False || _la==True) ) { _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 StringLiteralContext extends ParserRuleContext { public List NonEmptyStringLiteral() { return getTokens(SolidityParser.NonEmptyStringLiteral); } public TerminalNode NonEmptyStringLiteral(int i) { return getToken(SolidityParser.NonEmptyStringLiteral, i); } public List EmptyStringLiteral() { return getTokens(SolidityParser.EmptyStringLiteral); } public TerminalNode EmptyStringLiteral(int i) { return getToken(SolidityParser.EmptyStringLiteral, i); } public StringLiteralContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_stringLiteral; } } public final StringLiteralContext stringLiteral() throws RecognitionException { StringLiteralContext _localctx = new StringLiteralContext(_ctx, getState()); enterRule(_localctx, 104, RULE_stringLiteral); int _la; try { int _alt; enterOuterAlt(_localctx, 1); { setState(923); _errHandler.sync(this); _alt = 1; do { switch (_alt) { case 1: { { setState(922); _la = _input.LA(1); if ( !(_la==NonEmptyStringLiteral || _la==EmptyStringLiteral) ) { _errHandler.recoverInline(this); } else { if ( _input.LA(1)==Token.EOF ) matchedEOF = true; _errHandler.reportMatch(this); consume(); } } } break; default: throw new NoViableAltException(this); } setState(925); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,92,_ctx); } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class HexStringLiteralContext extends ParserRuleContext { public List HexString() { return getTokens(SolidityParser.HexString); } public TerminalNode HexString(int i) { return getToken(SolidityParser.HexString, i); } public HexStringLiteralContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_hexStringLiteral; } } public final HexStringLiteralContext hexStringLiteral() throws RecognitionException { HexStringLiteralContext _localctx = new HexStringLiteralContext(_ctx, getState()); enterRule(_localctx, 106, RULE_hexStringLiteral); try { int _alt; enterOuterAlt(_localctx, 1); { setState(928); _errHandler.sync(this); _alt = 1; do { switch (_alt) { case 1: { { setState(927); match(HexString); } } break; default: throw new NoViableAltException(this); } setState(930); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,93,_ctx); } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class UnicodeStringLiteralContext extends ParserRuleContext { public List UnicodeStringLiteral() { return getTokens(SolidityParser.UnicodeStringLiteral); } public TerminalNode UnicodeStringLiteral(int i) { return getToken(SolidityParser.UnicodeStringLiteral, i); } public UnicodeStringLiteralContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_unicodeStringLiteral; } } public final UnicodeStringLiteralContext unicodeStringLiteral() throws RecognitionException { UnicodeStringLiteralContext _localctx = new UnicodeStringLiteralContext(_ctx, getState()); enterRule(_localctx, 108, RULE_unicodeStringLiteral); try { int _alt; enterOuterAlt(_localctx, 1); { setState(933); _errHandler.sync(this); _alt = 1; do { switch (_alt) { case 1: { { setState(932); match(UnicodeStringLiteral); } } break; default: throw new NoViableAltException(this); } setState(935); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,94,_ctx); } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class NumberLiteralContext extends ParserRuleContext { public TerminalNode DecimalNumber() { return getToken(SolidityParser.DecimalNumber, 0); } public TerminalNode HexNumber() { return getToken(SolidityParser.HexNumber, 0); } public NumberLiteralContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_numberLiteral; } } public final NumberLiteralContext numberLiteral() throws RecognitionException { NumberLiteralContext _localctx = new NumberLiteralContext(_ctx, getState()); enterRule(_localctx, 110, RULE_numberLiteral); int _la; try { enterOuterAlt(_localctx, 1); { setState(937); _la = _input.LA(1); if ( !(_la==HexNumber || _la==DecimalNumber) ) { _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 BlockContext extends ParserRuleContext { public TerminalNode LBrace() { return getToken(SolidityParser.LBrace, 0); } public TerminalNode RBrace() { return getToken(SolidityParser.RBrace, 0); } public List statement() { return getRuleContexts(StatementContext.class); } public StatementContext statement(int i) { return getRuleContext(StatementContext.class,i); } public List uncheckedBlock() { return getRuleContexts(UncheckedBlockContext.class); } public UncheckedBlockContext uncheckedBlock(int i) { return getRuleContext(UncheckedBlockContext.class,i); } public BlockContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_block; } } public final BlockContext block() throws RecognitionException { BlockContext _localctx = new BlockContext(_ctx, getState()); enterRule(_localctx, 112, RULE_block); try { int _alt; enterOuterAlt(_localctx, 1); { setState(939); match(LBrace); setState(944); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,96,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { setState(942); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,95,_ctx) ) { case 1: { setState(940); statement(); } break; case 2: { setState(941); uncheckedBlock(); } break; } } } setState(946); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,96,_ctx); } setState(947); match(RBrace); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class UncheckedBlockContext extends ParserRuleContext { public TerminalNode Unchecked() { return getToken(SolidityParser.Unchecked, 0); } public BlockContext block() { return getRuleContext(BlockContext.class,0); } public UncheckedBlockContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_uncheckedBlock; } } public final UncheckedBlockContext uncheckedBlock() throws RecognitionException { UncheckedBlockContext _localctx = new UncheckedBlockContext(_ctx, getState()); enterRule(_localctx, 114, RULE_uncheckedBlock); try { enterOuterAlt(_localctx, 1); { setState(949); match(Unchecked); setState(950); block(); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class StatementContext extends ParserRuleContext { public BlockContext block() { return getRuleContext(BlockContext.class,0); } public SimpleStatementContext simpleStatement() { return getRuleContext(SimpleStatementContext.class,0); } public IfStatementContext ifStatement() { return getRuleContext(IfStatementContext.class,0); } public ForStatementContext forStatement() { return getRuleContext(ForStatementContext.class,0); } public WhileStatementContext whileStatement() { return getRuleContext(WhileStatementContext.class,0); } public DoWhileStatementContext doWhileStatement() { return getRuleContext(DoWhileStatementContext.class,0); } public ContinueStatementContext continueStatement() { return getRuleContext(ContinueStatementContext.class,0); } public BreakStatementContext breakStatement() { return getRuleContext(BreakStatementContext.class,0); } public TryStatementContext tryStatement() { return getRuleContext(TryStatementContext.class,0); } public ReturnStatementContext returnStatement() { return getRuleContext(ReturnStatementContext.class,0); } public EmitStatementContext emitStatement() { return getRuleContext(EmitStatementContext.class,0); } public RevertStatementContext revertStatement() { return getRuleContext(RevertStatementContext.class,0); } public AssemblyStatementContext assemblyStatement() { return getRuleContext(AssemblyStatementContext.class,0); } public StatementContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_statement; } } public final StatementContext statement() throws RecognitionException { StatementContext _localctx = new StatementContext(_ctx, getState()); enterRule(_localctx, 116, RULE_statement); try { setState(965); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,97,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { setState(952); block(); } break; case 2: enterOuterAlt(_localctx, 2); { setState(953); simpleStatement(); } break; case 3: enterOuterAlt(_localctx, 3); { setState(954); ifStatement(); } break; case 4: enterOuterAlt(_localctx, 4); { setState(955); forStatement(); } break; case 5: enterOuterAlt(_localctx, 5); { setState(956); whileStatement(); } break; case 6: enterOuterAlt(_localctx, 6); { setState(957); doWhileStatement(); } break; case 7: enterOuterAlt(_localctx, 7); { setState(958); continueStatement(); } break; case 8: enterOuterAlt(_localctx, 8); { setState(959); breakStatement(); } break; case 9: enterOuterAlt(_localctx, 9); { setState(960); tryStatement(); } break; case 10: enterOuterAlt(_localctx, 10); { setState(961); returnStatement(); } break; case 11: enterOuterAlt(_localctx, 11); { setState(962); emitStatement(); } break; case 12: enterOuterAlt(_localctx, 12); { setState(963); revertStatement(); } break; case 13: enterOuterAlt(_localctx, 13); { setState(964); assemblyStatement(); } break; } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class SimpleStatementContext extends ParserRuleContext { public VariableDeclarationStatementContext variableDeclarationStatement() { return getRuleContext(VariableDeclarationStatementContext.class,0); } public ExpressionStatementContext expressionStatement() { return getRuleContext(ExpressionStatementContext.class,0); } public SimpleStatementContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_simpleStatement; } } public final SimpleStatementContext simpleStatement() throws RecognitionException { SimpleStatementContext _localctx = new SimpleStatementContext(_ctx, getState()); enterRule(_localctx, 118, RULE_simpleStatement); try { setState(969); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,98,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { setState(967); variableDeclarationStatement(); } break; case 2: enterOuterAlt(_localctx, 2); { setState(968); expressionStatement(); } break; } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class IfStatementContext extends ParserRuleContext { public TerminalNode If() { return getToken(SolidityParser.If, 0); } public TerminalNode LParen() { return getToken(SolidityParser.LParen, 0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } public TerminalNode RParen() { return getToken(SolidityParser.RParen, 0); } public List statement() { return getRuleContexts(StatementContext.class); } public StatementContext statement(int i) { return getRuleContext(StatementContext.class,i); } public TerminalNode Else() { return getToken(SolidityParser.Else, 0); } public IfStatementContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_ifStatement; } } public final IfStatementContext ifStatement() throws RecognitionException { IfStatementContext _localctx = new IfStatementContext(_ctx, getState()); enterRule(_localctx, 120, RULE_ifStatement); try { enterOuterAlt(_localctx, 1); { setState(971); match(If); setState(972); match(LParen); setState(973); expression(0); setState(974); match(RParen); setState(975); statement(); setState(978); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,99,_ctx) ) { case 1: { setState(976); match(Else); setState(977); statement(); } break; } } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class ForStatementContext extends ParserRuleContext { public TerminalNode For() { return getToken(SolidityParser.For, 0); } public TerminalNode LParen() { return getToken(SolidityParser.LParen, 0); } public TerminalNode RParen() { return getToken(SolidityParser.RParen, 0); } public StatementContext statement() { return getRuleContext(StatementContext.class,0); } public SimpleStatementContext simpleStatement() { return getRuleContext(SimpleStatementContext.class,0); } public List Semicolon() { return getTokens(SolidityParser.Semicolon); } public TerminalNode Semicolon(int i) { return getToken(SolidityParser.Semicolon, i); } public ExpressionStatementContext expressionStatement() { return getRuleContext(ExpressionStatementContext.class,0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } public ForStatementContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_forStatement; } } public final ForStatementContext forStatement() throws RecognitionException { ForStatementContext _localctx = new ForStatementContext(_ctx, getState()); enterRule(_localctx, 122, RULE_forStatement); try { enterOuterAlt(_localctx, 1); { setState(980); match(For); setState(981); match(LParen); setState(984); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,100,_ctx) ) { case 1: { setState(982); simpleStatement(); } break; case 2: { setState(983); match(Semicolon); } break; } setState(988); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,101,_ctx) ) { case 1: { setState(986); expressionStatement(); } break; case 2: { setState(987); match(Semicolon); } break; } setState(991); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,102,_ctx) ) { case 1: { setState(990); expression(0); } break; } setState(993); match(RParen); setState(994); statement(); } } 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(SolidityParser.While, 0); } public TerminalNode LParen() { return getToken(SolidityParser.LParen, 0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } public TerminalNode RParen() { return getToken(SolidityParser.RParen, 0); } public StatementContext statement() { return getRuleContext(StatementContext.class,0); } public WhileStatementContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_whileStatement; } } public final WhileStatementContext whileStatement() throws RecognitionException { WhileStatementContext _localctx = new WhileStatementContext(_ctx, getState()); enterRule(_localctx, 124, RULE_whileStatement); try { enterOuterAlt(_localctx, 1); { setState(996); match(While); setState(997); match(LParen); setState(998); expression(0); setState(999); match(RParen); setState(1000); statement(); } } 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(SolidityParser.Do, 0); } public StatementContext statement() { return getRuleContext(StatementContext.class,0); } public TerminalNode While() { return getToken(SolidityParser.While, 0); } public TerminalNode LParen() { return getToken(SolidityParser.LParen, 0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } public TerminalNode RParen() { return getToken(SolidityParser.RParen, 0); } public TerminalNode Semicolon() { return getToken(SolidityParser.Semicolon, 0); } public DoWhileStatementContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_doWhileStatement; } } public final DoWhileStatementContext doWhileStatement() throws RecognitionException { DoWhileStatementContext _localctx = new DoWhileStatementContext(_ctx, getState()); enterRule(_localctx, 126, RULE_doWhileStatement); try { enterOuterAlt(_localctx, 1); { setState(1002); match(Do); setState(1003); statement(); setState(1004); match(While); setState(1005); match(LParen); setState(1006); expression(0); setState(1007); match(RParen); setState(1008); 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 ContinueStatementContext extends ParserRuleContext { public TerminalNode Continue() { return getToken(SolidityParser.Continue, 0); } public TerminalNode Semicolon() { return getToken(SolidityParser.Semicolon, 0); } public ContinueStatementContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_continueStatement; } } public final ContinueStatementContext continueStatement() throws RecognitionException { ContinueStatementContext _localctx = new ContinueStatementContext(_ctx, getState()); enterRule(_localctx, 128, RULE_continueStatement); try { enterOuterAlt(_localctx, 1); { setState(1010); match(Continue); setState(1011); 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 BreakStatementContext extends ParserRuleContext { public TerminalNode Break() { return getToken(SolidityParser.Break, 0); } public TerminalNode Semicolon() { return getToken(SolidityParser.Semicolon, 0); } public BreakStatementContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_breakStatement; } } public final BreakStatementContext breakStatement() throws RecognitionException { BreakStatementContext _localctx = new BreakStatementContext(_ctx, getState()); enterRule(_localctx, 130, RULE_breakStatement); try { enterOuterAlt(_localctx, 1); { setState(1013); match(Break); setState(1014); 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 TryStatementContext extends ParserRuleContext { public ParameterListContext returnParameters; public TerminalNode Try() { return getToken(SolidityParser.Try, 0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } public BlockContext block() { return getRuleContext(BlockContext.class,0); } public TerminalNode Returns() { return getToken(SolidityParser.Returns, 0); } public TerminalNode LParen() { return getToken(SolidityParser.LParen, 0); } public TerminalNode RParen() { return getToken(SolidityParser.RParen, 0); } public List catchClause() { return getRuleContexts(CatchClauseContext.class); } public CatchClauseContext catchClause(int i) { return getRuleContext(CatchClauseContext.class,i); } public ParameterListContext parameterList() { return getRuleContext(ParameterListContext.class,0); } public TryStatementContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_tryStatement; } } public final TryStatementContext tryStatement() throws RecognitionException { TryStatementContext _localctx = new TryStatementContext(_ctx, getState()); enterRule(_localctx, 132, RULE_tryStatement); int _la; try { int _alt; enterOuterAlt(_localctx, 1); { setState(1016); match(Try); setState(1017); expression(0); setState(1023); _errHandler.sync(this); _la = _input.LA(1); if (_la==Returns) { { setState(1018); match(Returns); setState(1019); match(LParen); setState(1020); ((TryStatementContext)_localctx).returnParameters = parameterList(); setState(1021); match(RParen); } } setState(1025); block(); setState(1027); _errHandler.sync(this); _alt = 1; do { switch (_alt) { case 1: { { setState(1026); catchClause(); } } break; default: throw new NoViableAltException(this); } setState(1029); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,104,_ctx); } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class CatchClauseContext extends ParserRuleContext { public ParameterListContext arguments; public TerminalNode Catch() { return getToken(SolidityParser.Catch, 0); } public BlockContext block() { return getRuleContext(BlockContext.class,0); } public TerminalNode LParen() { return getToken(SolidityParser.LParen, 0); } public TerminalNode RParen() { return getToken(SolidityParser.RParen, 0); } public IdentifierContext identifier() { return getRuleContext(IdentifierContext.class,0); } public ParameterListContext parameterList() { return getRuleContext(ParameterListContext.class,0); } public CatchClauseContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_catchClause; } } public final CatchClauseContext catchClause() throws RecognitionException { CatchClauseContext _localctx = new CatchClauseContext(_ctx, getState()); enterRule(_localctx, 134, RULE_catchClause); int _la; try { enterOuterAlt(_localctx, 1); { setState(1031); match(Catch); setState(1039); _errHandler.sync(this); _la = _input.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 36028799705415680L) != 0) || _la==LParen || _la==Identifier) { { setState(1033); _errHandler.sync(this); _la = _input.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 36028799705415680L) != 0) || _la==Identifier) { { setState(1032); identifier(); } } setState(1035); match(LParen); { setState(1036); ((CatchClauseContext)_localctx).arguments = parameterList(); } setState(1037); match(RParen); } } setState(1041); block(); } } 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(SolidityParser.Return, 0); } public TerminalNode Semicolon() { return getToken(SolidityParser.Semicolon, 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; } } public final ReturnStatementContext returnStatement() throws RecognitionException { ReturnStatementContext _localctx = new ReturnStatementContext(_ctx, getState()); enterRule(_localctx, 136, RULE_returnStatement); try { enterOuterAlt(_localctx, 1); { setState(1043); match(Return); setState(1045); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,107,_ctx) ) { case 1: { setState(1044); expression(0); } break; } setState(1047); 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 EmitStatementContext extends ParserRuleContext { public TerminalNode Emit() { return getToken(SolidityParser.Emit, 0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } public CallArgumentListContext callArgumentList() { return getRuleContext(CallArgumentListContext.class,0); } public TerminalNode Semicolon() { return getToken(SolidityParser.Semicolon, 0); } public EmitStatementContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_emitStatement; } } public final EmitStatementContext emitStatement() throws RecognitionException { EmitStatementContext _localctx = new EmitStatementContext(_ctx, getState()); enterRule(_localctx, 138, RULE_emitStatement); try { enterOuterAlt(_localctx, 1); { setState(1049); match(Emit); setState(1050); expression(0); setState(1051); callArgumentList(); setState(1052); 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 RevertStatementContext extends ParserRuleContext { public TerminalNode Revert() { return getToken(SolidityParser.Revert, 0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } public CallArgumentListContext callArgumentList() { return getRuleContext(CallArgumentListContext.class,0); } public TerminalNode Semicolon() { return getToken(SolidityParser.Semicolon, 0); } public RevertStatementContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_revertStatement; } } public final RevertStatementContext revertStatement() throws RecognitionException { RevertStatementContext _localctx = new RevertStatementContext(_ctx, getState()); enterRule(_localctx, 140, RULE_revertStatement); try { enterOuterAlt(_localctx, 1); { setState(1054); match(Revert); setState(1055); expression(0); setState(1056); callArgumentList(); setState(1057); 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 AssemblyStatementContext extends ParserRuleContext { public TerminalNode Assembly() { return getToken(SolidityParser.Assembly, 0); } public TerminalNode AssemblyLBrace() { return getToken(SolidityParser.AssemblyLBrace, 0); } public TerminalNode YulRBrace() { return getToken(SolidityParser.YulRBrace, 0); } public TerminalNode AssemblyDialect() { return getToken(SolidityParser.AssemblyDialect, 0); } public AssemblyFlagsContext assemblyFlags() { return getRuleContext(AssemblyFlagsContext.class,0); } public List yulStatement() { return getRuleContexts(YulStatementContext.class); } public YulStatementContext yulStatement(int i) { return getRuleContext(YulStatementContext.class,i); } public AssemblyStatementContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_assemblyStatement; } } public final AssemblyStatementContext assemblyStatement() throws RecognitionException { AssemblyStatementContext _localctx = new AssemblyStatementContext(_ctx, getState()); enterRule(_localctx, 142, RULE_assemblyStatement); int _la; try { enterOuterAlt(_localctx, 1); { setState(1059); match(Assembly); setState(1061); _errHandler.sync(this); _la = _input.LA(1); if (_la==AssemblyDialect) { { setState(1060); match(AssemblyDialect); } } setState(1064); _errHandler.sync(this); _la = _input.LA(1); if (_la==AssemblyBlockLParen) { { setState(1063); assemblyFlags(); } } setState(1066); match(AssemblyLBrace); setState(1070); _errHandler.sync(this); _la = _input.LA(1); while (((((_la - 143)) & ~0x3f) == 0 && ((1L << (_la - 143)) & 4220901L) != 0)) { { { setState(1067); yulStatement(); } } setState(1072); _errHandler.sync(this); _la = _input.LA(1); } setState(1073); match(YulRBrace); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class AssemblyFlagsContext extends ParserRuleContext { public TerminalNode AssemblyBlockLParen() { return getToken(SolidityParser.AssemblyBlockLParen, 0); } public List AssemblyFlagString() { return getTokens(SolidityParser.AssemblyFlagString); } public TerminalNode AssemblyFlagString(int i) { return getToken(SolidityParser.AssemblyFlagString, i); } public TerminalNode AssemblyBlockRParen() { return getToken(SolidityParser.AssemblyBlockRParen, 0); } public List AssemblyBlockComma() { return getTokens(SolidityParser.AssemblyBlockComma); } public TerminalNode AssemblyBlockComma(int i) { return getToken(SolidityParser.AssemblyBlockComma, i); } public AssemblyFlagsContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_assemblyFlags; } } public final AssemblyFlagsContext assemblyFlags() throws RecognitionException { AssemblyFlagsContext _localctx = new AssemblyFlagsContext(_ctx, getState()); enterRule(_localctx, 144, RULE_assemblyFlags); int _la; try { enterOuterAlt(_localctx, 1); { setState(1075); match(AssemblyBlockLParen); setState(1076); match(AssemblyFlagString); setState(1081); _errHandler.sync(this); _la = _input.LA(1); while (_la==AssemblyBlockComma) { { { setState(1077); match(AssemblyBlockComma); setState(1078); match(AssemblyFlagString); } } setState(1083); _errHandler.sync(this); _la = _input.LA(1); } setState(1084); match(AssemblyBlockRParen); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class VariableDeclarationListContext extends ParserRuleContext { public VariableDeclarationContext variableDeclaration; public List variableDeclarations = new ArrayList(); public List variableDeclaration() { return getRuleContexts(VariableDeclarationContext.class); } public VariableDeclarationContext variableDeclaration(int i) { return getRuleContext(VariableDeclarationContext.class,i); } public List Comma() { return getTokens(SolidityParser.Comma); } public TerminalNode Comma(int i) { return getToken(SolidityParser.Comma, i); } public VariableDeclarationListContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_variableDeclarationList; } } public final VariableDeclarationListContext variableDeclarationList() throws RecognitionException { VariableDeclarationListContext _localctx = new VariableDeclarationListContext(_ctx, getState()); enterRule(_localctx, 146, RULE_variableDeclarationList); int _la; try { enterOuterAlt(_localctx, 1); { setState(1086); ((VariableDeclarationListContext)_localctx).variableDeclaration = variableDeclaration(); ((VariableDeclarationListContext)_localctx).variableDeclarations.add(((VariableDeclarationListContext)_localctx).variableDeclaration); setState(1091); _errHandler.sync(this); _la = _input.LA(1); while (_la==Comma) { { { setState(1087); match(Comma); setState(1088); ((VariableDeclarationListContext)_localctx).variableDeclaration = variableDeclaration(); ((VariableDeclarationListContext)_localctx).variableDeclarations.add(((VariableDeclarationListContext)_localctx).variableDeclaration); } } setState(1093); _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 VariableDeclarationTupleContext extends ParserRuleContext { public VariableDeclarationContext variableDeclaration; public List variableDeclarations = new ArrayList(); public TerminalNode LParen() { return getToken(SolidityParser.LParen, 0); } public TerminalNode RParen() { return getToken(SolidityParser.RParen, 0); } public List variableDeclaration() { return getRuleContexts(VariableDeclarationContext.class); } public VariableDeclarationContext variableDeclaration(int i) { return getRuleContext(VariableDeclarationContext.class,i); } public List Comma() { return getTokens(SolidityParser.Comma); } public TerminalNode Comma(int i) { return getToken(SolidityParser.Comma, i); } public VariableDeclarationTupleContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_variableDeclarationTuple; } } public final VariableDeclarationTupleContext variableDeclarationTuple() throws RecognitionException { VariableDeclarationTupleContext _localctx = new VariableDeclarationTupleContext(_ctx, getState()); enterRule(_localctx, 148, RULE_variableDeclarationTuple); int _la; try { int _alt; enterOuterAlt(_localctx, 1); { setState(1094); match(LParen); { setState(1098); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,113,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { setState(1095); match(Comma); } } } setState(1100); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,113,_ctx); } setState(1101); ((VariableDeclarationTupleContext)_localctx).variableDeclaration = variableDeclaration(); ((VariableDeclarationTupleContext)_localctx).variableDeclarations.add(((VariableDeclarationTupleContext)_localctx).variableDeclaration); } setState(1109); _errHandler.sync(this); _la = _input.LA(1); while (_la==Comma) { { { setState(1103); match(Comma); setState(1105); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,114,_ctx) ) { case 1: { setState(1104); ((VariableDeclarationTupleContext)_localctx).variableDeclaration = variableDeclaration(); ((VariableDeclarationTupleContext)_localctx).variableDeclarations.add(((VariableDeclarationTupleContext)_localctx).variableDeclaration); } break; } } } setState(1111); _errHandler.sync(this); _la = _input.LA(1); } setState(1112); 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 VariableDeclarationStatementContext extends ParserRuleContext { public TerminalNode Semicolon() { return getToken(SolidityParser.Semicolon, 0); } public VariableDeclarationContext variableDeclaration() { return getRuleContext(VariableDeclarationContext.class,0); } public VariableDeclarationTupleContext variableDeclarationTuple() { return getRuleContext(VariableDeclarationTupleContext.class,0); } public TerminalNode Assign() { return getToken(SolidityParser.Assign, 0); } public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } public VariableDeclarationStatementContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_variableDeclarationStatement; } } public final VariableDeclarationStatementContext variableDeclarationStatement() throws RecognitionException { VariableDeclarationStatementContext _localctx = new VariableDeclarationStatementContext(_ctx, getState()); enterRule(_localctx, 150, RULE_variableDeclarationStatement); int _la; try { enterOuterAlt(_localctx, 1); { setState(1123); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,117,_ctx) ) { case 1: { { setState(1114); variableDeclaration(); setState(1117); _errHandler.sync(this); _la = _input.LA(1); if (_la==Assign) { { setState(1115); match(Assign); setState(1116); expression(0); } } } } break; case 2: { { setState(1119); variableDeclarationTuple(); setState(1120); match(Assign); setState(1121); expression(0); } } break; } setState(1125); 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 ExpressionStatementContext extends ParserRuleContext { public ExpressionContext expression() { return getRuleContext(ExpressionContext.class,0); } public TerminalNode Semicolon() { return getToken(SolidityParser.Semicolon, 0); } public ExpressionStatementContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_expressionStatement; } } public final ExpressionStatementContext expressionStatement() throws RecognitionException { ExpressionStatementContext _localctx = new ExpressionStatementContext(_ctx, getState()); enterRule(_localctx, 152, RULE_expressionStatement); try { enterOuterAlt(_localctx, 1); { setState(1127); expression(0); setState(1128); 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 MappingTypeContext extends ParserRuleContext { public MappingKeyTypeContext key; public IdentifierContext name; public TypeNameContext value; public TerminalNode Mapping() { return getToken(SolidityParser.Mapping, 0); } public TerminalNode LParen() { return getToken(SolidityParser.LParen, 0); } public TerminalNode DoubleArrow() { return getToken(SolidityParser.DoubleArrow, 0); } public TerminalNode RParen() { return getToken(SolidityParser.RParen, 0); } public MappingKeyTypeContext mappingKeyType() { return getRuleContext(MappingKeyTypeContext.class,0); } public TypeNameContext typeName() { return getRuleContext(TypeNameContext.class,0); } public List identifier() { return getRuleContexts(IdentifierContext.class); } public IdentifierContext identifier(int i) { return getRuleContext(IdentifierContext.class,i); } public MappingTypeContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_mappingType; } } public final MappingTypeContext mappingType() throws RecognitionException { MappingTypeContext _localctx = new MappingTypeContext(_ctx, getState()); enterRule(_localctx, 154, RULE_mappingType); int _la; try { enterOuterAlt(_localctx, 1); { setState(1130); match(Mapping); setState(1131); match(LParen); setState(1132); ((MappingTypeContext)_localctx).key = mappingKeyType(); setState(1134); _errHandler.sync(this); _la = _input.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 36028799705415680L) != 0) || _la==Identifier) { { setState(1133); ((MappingTypeContext)_localctx).name = identifier(); } } setState(1136); match(DoubleArrow); setState(1137); ((MappingTypeContext)_localctx).value = typeName(0); setState(1139); _errHandler.sync(this); _la = _input.LA(1); if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 36028799705415680L) != 0) || _la==Identifier) { { setState(1138); ((MappingTypeContext)_localctx).name = identifier(); } } setState(1141); 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 MappingKeyTypeContext extends ParserRuleContext { public ElementaryTypeNameContext elementaryTypeName() { return getRuleContext(ElementaryTypeNameContext.class,0); } public IdentifierPathContext identifierPath() { return getRuleContext(IdentifierPathContext.class,0); } public MappingKeyTypeContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_mappingKeyType; } } public final MappingKeyTypeContext mappingKeyType() throws RecognitionException { MappingKeyTypeContext _localctx = new MappingKeyTypeContext(_ctx, getState()); enterRule(_localctx, 156, RULE_mappingKeyType); try { setState(1145); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,120,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { setState(1143); elementaryTypeName(false); } break; case 2: enterOuterAlt(_localctx, 2); { setState(1144); identifierPath(); } break; } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class YulStatementContext extends ParserRuleContext { public YulBlockContext yulBlock() { return getRuleContext(YulBlockContext.class,0); } public YulVariableDeclarationContext yulVariableDeclaration() { return getRuleContext(YulVariableDeclarationContext.class,0); } public YulAssignmentContext yulAssignment() { return getRuleContext(YulAssignmentContext.class,0); } public YulFunctionCallContext yulFunctionCall() { return getRuleContext(YulFunctionCallContext.class,0); } public YulIfStatementContext yulIfStatement() { return getRuleContext(YulIfStatementContext.class,0); } public YulForStatementContext yulForStatement() { return getRuleContext(YulForStatementContext.class,0); } public YulSwitchStatementContext yulSwitchStatement() { return getRuleContext(YulSwitchStatementContext.class,0); } public TerminalNode YulLeave() { return getToken(SolidityParser.YulLeave, 0); } public TerminalNode YulBreak() { return getToken(SolidityParser.YulBreak, 0); } public TerminalNode YulContinue() { return getToken(SolidityParser.YulContinue, 0); } public YulFunctionDefinitionContext yulFunctionDefinition() { return getRuleContext(YulFunctionDefinitionContext.class,0); } public YulStatementContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_yulStatement; } } public final YulStatementContext yulStatement() throws RecognitionException { YulStatementContext _localctx = new YulStatementContext(_ctx, getState()); enterRule(_localctx, 158, RULE_yulStatement); try { setState(1158); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,121,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { setState(1147); yulBlock(); } break; case 2: enterOuterAlt(_localctx, 2); { setState(1148); yulVariableDeclaration(); } break; case 3: enterOuterAlt(_localctx, 3); { setState(1149); yulAssignment(); } break; case 4: enterOuterAlt(_localctx, 4); { setState(1150); yulFunctionCall(); } break; case 5: enterOuterAlt(_localctx, 5); { setState(1151); yulIfStatement(); } break; case 6: enterOuterAlt(_localctx, 6); { setState(1152); yulForStatement(); } break; case 7: enterOuterAlt(_localctx, 7); { setState(1153); yulSwitchStatement(); } break; case 8: enterOuterAlt(_localctx, 8); { setState(1154); match(YulLeave); } break; case 9: enterOuterAlt(_localctx, 9); { setState(1155); match(YulBreak); } break; case 10: enterOuterAlt(_localctx, 10); { setState(1156); match(YulContinue); } break; case 11: enterOuterAlt(_localctx, 11); { setState(1157); yulFunctionDefinition(); } break; } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class YulBlockContext extends ParserRuleContext { public TerminalNode YulLBrace() { return getToken(SolidityParser.YulLBrace, 0); } public TerminalNode YulRBrace() { return getToken(SolidityParser.YulRBrace, 0); } public List yulStatement() { return getRuleContexts(YulStatementContext.class); } public YulStatementContext yulStatement(int i) { return getRuleContext(YulStatementContext.class,i); } public YulBlockContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_yulBlock; } } public final YulBlockContext yulBlock() throws RecognitionException { YulBlockContext _localctx = new YulBlockContext(_ctx, getState()); enterRule(_localctx, 160, RULE_yulBlock); int _la; try { enterOuterAlt(_localctx, 1); { setState(1160); match(YulLBrace); setState(1164); _errHandler.sync(this); _la = _input.LA(1); while (((((_la - 143)) & ~0x3f) == 0 && ((1L << (_la - 143)) & 4220901L) != 0)) { { { setState(1161); yulStatement(); } } setState(1166); _errHandler.sync(this); _la = _input.LA(1); } setState(1167); match(YulRBrace); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class YulVariableDeclarationContext extends ParserRuleContext { public Token YulIdentifier; public List variables = new ArrayList(); public TerminalNode YulLet() { return getToken(SolidityParser.YulLet, 0); } public List YulIdentifier() { return getTokens(SolidityParser.YulIdentifier); } public TerminalNode YulIdentifier(int i) { return getToken(SolidityParser.YulIdentifier, i); } public TerminalNode YulAssign() { return getToken(SolidityParser.YulAssign, 0); } public YulExpressionContext yulExpression() { return getRuleContext(YulExpressionContext.class,0); } public List YulComma() { return getTokens(SolidityParser.YulComma); } public TerminalNode YulComma(int i) { return getToken(SolidityParser.YulComma, i); } public YulFunctionCallContext yulFunctionCall() { return getRuleContext(YulFunctionCallContext.class,0); } public YulVariableDeclarationContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_yulVariableDeclaration; } } public final YulVariableDeclarationContext yulVariableDeclaration() throws RecognitionException { YulVariableDeclarationContext _localctx = new YulVariableDeclarationContext(_ctx, getState()); enterRule(_localctx, 162, RULE_yulVariableDeclaration); int _la; try { setState(1188); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { { setState(1169); match(YulLet); setState(1170); ((YulVariableDeclarationContext)_localctx).YulIdentifier = match(YulIdentifier); ((YulVariableDeclarationContext)_localctx).variables.add(((YulVariableDeclarationContext)_localctx).YulIdentifier); setState(1173); _errHandler.sync(this); _la = _input.LA(1); if (_la==YulAssign) { { setState(1171); match(YulAssign); setState(1172); yulExpression(); } } } } break; case 2: enterOuterAlt(_localctx, 2); { { setState(1175); match(YulLet); setState(1176); ((YulVariableDeclarationContext)_localctx).YulIdentifier = match(YulIdentifier); ((YulVariableDeclarationContext)_localctx).variables.add(((YulVariableDeclarationContext)_localctx).YulIdentifier); setState(1181); _errHandler.sync(this); _la = _input.LA(1); while (_la==YulComma) { { { setState(1177); match(YulComma); setState(1178); ((YulVariableDeclarationContext)_localctx).YulIdentifier = match(YulIdentifier); ((YulVariableDeclarationContext)_localctx).variables.add(((YulVariableDeclarationContext)_localctx).YulIdentifier); } } setState(1183); _errHandler.sync(this); _la = _input.LA(1); } setState(1186); _errHandler.sync(this); _la = _input.LA(1); if (_la==YulAssign) { { setState(1184); match(YulAssign); setState(1185); yulFunctionCall(); } } } } break; } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class YulAssignmentContext extends ParserRuleContext { public List yulPath() { return getRuleContexts(YulPathContext.class); } public YulPathContext yulPath(int i) { return getRuleContext(YulPathContext.class,i); } public TerminalNode YulAssign() { return getToken(SolidityParser.YulAssign, 0); } public YulExpressionContext yulExpression() { return getRuleContext(YulExpressionContext.class,0); } public YulFunctionCallContext yulFunctionCall() { return getRuleContext(YulFunctionCallContext.class,0); } public List YulComma() { return getTokens(SolidityParser.YulComma); } public TerminalNode YulComma(int i) { return getToken(SolidityParser.YulComma, i); } public YulAssignmentContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_yulAssignment; } } public final YulAssignmentContext yulAssignment() throws RecognitionException { YulAssignmentContext _localctx = new YulAssignmentContext(_ctx, getState()); enterRule(_localctx, 164, RULE_yulAssignment); int _la; try { setState(1204); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,128,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { setState(1190); yulPath(); setState(1191); match(YulAssign); setState(1192); yulExpression(); } break; case 2: enterOuterAlt(_localctx, 2); { { setState(1194); yulPath(); setState(1197); _errHandler.sync(this); _la = _input.LA(1); do { { { setState(1195); match(YulComma); setState(1196); yulPath(); } } setState(1199); _errHandler.sync(this); _la = _input.LA(1); } while ( _la==YulComma ); } setState(1201); match(YulAssign); setState(1202); yulFunctionCall(); } break; } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class YulIfStatementContext extends ParserRuleContext { public YulExpressionContext cond; public YulBlockContext body; public TerminalNode YulIf() { return getToken(SolidityParser.YulIf, 0); } public YulExpressionContext yulExpression() { return getRuleContext(YulExpressionContext.class,0); } public YulBlockContext yulBlock() { return getRuleContext(YulBlockContext.class,0); } public YulIfStatementContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_yulIfStatement; } } public final YulIfStatementContext yulIfStatement() throws RecognitionException { YulIfStatementContext _localctx = new YulIfStatementContext(_ctx, getState()); enterRule(_localctx, 166, RULE_yulIfStatement); try { enterOuterAlt(_localctx, 1); { setState(1206); match(YulIf); setState(1207); ((YulIfStatementContext)_localctx).cond = yulExpression(); setState(1208); ((YulIfStatementContext)_localctx).body = yulBlock(); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class YulForStatementContext extends ParserRuleContext { public YulBlockContext init; public YulExpressionContext cond; public YulBlockContext post; public YulBlockContext body; public TerminalNode YulFor() { return getToken(SolidityParser.YulFor, 0); } public List yulBlock() { return getRuleContexts(YulBlockContext.class); } public YulBlockContext yulBlock(int i) { return getRuleContext(YulBlockContext.class,i); } public YulExpressionContext yulExpression() { return getRuleContext(YulExpressionContext.class,0); } public YulForStatementContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_yulForStatement; } } public final YulForStatementContext yulForStatement() throws RecognitionException { YulForStatementContext _localctx = new YulForStatementContext(_ctx, getState()); enterRule(_localctx, 168, RULE_yulForStatement); try { enterOuterAlt(_localctx, 1); { setState(1210); match(YulFor); setState(1211); ((YulForStatementContext)_localctx).init = yulBlock(); setState(1212); ((YulForStatementContext)_localctx).cond = yulExpression(); setState(1213); ((YulForStatementContext)_localctx).post = yulBlock(); setState(1214); ((YulForStatementContext)_localctx).body = yulBlock(); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class YulSwitchCaseContext extends ParserRuleContext { public TerminalNode YulCase() { return getToken(SolidityParser.YulCase, 0); } public YulLiteralContext yulLiteral() { return getRuleContext(YulLiteralContext.class,0); } public YulBlockContext yulBlock() { return getRuleContext(YulBlockContext.class,0); } public YulSwitchCaseContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_yulSwitchCase; } } public final YulSwitchCaseContext yulSwitchCase() throws RecognitionException { YulSwitchCaseContext _localctx = new YulSwitchCaseContext(_ctx, getState()); enterRule(_localctx, 170, RULE_yulSwitchCase); try { enterOuterAlt(_localctx, 1); { setState(1216); match(YulCase); setState(1217); yulLiteral(); setState(1218); yulBlock(); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class YulSwitchStatementContext extends ParserRuleContext { public TerminalNode YulSwitch() { return getToken(SolidityParser.YulSwitch, 0); } public YulExpressionContext yulExpression() { return getRuleContext(YulExpressionContext.class,0); } public TerminalNode YulDefault() { return getToken(SolidityParser.YulDefault, 0); } public YulBlockContext yulBlock() { return getRuleContext(YulBlockContext.class,0); } public List yulSwitchCase() { return getRuleContexts(YulSwitchCaseContext.class); } public YulSwitchCaseContext yulSwitchCase(int i) { return getRuleContext(YulSwitchCaseContext.class,i); } public YulSwitchStatementContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_yulSwitchStatement; } } public final YulSwitchStatementContext yulSwitchStatement() throws RecognitionException { YulSwitchStatementContext _localctx = new YulSwitchStatementContext(_ctx, getState()); enterRule(_localctx, 172, RULE_yulSwitchStatement); int _la; try { enterOuterAlt(_localctx, 1); { setState(1220); match(YulSwitch); setState(1221); yulExpression(); setState(1233); _errHandler.sync(this); switch (_input.LA(1)) { case YulCase: { { setState(1223); _errHandler.sync(this); _la = _input.LA(1); do { { { setState(1222); yulSwitchCase(); } } setState(1225); _errHandler.sync(this); _la = _input.LA(1); } while ( _la==YulCase ); setState(1229); _errHandler.sync(this); _la = _input.LA(1); if (_la==YulDefault) { { setState(1227); match(YulDefault); setState(1228); yulBlock(); } } } } break; case YulDefault: { { setState(1231); match(YulDefault); setState(1232); yulBlock(); } } 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 YulFunctionDefinitionContext extends ParserRuleContext { public Token YulIdentifier; public List arguments = new ArrayList(); public List returnParameters = new ArrayList(); public YulBlockContext body; public TerminalNode YulFunction() { return getToken(SolidityParser.YulFunction, 0); } public List YulIdentifier() { return getTokens(SolidityParser.YulIdentifier); } public TerminalNode YulIdentifier(int i) { return getToken(SolidityParser.YulIdentifier, i); } public TerminalNode YulLParen() { return getToken(SolidityParser.YulLParen, 0); } public TerminalNode YulRParen() { return getToken(SolidityParser.YulRParen, 0); } public YulBlockContext yulBlock() { return getRuleContext(YulBlockContext.class,0); } public TerminalNode YulArrow() { return getToken(SolidityParser.YulArrow, 0); } public List YulComma() { return getTokens(SolidityParser.YulComma); } public TerminalNode YulComma(int i) { return getToken(SolidityParser.YulComma, i); } public YulFunctionDefinitionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_yulFunctionDefinition; } } public final YulFunctionDefinitionContext yulFunctionDefinition() throws RecognitionException { YulFunctionDefinitionContext _localctx = new YulFunctionDefinitionContext(_ctx, getState()); enterRule(_localctx, 174, RULE_yulFunctionDefinition); int _la; try { enterOuterAlt(_localctx, 1); { setState(1235); match(YulFunction); setState(1236); match(YulIdentifier); setState(1237); match(YulLParen); setState(1246); _errHandler.sync(this); _la = _input.LA(1); if (_la==YulIdentifier) { { setState(1238); ((YulFunctionDefinitionContext)_localctx).YulIdentifier = match(YulIdentifier); ((YulFunctionDefinitionContext)_localctx).arguments.add(((YulFunctionDefinitionContext)_localctx).YulIdentifier); setState(1243); _errHandler.sync(this); _la = _input.LA(1); while (_la==YulComma) { { { setState(1239); match(YulComma); setState(1240); ((YulFunctionDefinitionContext)_localctx).YulIdentifier = match(YulIdentifier); ((YulFunctionDefinitionContext)_localctx).arguments.add(((YulFunctionDefinitionContext)_localctx).YulIdentifier); } } setState(1245); _errHandler.sync(this); _la = _input.LA(1); } } } setState(1248); match(YulRParen); setState(1258); _errHandler.sync(this); _la = _input.LA(1); if (_la==YulArrow) { { setState(1249); match(YulArrow); setState(1250); ((YulFunctionDefinitionContext)_localctx).YulIdentifier = match(YulIdentifier); ((YulFunctionDefinitionContext)_localctx).returnParameters.add(((YulFunctionDefinitionContext)_localctx).YulIdentifier); setState(1255); _errHandler.sync(this); _la = _input.LA(1); while (_la==YulComma) { { { setState(1251); match(YulComma); setState(1252); ((YulFunctionDefinitionContext)_localctx).YulIdentifier = match(YulIdentifier); ((YulFunctionDefinitionContext)_localctx).returnParameters.add(((YulFunctionDefinitionContext)_localctx).YulIdentifier); } } setState(1257); _errHandler.sync(this); _la = _input.LA(1); } } } setState(1260); ((YulFunctionDefinitionContext)_localctx).body = yulBlock(); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class YulPathContext extends ParserRuleContext { public List YulIdentifier() { return getTokens(SolidityParser.YulIdentifier); } public TerminalNode YulIdentifier(int i) { return getToken(SolidityParser.YulIdentifier, i); } public List YulPeriod() { return getTokens(SolidityParser.YulPeriod); } public TerminalNode YulPeriod(int i) { return getToken(SolidityParser.YulPeriod, i); } public List YulEVMBuiltin() { return getTokens(SolidityParser.YulEVMBuiltin); } public TerminalNode YulEVMBuiltin(int i) { return getToken(SolidityParser.YulEVMBuiltin, i); } public YulPathContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_yulPath; } } public final YulPathContext yulPath() throws RecognitionException { YulPathContext _localctx = new YulPathContext(_ctx, getState()); enterRule(_localctx, 176, RULE_yulPath); int _la; try { enterOuterAlt(_localctx, 1); { setState(1262); match(YulIdentifier); setState(1267); _errHandler.sync(this); _la = _input.LA(1); while (_la==YulPeriod) { { { setState(1263); match(YulPeriod); setState(1264); _la = _input.LA(1); if ( !(_la==YulEVMBuiltin || _la==YulIdentifier) ) { _errHandler.recoverInline(this); } else { if ( _input.LA(1)==Token.EOF ) matchedEOF = true; _errHandler.reportMatch(this); consume(); } } } setState(1269); _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 YulFunctionCallContext extends ParserRuleContext { public TerminalNode YulLParen() { return getToken(SolidityParser.YulLParen, 0); } public TerminalNode YulRParen() { return getToken(SolidityParser.YulRParen, 0); } public TerminalNode YulIdentifier() { return getToken(SolidityParser.YulIdentifier, 0); } public TerminalNode YulEVMBuiltin() { return getToken(SolidityParser.YulEVMBuiltin, 0); } public List yulExpression() { return getRuleContexts(YulExpressionContext.class); } public YulExpressionContext yulExpression(int i) { return getRuleContext(YulExpressionContext.class,i); } public List YulComma() { return getTokens(SolidityParser.YulComma); } public TerminalNode YulComma(int i) { return getToken(SolidityParser.YulComma, i); } public YulFunctionCallContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_yulFunctionCall; } } public final YulFunctionCallContext yulFunctionCall() throws RecognitionException { YulFunctionCallContext _localctx = new YulFunctionCallContext(_ctx, getState()); enterRule(_localctx, 178, RULE_yulFunctionCall); int _la; try { enterOuterAlt(_localctx, 1); { setState(1270); _la = _input.LA(1); if ( !(_la==YulEVMBuiltin || _la==YulIdentifier) ) { _errHandler.recoverInline(this); } else { if ( _input.LA(1)==Token.EOF ) matchedEOF = true; _errHandler.reportMatch(this); consume(); } setState(1271); match(YulLParen); setState(1280); _errHandler.sync(this); _la = _input.LA(1); if (((((_la - 147)) & ~0x3f) == 0 && ((1L << (_la - 147)) & 8127105L) != 0)) { { setState(1272); yulExpression(); setState(1277); _errHandler.sync(this); _la = _input.LA(1); while (_la==YulComma) { { { setState(1273); match(YulComma); setState(1274); yulExpression(); } } setState(1279); _errHandler.sync(this); _la = _input.LA(1); } } } setState(1282); match(YulRParen); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.reportError(this, re); _errHandler.recover(this, re); } finally { exitRule(); } return _localctx; } @SuppressWarnings("CheckReturnValue") public static class YulBooleanContext extends ParserRuleContext { public TerminalNode YulTrue() { return getToken(SolidityParser.YulTrue, 0); } public TerminalNode YulFalse() { return getToken(SolidityParser.YulFalse, 0); } public YulBooleanContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_yulBoolean; } } public final YulBooleanContext yulBoolean() throws RecognitionException { YulBooleanContext _localctx = new YulBooleanContext(_ctx, getState()); enterRule(_localctx, 180, RULE_yulBoolean); int _la; try { enterOuterAlt(_localctx, 1); { setState(1284); _la = _input.LA(1); if ( !(_la==YulFalse || _la==YulTrue) ) { _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 YulLiteralContext extends ParserRuleContext { public TerminalNode YulDecimalNumber() { return getToken(SolidityParser.YulDecimalNumber, 0); } public TerminalNode YulStringLiteral() { return getToken(SolidityParser.YulStringLiteral, 0); } public TerminalNode YulHexNumber() { return getToken(SolidityParser.YulHexNumber, 0); } public YulBooleanContext yulBoolean() { return getRuleContext(YulBooleanContext.class,0); } public TerminalNode YulHexStringLiteral() { return getToken(SolidityParser.YulHexStringLiteral, 0); } public YulLiteralContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_yulLiteral; } } public final YulLiteralContext yulLiteral() throws RecognitionException { YulLiteralContext _localctx = new YulLiteralContext(_ctx, getState()); enterRule(_localctx, 182, RULE_yulLiteral); try { setState(1291); _errHandler.sync(this); switch (_input.LA(1)) { case YulDecimalNumber: enterOuterAlt(_localctx, 1); { setState(1286); match(YulDecimalNumber); } break; case YulStringLiteral: enterOuterAlt(_localctx, 2); { setState(1287); match(YulStringLiteral); } break; case YulHexNumber: enterOuterAlt(_localctx, 3); { setState(1288); match(YulHexNumber); } break; case YulFalse: case YulTrue: enterOuterAlt(_localctx, 4); { setState(1289); yulBoolean(); } break; case YulHexStringLiteral: enterOuterAlt(_localctx, 5); { setState(1290); match(YulHexStringLiteral); } 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 YulExpressionContext extends ParserRuleContext { public YulPathContext yulPath() { return getRuleContext(YulPathContext.class,0); } public YulFunctionCallContext yulFunctionCall() { return getRuleContext(YulFunctionCallContext.class,0); } public YulLiteralContext yulLiteral() { return getRuleContext(YulLiteralContext.class,0); } public YulExpressionContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } @Override public int getRuleIndex() { return RULE_yulExpression; } } public final YulExpressionContext yulExpression() throws RecognitionException { YulExpressionContext _localctx = new YulExpressionContext(_ctx, getState()); enterRule(_localctx, 184, RULE_yulExpression); try { setState(1296); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,140,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { setState(1293); yulPath(); } break; case 2: enterOuterAlt(_localctx, 2); { setState(1294); yulFunctionCall(); } break; case 3: enterOuterAlt(_localctx, 3); { setState(1295); yulLiteral(); } break; } } 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 19: return constructorDefinition_sempred((ConstructorDefinitionContext)_localctx, predIndex); case 22: return functionDefinition_sempred((FunctionDefinitionContext)_localctx, predIndex); case 23: return modifierDefinition_sempred((ModifierDefinitionContext)_localctx, predIndex); case 24: return fallbackFunctionDefinition_sempred((FallbackFunctionDefinitionContext)_localctx, predIndex); case 25: return receiveFunctionDefinition_sempred((ReceiveFunctionDefinitionContext)_localctx, predIndex); case 30: return stateVariableDeclaration_sempred((StateVariableDeclarationContext)_localctx, predIndex); case 39: return typeName_sempred((TypeNameContext)_localctx, predIndex); case 40: return elementaryTypeName_sempred((ElementaryTypeNameContext)_localctx, predIndex); case 41: return functionTypeName_sempred((FunctionTypeNameContext)_localctx, predIndex); case 44: return expression_sempred((ExpressionContext)_localctx, predIndex); } return true; } private boolean constructorDefinition_sempred(ConstructorDefinitionContext _localctx, int predIndex) { switch (predIndex) { case 0: return !_localctx.payableSet; case 1: return !_localctx.visibilitySet; case 2: return !_localctx.visibilitySet; } return true; } private boolean functionDefinition_sempred(FunctionDefinitionContext _localctx, int predIndex) { switch (predIndex) { case 3: return !_localctx.visibilitySet; case 4: return !_localctx.mutabilitySet; case 5: return !_localctx.virtualSet; case 6: return !_localctx.overrideSpecifierSet; } return true; } private boolean modifierDefinition_sempred(ModifierDefinitionContext _localctx, int predIndex) { switch (predIndex) { case 7: return !_localctx.virtualSet; case 8: return !_localctx.overrideSpecifierSet; } return true; } private boolean fallbackFunctionDefinition_sempred(FallbackFunctionDefinitionContext _localctx, int predIndex) { switch (predIndex) { case 9: return !_localctx.visibilitySet; case 10: return !_localctx.mutabilitySet; case 11: return !_localctx.virtualSet; case 12: return !_localctx.overrideSpecifierSet; case 13: return _localctx.hasParameters; case 14: return !_localctx.hasParameters; } return true; } private boolean receiveFunctionDefinition_sempred(ReceiveFunctionDefinitionContext _localctx, int predIndex) { switch (predIndex) { case 15: return !_localctx.visibilitySet; case 16: return !_localctx.mutabilitySet; case 17: return !_localctx.virtualSet; case 18: return !_localctx.overrideSpecifierSet; } return true; } private boolean stateVariableDeclaration_sempred(StateVariableDeclarationContext _localctx, int predIndex) { switch (predIndex) { case 19: return !_localctx.visibilitySet; case 20: return !_localctx.visibilitySet; case 21: return !_localctx.visibilitySet; case 22: return !_localctx.constantnessSet; case 23: return !_localctx.overrideSpecifierSet; case 24: return !_localctx.constantnessSet; } return true; } private boolean typeName_sempred(TypeNameContext _localctx, int predIndex) { switch (predIndex) { case 25: return precpred(_ctx, 1); } return true; } private boolean elementaryTypeName_sempred(ElementaryTypeNameContext _localctx, int predIndex) { switch (predIndex) { case 26: return _localctx.allowAddressPayable; } return true; } private boolean functionTypeName_sempred(FunctionTypeNameContext _localctx, int predIndex) { switch (predIndex) { case 27: return !_localctx.visibilitySet; case 28: return !_localctx.mutabilitySet; } return true; } private boolean expression_sempred(ExpressionContext _localctx, int predIndex) { switch (predIndex) { case 29: return precpred(_ctx, 17); case 30: return precpred(_ctx, 16); case 31: return precpred(_ctx, 15); case 32: return precpred(_ctx, 14); case 33: return precpred(_ctx, 13); case 34: return precpred(_ctx, 12); case 35: return precpred(_ctx, 11); case 36: return precpred(_ctx, 10); case 37: return precpred(_ctx, 9); case 38: return precpred(_ctx, 8); case 39: return precpred(_ctx, 7); case 40: return precpred(_ctx, 6); case 41: return precpred(_ctx, 5); case 42: return precpred(_ctx, 26); case 43: return precpred(_ctx, 25); case 44: return precpred(_ctx, 24); case 45: return precpred(_ctx, 23); case 46: return precpred(_ctx, 22); case 47: return precpred(_ctx, 18); } return true; } public static final String _serializedATN = "\u0004\u0001\u00b1\u0513\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\\\u0001\u0000\u0001\u0000"+ "\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0000"+ "\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0000\u0005\u0000"+ "\u00c8\b\u0000\n\u0000\f\u0000\u00cb\t\u0000\u0001\u0000\u0001\u0000\u0001"+ "\u0001\u0001\u0001\u0004\u0001\u00d1\b\u0001\u000b\u0001\f\u0001\u00d2"+ "\u0001\u0001\u0001\u0001\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002"+ "\u0003\u0002\u00db\b\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002"+ "\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002"+ "\u0003\u0002\u00e7\b\u0002\u0001\u0002\u0001\u0002\u0001\u0003\u0001\u0003"+ "\u0001\u0003\u0003\u0003\u00ee\b\u0003\u0001\u0004\u0001\u0004\u0001\u0005"+ "\u0001\u0005\u0001\u0005\u0001\u0005\u0005\u0005\u00f6\b\u0005\n\u0005"+ "\f\u0005\u00f9\t\u0005\u0001\u0005\u0001\u0005\u0001\u0006\u0003\u0006"+ "\u00fe\b\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0003\u0006\u0103\b"+ "\u0006\u0001\u0006\u0001\u0006\u0005\u0006\u0107\b\u0006\n\u0006\f\u0006"+ "\u010a\t\u0006\u0001\u0006\u0001\u0006\u0001\u0007\u0001\u0007\u0001\u0007"+ "\u0003\u0007\u0111\b\u0007\u0001\u0007\u0001\u0007\u0005\u0007\u0115\b"+ "\u0007\n\u0007\f\u0007\u0118\t\u0007\u0001\u0007\u0001\u0007\u0001\b\u0001"+ "\b\u0001\b\u0001\b\u0005\b\u0120\b\b\n\b\f\b\u0123\t\b\u0001\b\u0001\b"+ "\u0001\t\u0001\t\u0001\t\u0001\t\u0005\t\u012b\b\t\n\t\f\t\u012e\t\t\u0001"+ "\n\u0001\n\u0003\n\u0132\b\n\u0001\u000b\u0001\u000b\u0001\u000b\u0001"+ "\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001"+ "\u000b\u0001\u000b\u0001\u000b\u0003\u000b\u0140\b\u000b\u0001\f\u0001"+ "\f\u0001\f\u0001\f\u0001\r\u0001\r\u0001\r\u0001\r\u0005\r\u014a\b\r\n"+ "\r\f\r\u014d\t\r\u0003\r\u014f\b\r\u0001\r\u0001\r\u0001\r\u0001\r\u0005"+ "\r\u0155\b\r\n\r\f\r\u0158\t\r\u0003\r\u015a\b\r\u0001\r\u0003\r\u015d"+ "\b\r\u0001\r\u0001\r\u0001\u000e\u0001\u000e\u0001\u000e\u0005\u000e\u0164"+ "\b\u000e\n\u000e\f\u000e\u0167\t\u000e\u0001\u000f\u0001\u000f\u0003\u000f"+ "\u016b\b\u000f\u0001\u0010\u0001\u0010\u0001\u0011\u0001\u0011\u0001\u0011"+ "\u0005\u0011\u0172\b\u0011\n\u0011\f\u0011\u0175\t\u0011\u0001\u0012\u0001"+ "\u0012\u0003\u0012\u0179\b\u0012\u0001\u0012\u0003\u0012\u017c\b\u0012"+ "\u0001\u0013\u0001\u0013\u0001\u0013\u0003\u0013\u0181\b\u0013\u0001\u0013"+ "\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013"+ "\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0005\u0013\u018e\b\u0013"+ "\n\u0013\f\u0013\u0191\t\u0013\u0001\u0013\u0001\u0013\u0001\u0014\u0001"+ "\u0014\u0001\u0015\u0001\u0015\u0001\u0015\u0001\u0015\u0001\u0015\u0005"+ "\u0015\u019c\b\u0015\n\u0015\f\u0015\u019f\t\u0015\u0001\u0015\u0001\u0015"+ "\u0003\u0015\u01a3\b\u0015\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016"+ "\u0003\u0016\u01a9\b\u0016\u0001\u0016\u0001\u0016\u0003\u0016\u01ad\b"+ "\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001"+ "\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001"+ "\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0005"+ "\u0016\u01c0\b\u0016\n\u0016\f\u0016\u01c3\t\u0016\u0001\u0016\u0001\u0016"+ "\u0001\u0016\u0001\u0016\u0001\u0016\u0003\u0016\u01ca\b\u0016\u0001\u0016"+ "\u0001\u0016\u0003\u0016\u01ce\b\u0016\u0001\u0017\u0001\u0017\u0001\u0017"+ "\u0001\u0017\u0003\u0017\u01d4\b\u0017\u0001\u0017\u0003\u0017\u01d7\b"+ "\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001"+ "\u0017\u0001\u0017\u0005\u0017\u01e0\b\u0017\n\u0017\f\u0017\u01e3\t\u0017"+ "\u0001\u0017\u0001\u0017\u0003\u0017\u01e7\b\u0017\u0001\u0018\u0001\u0018"+ "\u0001\u0018\u0001\u0018\u0001\u0018\u0003\u0018\u01ee\b\u0018\u0001\u0018"+ "\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+ "\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+ "\u0001\u0018\u0001\u0018\u0001\u0018\u0005\u0018\u0200\b\u0018\n\u0018"+ "\f\u0018\u0203\t\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+ "\u0001\u0018\u0001\u0018\u0001\u0018\u0003\u0018\u020c\b\u0018\u0001\u0018"+ "\u0001\u0018\u0003\u0018\u0210\b\u0018\u0001\u0019\u0001\u0019\u0001\u0019"+ "\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+ "\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019"+ "\u0001\u0019\u0001\u0019\u0005\u0019\u0223\b\u0019\n\u0019\f\u0019\u0226"+ "\t\u0019\u0001\u0019\u0001\u0019\u0003\u0019\u022a\b\u0019\u0001\u001a"+ "\u0001\u001a\u0001\u001a\u0001\u001a\u0004\u001a\u0230\b\u001a\u000b\u001a"+ "\f\u001a\u0231\u0001\u001a\u0001\u001a\u0001\u001b\u0001\u001b\u0001\u001b"+ "\u0001\u001b\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c"+ "\u0001\u001c\u0005\u001c\u0240\b\u001c\n\u001c\f\u001c\u0243\t\u001c\u0001"+ "\u001c\u0001\u001c\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001"+ "\u001d\u0001\u001d\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001"+ "\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001"+ "\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001"+ "\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0005\u001e\u0261\b\u001e\n"+ "\u001e\f\u001e\u0264\t\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0003"+ "\u001e\u0269\b\u001e\u0001\u001e\u0001\u001e\u0001\u001f\u0001\u001f\u0001"+ "\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0001 \u0001 \u0003"+ " \u0276\b \u0001 \u0003 \u0279\b \u0001!\u0001!\u0001!\u0001!\u0001!\u0001"+ "!\u0005!\u0281\b!\n!\f!\u0284\t!\u0003!\u0286\b!\u0001!\u0001!\u0003!"+ "\u028a\b!\u0001!\u0001!\u0001\"\u0001\"\u0003\"\u0290\b\"\u0001#\u0001"+ "#\u0001#\u0001#\u0001#\u0001#\u0005#\u0298\b#\n#\f#\u029b\t#\u0003#\u029d"+ "\b#\u0001#\u0001#\u0001#\u0001$\u0001$\u0001%\u0001%\u0001%\u0001%\u0001"+ "%\u0001%\u0005%\u02aa\b%\n%\f%\u02ad\t%\u0001%\u0001%\u0003%\u02b1\b%"+ "\u0001%\u0001%\u0001%\u0003%\u02b6\b%\u0001%\u0003%\u02b9\b%\u0001%\u0001"+ "%\u0001&\u0001&\u0001&\u0003&\u02c0\b&\u0001\'\u0001\'\u0001\'\u0001\'"+ "\u0001\'\u0003\'\u02c7\b\'\u0001\'\u0001\'\u0001\'\u0003\'\u02cc\b\'\u0001"+ "\'\u0005\'\u02cf\b\'\n\'\f\'\u02d2\t\'\u0001(\u0001(\u0001(\u0001(\u0001"+ "(\u0001(\u0001(\u0001(\u0001(\u0001(\u0001(\u0001(\u0003(\u02e0\b(\u0001"+ ")\u0001)\u0001)\u0003)\u02e5\b)\u0001)\u0001)\u0001)\u0001)\u0001)\u0001"+ ")\u0001)\u0001)\u0001)\u0005)\u02f0\b)\n)\f)\u02f3\t)\u0001)\u0001)\u0001"+ ")\u0001)\u0001)\u0003)\u02fa\b)\u0001*\u0001*\u0003*\u02fe\b*\u0001*\u0001"+ "*\u0001+\u0001+\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001"+ ",\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001"+ ",\u0003,\u0316\b,\u0003,\u0318\b,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001"+ ",\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001"+ ",\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001"+ ",\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001"+ ",\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001"+ ",\u0003,\u0348\b,\u0001,\u0001,\u0001,\u0001,\u0003,\u034e\b,\u0001,\u0001"+ ",\u0003,\u0352\b,\u0001,\u0001,\u0001,\u0001,\u0001,\u0003,\u0359\b,\u0001"+ ",\u0001,\u0001,\u0001,\u0001,\u0005,\u0360\b,\n,\f,\u0363\t,\u0003,\u0365"+ "\b,\u0001,\u0001,\u0001,\u0001,\u0001,\u0005,\u036c\b,\n,\f,\u036f\t,"+ "\u0001-\u0001-\u0001.\u0001.\u0003.\u0375\b.\u0001.\u0001.\u0003.\u0379"+ "\b.\u0005.\u037b\b.\n.\f.\u037e\t.\u0001.\u0001.\u0001/\u0001/\u0001/"+ "\u0001/\u0005/\u0386\b/\n/\f/\u0389\t/\u0001/\u0001/\u00010\u00010\u0001"+ "1\u00011\u00011\u00011\u00011\u00031\u0394\b1\u00012\u00012\u00012\u0001"+ "3\u00013\u00014\u00044\u039c\b4\u000b4\f4\u039d\u00015\u00045\u03a1\b"+ "5\u000b5\f5\u03a2\u00016\u00046\u03a6\b6\u000b6\f6\u03a7\u00017\u0001"+ "7\u00018\u00018\u00018\u00058\u03af\b8\n8\f8\u03b2\t8\u00018\u00018\u0001"+ "9\u00019\u00019\u0001:\u0001:\u0001:\u0001:\u0001:\u0001:\u0001:\u0001"+ ":\u0001:\u0001:\u0001:\u0001:\u0001:\u0003:\u03c6\b:\u0001;\u0001;\u0003"+ ";\u03ca\b;\u0001<\u0001<\u0001<\u0001<\u0001<\u0001<\u0001<\u0003<\u03d3"+ "\b<\u0001=\u0001=\u0001=\u0001=\u0003=\u03d9\b=\u0001=\u0001=\u0003=\u03dd"+ "\b=\u0001=\u0003=\u03e0\b=\u0001=\u0001=\u0001=\u0001>\u0001>\u0001>\u0001"+ ">\u0001>\u0001>\u0001?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001"+ "?\u0001@\u0001@\u0001@\u0001A\u0001A\u0001A\u0001B\u0001B\u0001B\u0001"+ "B\u0001B\u0001B\u0001B\u0003B\u0400\bB\u0001B\u0001B\u0004B\u0404\bB\u000b"+ "B\fB\u0405\u0001C\u0001C\u0003C\u040a\bC\u0001C\u0001C\u0001C\u0001C\u0003"+ "C\u0410\bC\u0001C\u0001C\u0001D\u0001D\u0003D\u0416\bD\u0001D\u0001D\u0001"+ "E\u0001E\u0001E\u0001E\u0001E\u0001F\u0001F\u0001F\u0001F\u0001F\u0001"+ "G\u0001G\u0003G\u0426\bG\u0001G\u0003G\u0429\bG\u0001G\u0001G\u0005G\u042d"+ "\bG\nG\fG\u0430\tG\u0001G\u0001G\u0001H\u0001H\u0001H\u0001H\u0005H\u0438"+ "\bH\nH\fH\u043b\tH\u0001H\u0001H\u0001I\u0001I\u0001I\u0005I\u0442\bI"+ "\nI\fI\u0445\tI\u0001J\u0001J\u0005J\u0449\bJ\nJ\fJ\u044c\tJ\u0001J\u0001"+ "J\u0001J\u0001J\u0003J\u0452\bJ\u0005J\u0454\bJ\nJ\fJ\u0457\tJ\u0001J"+ "\u0001J\u0001K\u0001K\u0001K\u0003K\u045e\bK\u0001K\u0001K\u0001K\u0001"+ "K\u0003K\u0464\bK\u0001K\u0001K\u0001L\u0001L\u0001L\u0001M\u0001M\u0001"+ "M\u0001M\u0003M\u046f\bM\u0001M\u0001M\u0001M\u0003M\u0474\bM\u0001M\u0001"+ "M\u0001N\u0001N\u0003N\u047a\bN\u0001O\u0001O\u0001O\u0001O\u0001O\u0001"+ "O\u0001O\u0001O\u0001O\u0001O\u0001O\u0003O\u0487\bO\u0001P\u0001P\u0005"+ "P\u048b\bP\nP\fP\u048e\tP\u0001P\u0001P\u0001Q\u0001Q\u0001Q\u0001Q\u0003"+ "Q\u0496\bQ\u0001Q\u0001Q\u0001Q\u0001Q\u0005Q\u049c\bQ\nQ\fQ\u049f\tQ"+ "\u0001Q\u0001Q\u0003Q\u04a3\bQ\u0003Q\u04a5\bQ\u0001R\u0001R\u0001R\u0001"+ "R\u0001R\u0001R\u0001R\u0004R\u04ae\bR\u000bR\fR\u04af\u0001R\u0001R\u0001"+ "R\u0003R\u04b5\bR\u0001S\u0001S\u0001S\u0001S\u0001T\u0001T\u0001T\u0001"+ "T\u0001T\u0001T\u0001U\u0001U\u0001U\u0001U\u0001V\u0001V\u0001V\u0004"+ "V\u04c8\bV\u000bV\fV\u04c9\u0001V\u0001V\u0003V\u04ce\bV\u0001V\u0001"+ "V\u0003V\u04d2\bV\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0005W\u04da"+ "\bW\nW\fW\u04dd\tW\u0003W\u04df\bW\u0001W\u0001W\u0001W\u0001W\u0001W"+ "\u0005W\u04e6\bW\nW\fW\u04e9\tW\u0003W\u04eb\bW\u0001W\u0001W\u0001X\u0001"+ "X\u0001X\u0005X\u04f2\bX\nX\fX\u04f5\tX\u0001Y\u0001Y\u0001Y\u0001Y\u0001"+ "Y\u0005Y\u04fc\bY\nY\fY\u04ff\tY\u0003Y\u0501\bY\u0001Y\u0001Y\u0001Z"+ "\u0001Z\u0001[\u0001[\u0001[\u0001[\u0001[\u0003[\u050c\b[\u0001\\\u0001"+ "\\\u0001\\\u0003\\\u0511\b\\\u0001\\\u0001\u012c\u0002NX]\u0000\u0002"+ "\u0004\u0006\b\n\f\u000e\u0010\u0012\u0014\u0016\u0018\u001a\u001c\u001e"+ " \"$&(*,.02468:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086"+ "\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e"+ "\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6"+ "\u00b8\u0000\u0012\u0003\u0000\u0017\u0017&&12\u0003\u0000//33DD\u0004"+ "\u0000bdhlnsuu\u0003\u0000\n\n**99\u0003\u0000\u0010\u0010iitw\u0001\u0000"+ "jl\u0001\u0000hi\u0001\u0000eg\u0001\u0000ps\u0001\u0000no\u0001\u0000"+ "vw\u0001\u0000S^\u0005\u0000\u0015\u0015\u001d\u001d\u001f\u001f77\u0082"+ "\u0082\u0002\u0000\u0019\u0019<<\u0001\u0000z{\u0002\u0000~~\u0080\u0080"+ "\u0002\u0000\u009c\u009c\u00a5\u00a5\u0002\u0000\u0093\u0093\u009a\u009a"+ "\u05a5\u0000\u00c9\u0001\u0000\u0000\u0000\u0002\u00ce\u0001\u0000\u0000"+ "\u0000\u0004\u00d6\u0001\u0000\u0000\u0000\u0006\u00ea\u0001\u0000\u0000"+ "\u0000\b\u00ef\u0001\u0000\u0000\u0000\n\u00f1\u0001\u0000\u0000\u0000"+ "\f\u00fd\u0001\u0000\u0000\u0000\u000e\u010d\u0001\u0000\u0000\u0000\u0010"+ "\u011b\u0001\u0000\u0000\u0000\u0012\u0126\u0001\u0000\u0000\u0000\u0014"+ "\u012f\u0001\u0000\u0000\u0000\u0016\u013f\u0001\u0000\u0000\u0000\u0018"+ "\u0141\u0001\u0000\u0000\u0000\u001a\u0145\u0001\u0000\u0000\u0000\u001c"+ "\u0160\u0001\u0000\u0000\u0000\u001e\u0168\u0001\u0000\u0000\u0000 \u016c"+ "\u0001\u0000\u0000\u0000\"\u016e\u0001\u0000\u0000\u0000$\u0176\u0001"+ "\u0000\u0000\u0000&\u017d\u0001\u0000\u0000\u0000(\u0194\u0001\u0000\u0000"+ "\u0000*\u0196\u0001\u0000\u0000\u0000,\u01a4\u0001\u0000\u0000\u0000."+ "\u01cf\u0001\u0000\u0000\u00000\u01e8\u0001\u0000\u0000\u00002\u0211\u0001"+ "\u0000\u0000\u00004\u022b\u0001\u0000\u0000\u00006\u0235\u0001\u0000\u0000"+ "\u00008\u0239\u0001\u0000\u0000\u0000:\u0246\u0001\u0000\u0000\u0000<"+ "\u024c\u0001\u0000\u0000\u0000>\u026c\u0001\u0000\u0000\u0000@\u0273\u0001"+ "\u0000\u0000\u0000B\u027a\u0001\u0000\u0000\u0000D\u028d\u0001\u0000\u0000"+ "\u0000F\u0291\u0001\u0000\u0000\u0000H\u02a1\u0001\u0000\u0000\u0000J"+ "\u02a3\u0001\u0000\u0000\u0000L\u02bc\u0001\u0000\u0000\u0000N\u02c6\u0001"+ "\u0000\u0000\u0000P\u02df\u0001\u0000\u0000\u0000R\u02e1\u0001\u0000\u0000"+ "\u0000T\u02fb\u0001\u0000\u0000\u0000V\u0301\u0001\u0000\u0000\u0000X"+ "\u0317\u0001\u0000\u0000\u0000Z\u0370\u0001\u0000\u0000\u0000\\\u0372"+ "\u0001\u0000\u0000\u0000^\u0381\u0001\u0000\u0000\u0000`\u038c\u0001\u0000"+ "\u0000\u0000b\u0393\u0001\u0000\u0000\u0000d\u0395\u0001\u0000\u0000\u0000"+ "f\u0398\u0001\u0000\u0000\u0000h\u039b\u0001\u0000\u0000\u0000j\u03a0"+ "\u0001\u0000\u0000\u0000l\u03a5\u0001\u0000\u0000\u0000n\u03a9\u0001\u0000"+ "\u0000\u0000p\u03ab\u0001\u0000\u0000\u0000r\u03b5\u0001\u0000\u0000\u0000"+ "t\u03c5\u0001\u0000\u0000\u0000v\u03c9\u0001\u0000\u0000\u0000x\u03cb"+ "\u0001\u0000\u0000\u0000z\u03d4\u0001\u0000\u0000\u0000|\u03e4\u0001\u0000"+ "\u0000\u0000~\u03ea\u0001\u0000\u0000\u0000\u0080\u03f2\u0001\u0000\u0000"+ "\u0000\u0082\u03f5\u0001\u0000\u0000\u0000\u0084\u03f8\u0001\u0000\u0000"+ "\u0000\u0086\u0407\u0001\u0000\u0000\u0000\u0088\u0413\u0001\u0000\u0000"+ "\u0000\u008a\u0419\u0001\u0000\u0000\u0000\u008c\u041e\u0001\u0000\u0000"+ "\u0000\u008e\u0423\u0001\u0000\u0000\u0000\u0090\u0433\u0001\u0000\u0000"+ "\u0000\u0092\u043e\u0001\u0000\u0000\u0000\u0094\u0446\u0001\u0000\u0000"+ "\u0000\u0096\u0463\u0001\u0000\u0000\u0000\u0098\u0467\u0001\u0000\u0000"+ "\u0000\u009a\u046a\u0001\u0000\u0000\u0000\u009c\u0479\u0001\u0000\u0000"+ "\u0000\u009e\u0486\u0001\u0000\u0000\u0000\u00a0\u0488\u0001\u0000\u0000"+ "\u0000\u00a2\u04a4\u0001\u0000\u0000\u0000\u00a4\u04b4\u0001\u0000\u0000"+ "\u0000\u00a6\u04b6\u0001\u0000\u0000\u0000\u00a8\u04ba\u0001\u0000\u0000"+ "\u0000\u00aa\u04c0\u0001\u0000\u0000\u0000\u00ac\u04c4\u0001\u0000\u0000"+ "\u0000\u00ae\u04d3\u0001\u0000\u0000\u0000\u00b0\u04ee\u0001\u0000\u0000"+ "\u0000\u00b2\u04f6\u0001\u0000\u0000\u0000\u00b4\u0504\u0001\u0000\u0000"+ "\u0000\u00b6\u050b\u0001\u0000\u0000\u0000\u00b8\u0510\u0001\u0000\u0000"+ "\u0000\u00ba\u00c8\u0003\u0002\u0001\u0000\u00bb\u00c8\u0003\u0004\u0002"+ "\u0000\u00bc\u00c8\u0003J%\u0000\u00bd\u00c8\u0003\f\u0006\u0000\u00be"+ "\u00c8\u0003\u000e\u0007\u0000\u00bf\u00c8\u0003\u0010\b\u0000\u00c0\u00c8"+ "\u0003,\u0016\u0000\u00c1\u00c8\u0003>\u001f\u0000\u00c2\u00c8\u00034"+ "\u001a\u0000\u00c3\u00c8\u00038\u001c\u0000\u00c4\u00c8\u0003:\u001d\u0000"+ "\u00c5\u00c8\u0003F#\u0000\u00c6\u00c8\u0003B!\u0000\u00c7\u00ba\u0001"+ "\u0000\u0000\u0000\u00c7\u00bb\u0001\u0000\u0000\u0000\u00c7\u00bc\u0001"+ "\u0000\u0000\u0000\u00c7\u00bd\u0001\u0000\u0000\u0000\u00c7\u00be\u0001"+ "\u0000\u0000\u0000\u00c7\u00bf\u0001\u0000\u0000\u0000\u00c7\u00c0\u0001"+ "\u0000\u0000\u0000\u00c7\u00c1\u0001\u0000\u0000\u0000\u00c7\u00c2\u0001"+ "\u0000\u0000\u0000\u00c7\u00c3\u0001\u0000\u0000\u0000\u00c7\u00c4\u0001"+ "\u0000\u0000\u0000\u00c7\u00c5\u0001\u0000\u0000\u0000\u00c7\u00c6\u0001"+ "\u0000\u0000\u0000\u00c8\u00cb\u0001\u0000\u0000\u0000\u00c9\u00c7\u0001"+ "\u0000\u0000\u0000\u00c9\u00ca\u0001\u0000\u0000\u0000\u00ca\u00cc\u0001"+ "\u0000\u0000\u0000\u00cb\u00c9\u0001\u0000\u0000\u0000\u00cc\u00cd\u0005"+ "\u0000\u0000\u0001\u00cd\u0001\u0001\u0000\u0000\u0000\u00ce\u00d0\u0005"+ "0\u0000\u0000\u00cf\u00d1\u0005\u00ad\u0000\u0000\u00d0\u00cf\u0001\u0000"+ "\u0000\u0000\u00d1\u00d2\u0001\u0000\u0000\u0000\u00d2\u00d0\u0001\u0000"+ "\u0000\u0000\u00d2\u00d3\u0001\u0000\u0000\u0000\u00d3\u00d4\u0001\u0000"+ "\u0000\u0000\u00d4\u00d5\u0005\u00ae\u0000\u0000\u00d5\u0003\u0001\u0000"+ "\u0000\u0000\u00d6\u00e6\u0005#\u0000\u0000\u00d7\u00da\u0003\b\u0004"+ "\u0000\u00d8\u00d9\u0005\u0005\u0000\u0000\u00d9\u00db\u0003`0\u0000\u00da"+ "\u00d8\u0001\u0000\u0000\u0000\u00da\u00db\u0001\u0000\u0000\u0000\u00db"+ "\u00e7\u0001\u0000\u0000\u0000\u00dc\u00dd\u0003\n\u0005\u0000\u00dd\u00de"+ "\u0005\u001d\u0000\u0000\u00de\u00df\u0003\b\u0004\u0000\u00df\u00e7\u0001"+ "\u0000\u0000\u0000\u00e0\u00e1\u0005j\u0000\u0000\u00e1\u00e2\u0005\u0005"+ "\u0000\u0000\u00e2\u00e3\u0003`0\u0000\u00e3\u00e4\u0005\u001d\u0000\u0000"+ "\u00e4\u00e5\u0003\b\u0004\u0000\u00e5\u00e7\u0001\u0000\u0000\u0000\u00e6"+ "\u00d7\u0001\u0000\u0000\u0000\u00e6\u00dc\u0001\u0000\u0000\u0000\u00e6"+ "\u00e0\u0001\u0000\u0000\u0000\u00e7\u00e8\u0001\u0000\u0000\u0000\u00e8"+ "\u00e9\u0005N\u0000\u0000\u00e9\u0005\u0001\u0000\u0000\u0000\u00ea\u00ed"+ "\u0003`0\u0000\u00eb\u00ec\u0005\u0005\u0000\u0000\u00ec\u00ee\u0003`"+ "0\u0000\u00ed\u00eb\u0001\u0000\u0000\u0000\u00ed\u00ee\u0001\u0000\u0000"+ "\u0000\u00ee\u0007\u0001\u0000\u0000\u0000\u00ef\u00f0\u0005z\u0000\u0000"+ "\u00f0\t\u0001\u0000\u0000\u0000\u00f1\u00f2\u0005K\u0000\u0000\u00f2"+ "\u00f7\u0003\u0006\u0003\u0000\u00f3\u00f4\u0005_\u0000\u0000\u00f4\u00f6"+ "\u0003\u0006\u0003\u0000\u00f5\u00f3\u0001\u0000\u0000\u0000\u00f6\u00f9"+ "\u0001\u0000\u0000\u0000\u00f7\u00f5\u0001\u0000\u0000\u0000\u00f7\u00f8"+ "\u0001\u0000\u0000\u0000\u00f8\u00fa\u0001\u0000\u0000\u0000\u00f9\u00f7"+ "\u0001\u0000\u0000\u0000\u00fa\u00fb\u0005L\u0000\u0000\u00fb\u000b\u0001"+ "\u0000\u0000\u0000\u00fc\u00fe\u0005\u0002\u0000\u0000\u00fd\u00fc\u0001"+ "\u0000\u0000\u0000\u00fd\u00fe\u0001\u0000\u0000\u0000\u00fe\u00ff\u0001"+ "\u0000\u0000\u0000\u00ff\u0100\u0005\u000f\u0000\u0000\u0100\u0102\u0003"+ "`0\u0000\u0101\u0103\u0003\u0012\t\u0000\u0102\u0101\u0001\u0000\u0000"+ "\u0000\u0102\u0103\u0001\u0000\u0000\u0000\u0103\u0104\u0001\u0000\u0000"+ "\u0000\u0104\u0108\u0005K\u0000\u0000\u0105\u0107\u0003\u0016\u000b\u0000"+ "\u0106\u0105\u0001\u0000\u0000\u0000\u0107\u010a\u0001\u0000\u0000\u0000"+ "\u0108\u0106\u0001\u0000\u0000\u0000\u0108\u0109\u0001\u0000\u0000\u0000"+ "\u0109\u010b\u0001\u0000\u0000\u0000\u010a\u0108\u0001\u0000\u0000\u0000"+ "\u010b\u010c\u0005L\u0000\u0000\u010c\r\u0001\u0000\u0000\u0000\u010d"+ "\u010e\u0005%\u0000\u0000\u010e\u0110\u0003`0\u0000\u010f\u0111\u0003"+ "\u0012\t\u0000\u0110\u010f\u0001\u0000\u0000\u0000\u0110\u0111\u0001\u0000"+ "\u0000\u0000\u0111\u0112\u0001\u0000\u0000\u0000\u0112\u0116\u0005K\u0000"+ "\u0000\u0113\u0115\u0003\u0016\u000b\u0000\u0114\u0113\u0001\u0000\u0000"+ "\u0000\u0115\u0118\u0001\u0000\u0000\u0000\u0116\u0114\u0001\u0000\u0000"+ "\u0000\u0116\u0117\u0001\u0000\u0000\u0000\u0117\u0119\u0001\u0000\u0000"+ "\u0000\u0118\u0116\u0001\u0000\u0000\u0000\u0119\u011a\u0005L\u0000\u0000"+ "\u011a\u000f\u0001\u0000\u0000\u0000\u011b\u011c\u0005(\u0000\u0000\u011c"+ "\u011d\u0003`0\u0000\u011d\u0121\u0005K\u0000\u0000\u011e\u0120\u0003"+ "\u0016\u000b\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\u0124\u0001\u0000\u0000\u0000\u0123\u0121\u0001"+ "\u0000\u0000\u0000\u0124\u0125\u0005L\u0000\u0000\u0125\u0011\u0001\u0000"+ "\u0000\u0000\u0126\u0127\u0005\'\u0000\u0000\u0127\u012c\u0003\u0014\n"+ "\u0000\u0128\u0129\u0005_\u0000\u0000\u0129\u012b\u0003\u0014\n\u0000"+ "\u012a\u0128\u0001\u0000\u0000\u0000\u012b\u012e\u0001\u0000\u0000\u0000"+ "\u012c\u012d\u0001\u0000\u0000\u0000\u012c\u012a\u0001\u0000\u0000\u0000"+ "\u012d\u0013\u0001\u0000\u0000\u0000\u012e\u012c\u0001\u0000\u0000\u0000"+ "\u012f\u0131\u0003\u001c\u000e\u0000\u0130\u0132\u0003\u001a\r\u0000\u0131"+ "\u0130\u0001\u0000\u0000\u0000\u0131\u0132\u0001\u0000\u0000\u0000\u0132"+ "\u0015\u0001\u0000\u0000\u0000\u0133\u0140\u0003&\u0013\u0000\u0134\u0140"+ "\u0003,\u0016\u0000\u0135\u0140\u0003.\u0017\u0000\u0136\u0140\u00030"+ "\u0018\u0000\u0137\u0140\u00032\u0019\u0000\u0138\u0140\u00034\u001a\u0000"+ "\u0139\u0140\u00038\u001c\u0000\u013a\u0140\u0003:\u001d\u0000\u013b\u0140"+ "\u0003<\u001e\u0000\u013c\u0140\u0003B!\u0000\u013d\u0140\u0003F#\u0000"+ "\u013e\u0140\u0003J%\u0000\u013f\u0133\u0001\u0000\u0000\u0000\u013f\u0134"+ "\u0001\u0000\u0000\u0000\u013f\u0135\u0001\u0000\u0000\u0000\u013f\u0136"+ "\u0001\u0000\u0000\u0000\u013f\u0137\u0001\u0000\u0000\u0000\u013f\u0138"+ "\u0001\u0000\u0000\u0000\u013f\u0139\u0001\u0000\u0000\u0000\u013f\u013a"+ "\u0001\u0000\u0000\u0000\u013f\u013b\u0001\u0000\u0000\u0000\u013f\u013c"+ "\u0001\u0000\u0000\u0000\u013f\u013d\u0001\u0000\u0000\u0000\u013f\u013e"+ "\u0001\u0000\u0000\u0000\u0140\u0017\u0001\u0000\u0000\u0000\u0141\u0142"+ "\u0003`0\u0000\u0142\u0143\u0005M\u0000\u0000\u0143\u0144\u0003X,\u0000"+ "\u0144\u0019\u0001\u0000\u0000\u0000\u0145\u015c\u0005G\u0000\u0000\u0146"+ "\u014b\u0003X,\u0000\u0147\u0148\u0005_\u0000\u0000\u0148\u014a\u0003"+ "X,\u0000\u0149\u0147\u0001\u0000\u0000\u0000\u014a\u014d\u0001\u0000\u0000"+ "\u0000\u014b\u0149\u0001\u0000\u0000\u0000\u014b\u014c\u0001\u0000\u0000"+ "\u0000\u014c\u014f\u0001\u0000\u0000\u0000\u014d\u014b\u0001\u0000\u0000"+ "\u0000\u014e\u0146\u0001\u0000\u0000\u0000\u014e\u014f\u0001\u0000\u0000"+ "\u0000\u014f\u015d\u0001\u0000\u0000\u0000\u0150\u0159\u0005K\u0000\u0000"+ "\u0151\u0156\u0003\u0018\f\u0000\u0152\u0153\u0005_\u0000\u0000\u0153"+ "\u0155\u0003\u0018\f\u0000\u0154\u0152\u0001\u0000\u0000\u0000\u0155\u0158"+ "\u0001\u0000\u0000\u0000\u0156\u0154\u0001\u0000\u0000\u0000\u0156\u0157"+ "\u0001\u0000\u0000\u0000\u0157\u015a\u0001\u0000\u0000\u0000\u0158\u0156"+ "\u0001\u0000\u0000\u0000\u0159\u0151\u0001\u0000\u0000\u0000\u0159\u015a"+ "\u0001\u0000\u0000\u0000\u015a\u015b\u0001\u0000\u0000\u0000\u015b\u015d"+ "\u0005L\u0000\u0000\u015c\u014e\u0001\u0000\u0000\u0000\u015c\u0150\u0001"+ "\u0000\u0000\u0000\u015d\u015e\u0001\u0000\u0000\u0000\u015e\u015f\u0005"+ "H\u0000\u0000\u015f\u001b\u0001\u0000\u0000\u0000\u0160\u0165\u0003`0"+ "\u0000\u0161\u0162\u0005O\u0000\u0000\u0162\u0164\u0003`0\u0000\u0163"+ "\u0161\u0001\u0000\u0000\u0000\u0164\u0167\u0001\u0000\u0000\u0000\u0165"+ "\u0163\u0001\u0000\u0000\u0000\u0165\u0166\u0001\u0000\u0000\u0000\u0166"+ "\u001d\u0001\u0000\u0000\u0000\u0167\u0165\u0001\u0000\u0000\u0000\u0168"+ "\u016a\u0003\u001c\u000e\u0000\u0169\u016b\u0003\u001a\r\u0000\u016a\u0169"+ "\u0001\u0000\u0000\u0000\u016a\u016b\u0001\u0000\u0000\u0000\u016b\u001f"+ "\u0001\u0000\u0000\u0000\u016c\u016d\u0007\u0000\u0000\u0000\u016d!\u0001"+ "\u0000\u0000\u0000\u016e\u0173\u0003$\u0012\u0000\u016f\u0170\u0005_\u0000"+ "\u0000\u0170\u0172\u0003$\u0012\u0000\u0171\u016f\u0001\u0000\u0000\u0000"+ "\u0172\u0175\u0001\u0000\u0000\u0000\u0173\u0171\u0001\u0000\u0000\u0000"+ "\u0173\u0174\u0001\u0000\u0000\u0000\u0174#\u0001\u0000\u0000\u0000\u0175"+ "\u0173\u0001\u0000\u0000\u0000\u0176\u0178\u0003N\'\u0000\u0177\u0179"+ "\u0003V+\u0000\u0178\u0177\u0001\u0000\u0000\u0000\u0178\u0179\u0001\u0000"+ "\u0000\u0000\u0179\u017b\u0001\u0000\u0000\u0000\u017a\u017c\u0003`0\u0000"+ "\u017b\u017a\u0001\u0000\u0000\u0000\u017b\u017c\u0001\u0000\u0000\u0000"+ "\u017c%\u0001\u0000\u0000\u0000\u017d\u017e\u0005\r\u0000\u0000\u017e"+ "\u0180\u0005G\u0000\u0000\u017f\u0181\u0003\"\u0011\u0000\u0180\u017f"+ "\u0001\u0000\u0000\u0000\u0180\u0181\u0001\u0000\u0000\u0000\u0181\u0182"+ "\u0001\u0000\u0000\u0000\u0182\u018f\u0005H\u0000\u0000\u0183\u018e\u0003"+ "\u001e\u000f\u0000\u0184\u0185\u0004\u0013\u0000\u0001\u0185\u0186\u0005"+ "/\u0000\u0000\u0186\u018e\u0006\u0013\uffff\uffff\u0000\u0187\u0188\u0004"+ "\u0013\u0001\u0001\u0188\u0189\u0005&\u0000\u0000\u0189\u018e\u0006\u0013"+ "\uffff\uffff\u0000\u018a\u018b\u0004\u0013\u0002\u0001\u018b\u018c\u0005"+ "2\u0000\u0000\u018c\u018e\u0006\u0013\uffff\uffff\u0000\u018d\u0183\u0001"+ "\u0000\u0000\u0000\u018d\u0184\u0001\u0000\u0000\u0000\u018d\u0187\u0001"+ "\u0000\u0000\u0000\u018d\u018a\u0001\u0000\u0000\u0000\u018e\u0191\u0001"+ "\u0000\u0000\u0000\u018f\u018d\u0001\u0000\u0000\u0000\u018f\u0190\u0001"+ "\u0000\u0000\u0000\u0190\u0192\u0001\u0000\u0000\u0000\u0191\u018f\u0001"+ "\u0000\u0000\u0000\u0192\u0193\u0003p8\u0000\u0193\'\u0001\u0000\u0000"+ "\u0000\u0194\u0195\u0007\u0001\u0000\u0000\u0195)\u0001\u0000\u0000\u0000"+ "\u0196\u01a2\u0005.\u0000\u0000\u0197\u0198\u0005G\u0000\u0000\u0198\u019d"+ "\u0003\u001c\u000e\u0000\u0199\u019a\u0005_\u0000\u0000\u019a\u019c\u0003"+ "\u001c\u000e\u0000\u019b\u0199\u0001\u0000\u0000\u0000\u019c\u019f\u0001"+ "\u0000\u0000\u0000\u019d\u019b\u0001\u0000\u0000\u0000\u019d\u019e\u0001"+ "\u0000\u0000\u0000\u019e\u01a0\u0001\u0000\u0000\u0000\u019f\u019d\u0001"+ "\u0000\u0000\u0000\u01a0\u01a1\u0005H\u0000\u0000\u01a1\u01a3\u0001\u0000"+ "\u0000\u0000\u01a2\u0197\u0001\u0000\u0000\u0000\u01a2\u01a3\u0001\u0000"+ "\u0000\u0000\u01a3+\u0001\u0000\u0000\u0000\u01a4\u01a8\u0005\u001e\u0000"+ "\u0000\u01a5\u01a9\u0003`0\u0000\u01a6\u01a9\u0005\u0018\u0000\u0000\u01a7"+ "\u01a9\u00054\u0000\u0000\u01a8\u01a5\u0001\u0000\u0000\u0000\u01a8\u01a6"+ "\u0001\u0000\u0000\u0000\u01a8\u01a7\u0001\u0000\u0000\u0000\u01a9\u01aa"+ "\u0001\u0000\u0000\u0000\u01aa\u01ac\u0005G\u0000\u0000\u01ab\u01ad\u0003"+ "\"\u0011\u0000\u01ac\u01ab\u0001\u0000\u0000\u0000\u01ac\u01ad\u0001\u0000"+ "\u0000\u0000\u01ad\u01ae\u0001\u0000\u0000\u0000\u01ae\u01c1\u0005H\u0000"+ "\u0000\u01af\u01b0\u0004\u0016\u0003\u0001\u01b0\u01b1\u0003 \u0010\u0000"+ "\u01b1\u01b2\u0006\u0016\uffff\uffff\u0000\u01b2\u01c0\u0001\u0000\u0000"+ "\u0000\u01b3\u01b4\u0004\u0016\u0004\u0001\u01b4\u01b5\u0003(\u0014\u0000"+ "\u01b5\u01b6\u0006\u0016\uffff\uffff\u0000\u01b6\u01c0\u0001\u0000\u0000"+ "\u0000\u01b7\u01c0\u0003\u001e\u000f\u0000\u01b8\u01b9\u0004\u0016\u0005"+ "\u0001\u01b9\u01ba\u0005E\u0000\u0000\u01ba\u01c0\u0006\u0016\uffff\uffff"+ "\u0000\u01bb\u01bc\u0004\u0016\u0006\u0001\u01bc\u01bd\u0003*\u0015\u0000"+ "\u01bd\u01be\u0006\u0016\uffff\uffff\u0000\u01be\u01c0\u0001\u0000\u0000"+ "\u0000\u01bf\u01af\u0001\u0000\u0000\u0000\u01bf\u01b3\u0001\u0000\u0000"+ "\u0000\u01bf\u01b7\u0001\u0000\u0000\u0000\u01bf\u01b8\u0001\u0000\u0000"+ "\u0000\u01bf\u01bb\u0001\u0000\u0000\u0000\u01c0\u01c3\u0001\u0000\u0000"+ "\u0000\u01c1\u01bf\u0001\u0000\u0000\u0000\u01c1\u01c2\u0001\u0000\u0000"+ "\u0000\u01c2\u01c9\u0001\u0000\u0000\u0000\u01c3\u01c1\u0001\u0000\u0000"+ "\u0000\u01c4\u01c5\u00056\u0000\u0000\u01c5\u01c6\u0005G\u0000\u0000\u01c6"+ "\u01c7\u0003\"\u0011\u0000\u01c7\u01c8\u0005H\u0000\u0000\u01c8\u01ca"+ "\u0001\u0000\u0000\u0000\u01c9\u01c4\u0001\u0000\u0000\u0000\u01c9\u01ca"+ "\u0001\u0000\u0000\u0000\u01ca\u01cd\u0001\u0000\u0000\u0000\u01cb\u01ce"+ "\u0005N\u0000\u0000\u01cc\u01ce\u0003p8\u0000\u01cd\u01cb\u0001\u0000"+ "\u0000\u0000\u01cd\u01cc\u0001\u0000\u0000\u0000\u01ce-\u0001\u0000\u0000"+ "\u0000\u01cf\u01d0\u0005+\u0000\u0000\u01d0\u01d6\u0003`0\u0000\u01d1"+ "\u01d3\u0005G\u0000\u0000\u01d2\u01d4\u0003\"\u0011\u0000\u01d3\u01d2"+ "\u0001\u0000\u0000\u0000\u01d3\u01d4\u0001\u0000\u0000\u0000\u01d4\u01d5"+ "\u0001\u0000\u0000\u0000\u01d5\u01d7\u0005H\u0000\u0000\u01d6\u01d1\u0001"+ "\u0000\u0000\u0000\u01d6\u01d7\u0001\u0000\u0000\u0000\u01d7\u01e1\u0001"+ "\u0000\u0000\u0000\u01d8\u01d9\u0004\u0017\u0007\u0001\u01d9\u01da\u0005"+ "E\u0000\u0000\u01da\u01e0\u0006\u0017\uffff\uffff\u0000\u01db\u01dc\u0004"+ "\u0017\b\u0001\u01dc\u01dd\u0003*\u0015\u0000\u01dd\u01de\u0006\u0017"+ "\uffff\uffff\u0000\u01de\u01e0\u0001\u0000\u0000\u0000\u01df\u01d8\u0001"+ "\u0000\u0000\u0000\u01df\u01db\u0001\u0000\u0000\u0000\u01e0\u01e3\u0001"+ "\u0000\u0000\u0000\u01e1\u01df\u0001\u0000\u0000\u0000\u01e1\u01e2\u0001"+ "\u0000\u0000\u0000\u01e2\u01e6\u0001\u0000\u0000\u0000\u01e3\u01e1\u0001"+ "\u0000\u0000\u0000\u01e4\u01e7\u0005N\u0000\u0000\u01e5\u01e7\u0003p8"+ "\u0000\u01e6\u01e4\u0001\u0000\u0000\u0000\u01e6\u01e5\u0001\u0000\u0000"+ "\u0000\u01e7/\u0001\u0000\u0000\u0000\u01e8\u01e9\u0005\u0018\u0000\u0000"+ "\u01e9\u01ed\u0005G\u0000\u0000\u01ea\u01eb\u0003\"\u0011\u0000\u01eb"+ "\u01ec\u0006\u0018\uffff\uffff\u0000\u01ec\u01ee\u0001\u0000\u0000\u0000"+ "\u01ed\u01ea\u0001\u0000\u0000\u0000\u01ed\u01ee\u0001\u0000\u0000\u0000"+ "\u01ee\u01ef\u0001\u0000\u0000\u0000\u01ef\u0201\u0005H\u0000\u0000\u01f0"+ "\u01f1\u0004\u0018\t\u0001\u01f1\u01f2\u0005\u0017\u0000\u0000\u01f2\u0200"+ "\u0006\u0018\uffff\uffff\u0000\u01f3\u01f4\u0004\u0018\n\u0001\u01f4\u01f5"+ "\u0003(\u0014\u0000\u01f5\u01f6\u0006\u0018\uffff\uffff\u0000\u01f6\u0200"+ "\u0001\u0000\u0000\u0000\u01f7\u0200\u0003\u001e\u000f\u0000\u01f8\u01f9"+ "\u0004\u0018\u000b\u0001\u01f9\u01fa\u0005E\u0000\u0000\u01fa\u0200\u0006"+ "\u0018\uffff\uffff\u0000\u01fb\u01fc\u0004\u0018\f\u0001\u01fc\u01fd\u0003"+ "*\u0015\u0000\u01fd\u01fe\u0006\u0018\uffff\uffff\u0000\u01fe\u0200\u0001"+ "\u0000\u0000\u0000\u01ff\u01f0\u0001\u0000\u0000\u0000\u01ff\u01f3\u0001"+ "\u0000\u0000\u0000\u01ff\u01f7\u0001\u0000\u0000\u0000\u01ff\u01f8\u0001"+ "\u0000\u0000\u0000\u01ff\u01fb\u0001\u0000\u0000\u0000\u0200\u0203\u0001"+ "\u0000\u0000\u0000\u0201\u01ff\u0001\u0000\u0000\u0000\u0201\u0202\u0001"+ "\u0000\u0000\u0000\u0202\u020b\u0001\u0000\u0000\u0000\u0203\u0201\u0001"+ "\u0000\u0000\u0000\u0204\u0205\u0004\u0018\r\u0001\u0205\u0206\u00056"+ "\u0000\u0000\u0206\u0207\u0005G\u0000\u0000\u0207\u0208\u0003\"\u0011"+ "\u0000\u0208\u0209\u0005H\u0000\u0000\u0209\u020c\u0001\u0000\u0000\u0000"+ "\u020a\u020c\u0004\u0018\u000e\u0001\u020b\u0204\u0001\u0000\u0000\u0000"+ "\u020b\u020a\u0001\u0000\u0000\u0000\u020c\u020f\u0001\u0000\u0000\u0000"+ "\u020d\u0210\u0005N\u0000\u0000\u020e\u0210\u0003p8\u0000\u020f\u020d"+ "\u0001\u0000\u0000\u0000\u020f\u020e\u0001\u0000\u0000\u0000\u02101\u0001"+ "\u0000\u0000\u0000\u0211\u0212\u00054\u0000\u0000\u0212\u0213\u0005G\u0000"+ "\u0000\u0213\u0224\u0005H\u0000\u0000\u0214\u0215\u0004\u0019\u000f\u0001"+ "\u0215\u0216\u0005\u0017\u0000\u0000\u0216\u0223\u0006\u0019\uffff\uffff"+ "\u0000\u0217\u0218\u0004\u0019\u0010\u0001\u0218\u0219\u0005/\u0000\u0000"+ "\u0219\u0223\u0006\u0019\uffff\uffff\u0000\u021a\u0223\u0003\u001e\u000f"+ "\u0000\u021b\u021c\u0004\u0019\u0011\u0001\u021c\u021d\u0005E\u0000\u0000"+ "\u021d\u0223\u0006\u0019\uffff\uffff\u0000\u021e\u021f\u0004\u0019\u0012"+ "\u0001\u021f\u0220\u0003*\u0015\u0000\u0220\u0221\u0006\u0019\uffff\uffff"+ "\u0000\u0221\u0223\u0001\u0000\u0000\u0000\u0222\u0214\u0001\u0000\u0000"+ "\u0000\u0222\u0217\u0001\u0000\u0000\u0000\u0222\u021a\u0001\u0000\u0000"+ "\u0000\u0222\u021b\u0001\u0000\u0000\u0000\u0222\u021e\u0001\u0000\u0000"+ "\u0000\u0223\u0226\u0001\u0000\u0000\u0000\u0224\u0222\u0001\u0000\u0000"+ "\u0000\u0224\u0225\u0001\u0000\u0000\u0000\u0225\u0229\u0001\u0000\u0000"+ "\u0000\u0226\u0224\u0001\u0000\u0000\u0000\u0227\u022a\u0005N\u0000\u0000"+ "\u0228\u022a\u0003p8\u0000\u0229\u0227\u0001\u0000\u0000\u0000\u0229\u0228"+ "\u0001\u0000\u0000\u0000\u022a3\u0001\u0000\u0000\u0000\u022b\u022c\u0005"+ ";\u0000\u0000\u022c\u022d\u0003`0\u0000\u022d\u022f\u0005K\u0000\u0000"+ "\u022e\u0230\u00036\u001b\u0000\u022f\u022e\u0001\u0000\u0000\u0000\u0230"+ "\u0231\u0001\u0000\u0000\u0000\u0231\u022f\u0001\u0000\u0000\u0000\u0231"+ "\u0232\u0001\u0000\u0000\u0000\u0232\u0233\u0001\u0000\u0000\u0000\u0233"+ "\u0234\u0005L\u0000\u0000\u02345\u0001\u0000\u0000\u0000\u0235\u0236\u0003"+ "N\'\u0000\u0236\u0237\u0003`0\u0000\u0237\u0238\u0005N\u0000\u0000\u0238"+ "7\u0001\u0000\u0000\u0000\u0239\u023a\u0005\u0014\u0000\u0000\u023a\u023b"+ "\u0003`0\u0000\u023b\u023c\u0005K\u0000\u0000\u023c\u0241\u0003`0\u0000"+ "\u023d\u023e\u0005_\u0000\u0000\u023e\u0240\u0003`0\u0000\u023f\u023d"+ "\u0001\u0000\u0000\u0000\u0240\u0243\u0001\u0000\u0000\u0000\u0241\u023f"+ "\u0001\u0000\u0000\u0000\u0241\u0242\u0001\u0000\u0000\u0000\u0242\u0244"+ "\u0001\u0000\u0000\u0000\u0243\u0241\u0001\u0000\u0000\u0000\u0244\u0245"+ "\u0005L\u0000\u0000\u02459\u0001\u0000\u0000\u0000\u0246\u0247\u0005>"+ "\u0000\u0000\u0247\u0248\u0003`0\u0000\u0248\u0249\u0005\'\u0000\u0000"+ "\u0249\u024a\u0003P(\u0000\u024a\u024b\u0005N\u0000\u0000\u024b;\u0001"+ "\u0000\u0000\u0000\u024c\u0262\u0003N\'\u0000\u024d\u024e\u0004\u001e"+ "\u0013\u0001\u024e\u024f\u00052\u0000\u0000\u024f\u0261\u0006\u001e\uffff"+ "\uffff\u0000\u0250\u0251\u0004\u001e\u0014\u0001\u0251\u0252\u00051\u0000"+ "\u0000\u0252\u0261\u0006\u001e\uffff\uffff\u0000\u0253\u0254\u0004\u001e"+ "\u0015\u0001\u0254\u0255\u0005&\u0000\u0000\u0255\u0261\u0006\u001e\uffff"+ "\uffff\u0000\u0256\u0257\u0004\u001e\u0016\u0001\u0257\u0258\u0005\f\u0000"+ "\u0000\u0258\u0261\u0006\u001e\uffff\uffff\u0000\u0259\u025a\u0004\u001e"+ "\u0017\u0001\u025a\u025b\u0003*\u0015\u0000\u025b\u025c\u0006\u001e\uffff"+ "\uffff\u0000\u025c\u0261\u0001\u0000\u0000\u0000\u025d\u025e\u0004\u001e"+ "\u0018\u0001\u025e\u025f\u0005\"\u0000\u0000\u025f\u0261\u0006\u001e\uffff"+ "\uffff\u0000\u0260\u024d\u0001\u0000\u0000\u0000\u0260\u0250\u0001\u0000"+ "\u0000\u0000\u0260\u0253\u0001\u0000\u0000\u0000\u0260\u0256\u0001\u0000"+ "\u0000\u0000\u0260\u0259\u0001\u0000\u0000\u0000\u0260\u025d\u0001\u0000"+ "\u0000\u0000\u0261\u0264\u0001\u0000\u0000\u0000\u0262\u0260\u0001\u0000"+ "\u0000\u0000\u0262\u0263\u0001\u0000\u0000\u0000\u0263\u0265\u0001\u0000"+ "\u0000\u0000\u0264\u0262\u0001\u0000\u0000\u0000\u0265\u0268\u0003`0\u0000"+ "\u0266\u0267\u0005S\u0000\u0000\u0267\u0269\u0003X,\u0000\u0268\u0266"+ "\u0001\u0000\u0000\u0000\u0268\u0269\u0001\u0000\u0000\u0000\u0269\u026a"+ "\u0001\u0000\u0000\u0000\u026a\u026b\u0005N\u0000\u0000\u026b=\u0001\u0000"+ "\u0000\u0000\u026c\u026d\u0003N\'\u0000\u026d\u026e\u0005\f\u0000\u0000"+ "\u026e\u026f\u0003`0\u0000\u026f\u0270\u0005S\u0000\u0000\u0270\u0271"+ "\u0003X,\u0000\u0271\u0272\u0005N\u0000\u0000\u0272?\u0001\u0000\u0000"+ "\u0000\u0273\u0275\u0003N\'\u0000\u0274\u0276\u0005$\u0000\u0000\u0275"+ "\u0274\u0001\u0000\u0000\u0000\u0275\u0276\u0001\u0000\u0000\u0000\u0276"+ "\u0278\u0001\u0000\u0000\u0000\u0277\u0279\u0003`0\u0000\u0278\u0277\u0001"+ "\u0000\u0000\u0000\u0278\u0279\u0001\u0000\u0000\u0000\u0279A\u0001\u0000"+ "\u0000\u0000\u027a\u027b\u0005\u0016\u0000\u0000\u027b\u027c\u0003`0\u0000"+ "\u027c\u0285\u0005G\u0000\u0000\u027d\u0282\u0003@ \u0000\u027e\u027f"+ "\u0005_\u0000\u0000\u027f\u0281\u0003@ \u0000\u0280\u027e\u0001\u0000"+ "\u0000\u0000\u0281\u0284\u0001\u0000\u0000\u0000\u0282\u0280\u0001\u0000"+ "\u0000\u0000\u0282\u0283\u0001\u0000\u0000\u0000\u0283\u0286\u0001\u0000"+ "\u0000\u0000\u0284\u0282\u0001\u0000\u0000\u0000\u0285\u027d\u0001\u0000"+ "\u0000\u0000\u0285\u0286\u0001\u0000\u0000\u0000\u0286\u0287\u0001\u0000"+ "\u0000\u0000\u0287\u0289\u0005H\u0000\u0000\u0288\u028a\u0005\u0004\u0000"+ "\u0000\u0289\u0288\u0001\u0000\u0000\u0000\u0289\u028a\u0001\u0000\u0000"+ "\u0000\u028a\u028b\u0001\u0000\u0000\u0000\u028b\u028c\u0005N\u0000\u0000"+ "\u028cC\u0001\u0000\u0000\u0000\u028d\u028f\u0003N\'\u0000\u028e\u0290"+ "\u0003`0\u0000\u028f\u028e\u0001\u0000\u0000\u0000\u028f\u0290\u0001\u0000"+ "\u0000\u0000\u0290E\u0001\u0000\u0000\u0000\u0291\u0292\u0005\u0015\u0000"+ "\u0000\u0292\u0293\u0003`0\u0000\u0293\u029c\u0005G\u0000\u0000\u0294"+ "\u0299\u0003D\"\u0000\u0295\u0296\u0005_\u0000\u0000\u0296\u0298\u0003"+ "D\"\u0000\u0297\u0295\u0001\u0000\u0000\u0000\u0298\u029b\u0001\u0000"+ "\u0000\u0000\u0299\u0297\u0001\u0000\u0000\u0000\u0299\u029a\u0001\u0000"+ "\u0000\u0000\u029a\u029d\u0001\u0000\u0000\u0000\u029b\u0299\u0001\u0000"+ "\u0000\u0000\u029c\u0294\u0001\u0000\u0000\u0000\u029c\u029d\u0001\u0000"+ "\u0000\u0000\u029d\u029e\u0001\u0000\u0000\u0000\u029e\u029f\u0005H\u0000"+ "\u0000\u029f\u02a0\u0005N\u0000\u0000\u02a0G\u0001\u0000\u0000\u0000\u02a1"+ "\u02a2\u0007\u0002\u0000\u0000\u02a2I\u0001\u0000\u0000\u0000\u02a3\u02b0"+ "\u0005C\u0000\u0000\u02a4\u02b1\u0003\u001c\u000e\u0000\u02a5\u02a6\u0005"+ "K\u0000\u0000\u02a6\u02ab\u0003L&\u0000\u02a7\u02a8\u0005_\u0000\u0000"+ "\u02a8\u02aa\u0003L&\u0000\u02a9\u02a7\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\u02af\u0005L\u0000\u0000\u02af\u02b1\u0001"+ "\u0000\u0000\u0000\u02b0\u02a4\u0001\u0000\u0000\u0000\u02b0\u02a5\u0001"+ "\u0000\u0000\u0000\u02b1\u02b2\u0001\u0000\u0000\u0000\u02b2\u02b5\u0005"+ "\u001c\u0000\u0000\u02b3\u02b6\u0005j\u0000\u0000\u02b4\u02b6\u0003N\'"+ "\u0000\u02b5\u02b3\u0001\u0000\u0000\u0000\u02b5\u02b4\u0001\u0000\u0000"+ "\u0000\u02b6\u02b8\u0001\u0000\u0000\u0000\u02b7\u02b9\u0005\u001f\u0000"+ "\u0000\u02b8\u02b7\u0001\u0000\u0000\u0000\u02b8\u02b9\u0001\u0000\u0000"+ "\u0000\u02b9\u02ba\u0001\u0000\u0000\u0000\u02ba\u02bb\u0005N\u0000\u0000"+ "\u02bbK\u0001\u0000\u0000\u0000\u02bc\u02bf\u0003\u001c\u000e\u0000\u02bd"+ "\u02be\u0005\u0005\u0000\u0000\u02be\u02c0\u0003H$\u0000\u02bf\u02bd\u0001"+ "\u0000\u0000\u0000\u02bf\u02c0\u0001\u0000\u0000\u0000\u02c0M\u0001\u0000"+ "\u0000\u0000\u02c1\u02c2\u0006\'\uffff\uffff\u0000\u02c2\u02c7\u0003P"+ "(\u0000\u02c3\u02c7\u0003R)\u0000\u02c4\u02c7\u0003\u009aM\u0000\u02c5"+ "\u02c7\u0003\u001c\u000e\u0000\u02c6\u02c1\u0001\u0000\u0000\u0000\u02c6"+ "\u02c3\u0001\u0000\u0000\u0000\u02c6\u02c4\u0001\u0000\u0000\u0000\u02c6"+ "\u02c5\u0001\u0000\u0000\u0000\u02c7\u02d0\u0001\u0000\u0000\u0000\u02c8"+ "\u02c9\n\u0001\u0000\u0000\u02c9\u02cb\u0005I\u0000\u0000\u02ca\u02cc"+ "\u0003X,\u0000\u02cb\u02ca\u0001\u0000\u0000\u0000\u02cb\u02cc\u0001\u0000"+ "\u0000\u0000\u02cc\u02cd\u0001\u0000\u0000\u0000\u02cd\u02cf\u0005J\u0000"+ "\u0000\u02ce\u02c8\u0001\u0000\u0000\u0000\u02cf\u02d2\u0001\u0000\u0000"+ "\u0000\u02d0\u02ce\u0001\u0000\u0000\u0000\u02d0\u02d1\u0001\u0000\u0000"+ "\u0000\u02d1O\u0001\u0000\u0000\u0000\u02d2\u02d0\u0001\u0000\u0000\u0000"+ "\u02d3\u02e0\u0005\u0003\u0000\u0000\u02d4\u02d5\u0004(\u001a\u0001\u02d5"+ "\u02d6\u0005\u0003\u0000\u0000\u02d6\u02e0\u0005/\u0000\u0000\u02d7\u02e0"+ "\u0005\u0007\u0000\u0000\u02d8\u02e0\u0005:\u0000\u0000\u02d9\u02e0\u0005"+ "\t\u0000\u0000\u02da\u02e0\u00058\u0000\u0000\u02db\u02e0\u0005B\u0000"+ "\u0000\u02dc\u02e0\u0005\u001b\u0000\u0000\u02dd\u02e0\u0005\u001a\u0000"+ "\u0000\u02de\u02e0\u0005?\u0000\u0000\u02df\u02d3\u0001\u0000\u0000\u0000"+ "\u02df\u02d4\u0001\u0000\u0000\u0000\u02df\u02d7\u0001\u0000\u0000\u0000"+ "\u02df\u02d8\u0001\u0000\u0000\u0000\u02df\u02d9\u0001\u0000\u0000\u0000"+ "\u02df\u02da\u0001\u0000\u0000\u0000\u02df\u02db\u0001\u0000\u0000\u0000"+ "\u02df\u02dc\u0001\u0000\u0000\u0000\u02df\u02dd\u0001\u0000\u0000\u0000"+ "\u02df\u02de\u0001\u0000\u0000\u0000\u02e0Q\u0001\u0000\u0000\u0000\u02e1"+ "\u02e2\u0005\u001e\u0000\u0000\u02e2\u02e4\u0005G\u0000\u0000\u02e3\u02e5"+ "\u0003\"\u0011\u0000\u02e4\u02e3\u0001\u0000\u0000\u0000\u02e4\u02e5\u0001"+ "\u0000\u0000\u0000\u02e5\u02e6\u0001\u0000\u0000\u0000\u02e6\u02f1\u0005"+ "H\u0000\u0000\u02e7\u02e8\u0004)\u001b\u0001\u02e8\u02e9\u0003 \u0010"+ "\u0000\u02e9\u02ea\u0006)\uffff\uffff\u0000\u02ea\u02f0\u0001\u0000\u0000"+ "\u0000\u02eb\u02ec\u0004)\u001c\u0001\u02ec\u02ed\u0003(\u0014\u0000\u02ed"+ "\u02ee\u0006)\uffff\uffff\u0000\u02ee\u02f0\u0001\u0000\u0000\u0000\u02ef"+ "\u02e7\u0001\u0000\u0000\u0000\u02ef\u02eb\u0001\u0000\u0000\u0000\u02f0"+ "\u02f3\u0001\u0000\u0000\u0000\u02f1\u02ef\u0001\u0000\u0000\u0000\u02f1"+ "\u02f2\u0001\u0000\u0000\u0000\u02f2\u02f9\u0001\u0000\u0000\u0000\u02f3"+ "\u02f1\u0001\u0000\u0000\u0000\u02f4\u02f5\u00056\u0000\u0000\u02f5\u02f6"+ "\u0005G\u0000\u0000\u02f6\u02f7\u0003\"\u0011\u0000\u02f7\u02f8\u0005"+ "H\u0000\u0000\u02f8\u02fa\u0001\u0000\u0000\u0000\u02f9\u02f4\u0001\u0000"+ "\u0000\u0000\u02f9\u02fa\u0001\u0000\u0000\u0000\u02faS\u0001\u0000\u0000"+ "\u0000\u02fb\u02fd\u0003N\'\u0000\u02fc\u02fe\u0003V+\u0000\u02fd\u02fc"+ "\u0001\u0000\u0000\u0000\u02fd\u02fe\u0001\u0000\u0000\u0000\u02fe\u02ff"+ "\u0001\u0000\u0000\u0000\u02ff\u0300\u0003`0\u0000\u0300U\u0001\u0000"+ "\u0000\u0000\u0301\u0302\u0007\u0003\u0000\u0000\u0302W\u0001\u0000\u0000"+ "\u0000\u0303\u0304\u0006,\uffff\uffff\u0000\u0304\u0305\u0005/\u0000\u0000"+ "\u0305\u0318\u0003\u001a\r\u0000\u0306\u0307\u0005>\u0000\u0000\u0307"+ "\u0308\u0005G\u0000\u0000\u0308\u0309\u0003N\'\u0000\u0309\u030a\u0005"+ "H\u0000\u0000\u030a\u0318\u0001\u0000\u0000\u0000\u030b\u030c\u0007\u0004"+ "\u0000\u0000\u030c\u0318\u0003X,\u0013\u030d\u030e\u0005,\u0000\u0000"+ "\u030e\u0318\u0003N\'\u0000\u030f\u0318\u0003\\.\u0000\u0310\u0318\u0003"+ "^/\u0000\u0311\u0316\u0003`0\u0000\u0312\u0316\u0003b1\u0000\u0313\u0316"+ "\u0003d2\u0000\u0314\u0316\u0003P(\u0000\u0315\u0311\u0001\u0000\u0000"+ "\u0000\u0315\u0312\u0001\u0000\u0000\u0000\u0315\u0313\u0001\u0000\u0000"+ "\u0000\u0315\u0314\u0001\u0000\u0000\u0000\u0316\u0318\u0001\u0000\u0000"+ "\u0000\u0317\u0303\u0001\u0000\u0000\u0000\u0317\u0306\u0001\u0000\u0000"+ "\u0000\u0317\u030b\u0001\u0000\u0000\u0000\u0317\u030d\u0001\u0000\u0000"+ "\u0000\u0317\u030f\u0001\u0000\u0000\u0000\u0317\u0310\u0001\u0000\u0000"+ "\u0000\u0317\u0315\u0001\u0000\u0000\u0000\u0318\u036d\u0001\u0000\u0000"+ "\u0000\u0319\u031a\n\u0011\u0000\u0000\u031a\u031b\u0005m\u0000\u0000"+ "\u031b\u036c\u0003X,\u0011\u031c\u031d\n\u0010\u0000\u0000\u031d\u031e"+ "\u0007\u0005\u0000\u0000\u031e\u036c\u0003X,\u0011\u031f\u0320\n\u000f"+ "\u0000\u0000\u0320\u0321\u0007\u0006\u0000\u0000\u0321\u036c\u0003X,\u0010"+ "\u0322\u0323\n\u000e\u0000\u0000\u0323\u0324\u0007\u0007\u0000\u0000\u0324"+ "\u036c\u0003X,\u000f\u0325\u0326\n\r\u0000\u0000\u0326\u0327\u0005d\u0000"+ "\u0000\u0327\u036c\u0003X,\u000e\u0328\u0329\n\f\u0000\u0000\u0329\u032a"+ "\u0005c\u0000\u0000\u032a\u036c\u0003X,\r\u032b\u032c\n\u000b\u0000\u0000"+ "\u032c\u032d\u0005b\u0000\u0000\u032d\u036c\u0003X,\f\u032e\u032f\n\n"+ "\u0000\u0000\u032f\u0330\u0007\b\u0000\u0000\u0330\u036c\u0003X,\u000b"+ "\u0331\u0332\n\t\u0000\u0000\u0332\u0333\u0007\t\u0000\u0000\u0333\u036c"+ "\u0003X,\n\u0334\u0335\n\b\u0000\u0000\u0335\u0336\u0005a\u0000\u0000"+ "\u0336\u036c\u0003X,\t\u0337\u0338\n\u0007\u0000\u0000\u0338\u0339\u0005"+ "`\u0000\u0000\u0339\u036c\u0003X,\b\u033a\u033b\n\u0006\u0000\u0000\u033b"+ "\u033c\u0005P\u0000\u0000\u033c\u033d\u0003X,\u0000\u033d\u033e\u0005"+ "M\u0000\u0000\u033e\u033f\u0003X,\u0006\u033f\u036c\u0001\u0000\u0000"+ "\u0000\u0340\u0341\n\u0005\u0000\u0000\u0341\u0342\u0003Z-\u0000\u0342"+ "\u0343\u0003X,\u0005\u0343\u036c\u0001\u0000\u0000\u0000\u0344\u0345\n"+ "\u001a\u0000\u0000\u0345\u0347\u0005I\u0000\u0000\u0346\u0348\u0003X,"+ "\u0000\u0347\u0346\u0001\u0000\u0000\u0000\u0347\u0348\u0001\u0000\u0000"+ "\u0000\u0348\u0349\u0001\u0000\u0000\u0000\u0349\u036c\u0005J\u0000\u0000"+ "\u034a\u034b\n\u0019\u0000\u0000\u034b\u034d\u0005I\u0000\u0000\u034c"+ "\u034e\u0003X,\u0000\u034d\u034c\u0001\u0000\u0000\u0000\u034d\u034e\u0001"+ "\u0000\u0000\u0000\u034e\u034f\u0001\u0000\u0000\u0000\u034f\u0351\u0005"+ "M\u0000\u0000\u0350\u0352\u0003X,\u0000\u0351\u0350\u0001\u0000\u0000"+ "\u0000\u0351\u0352\u0001\u0000\u0000\u0000\u0352\u0353\u0001\u0000\u0000"+ "\u0000\u0353\u036c\u0005J\u0000\u0000\u0354\u0355\n\u0018\u0000\u0000"+ "\u0355\u0358\u0005O\u0000\u0000\u0356\u0359\u0003`0\u0000\u0357\u0359"+ "\u0005\u0003\u0000\u0000\u0358\u0356\u0001\u0000\u0000\u0000\u0358\u0357"+ "\u0001\u0000\u0000\u0000\u0359\u036c\u0001\u0000\u0000\u0000\u035a\u035b"+ "\n\u0017\u0000\u0000\u035b\u0364\u0005K\u0000\u0000\u035c\u0361\u0003"+ "\u0018\f\u0000\u035d\u035e\u0005_\u0000\u0000\u035e\u0360\u0003\u0018"+ "\f\u0000\u035f\u035d\u0001\u0000\u0000\u0000\u0360\u0363\u0001\u0000\u0000"+ "\u0000\u0361\u035f\u0001\u0000\u0000\u0000\u0361\u0362\u0001\u0000\u0000"+ "\u0000\u0362\u0365\u0001\u0000\u0000\u0000\u0363\u0361\u0001\u0000\u0000"+ "\u0000\u0364\u035c\u0001\u0000\u0000\u0000\u0364\u0365\u0001\u0000\u0000"+ "\u0000\u0365\u0366\u0001\u0000\u0000\u0000\u0366\u036c\u0005L\u0000\u0000"+ "\u0367\u0368\n\u0016\u0000\u0000\u0368\u036c\u0003\u001a\r\u0000\u0369"+ "\u036a\n\u0012\u0000\u0000\u036a\u036c\u0007\n\u0000\u0000\u036b\u0319"+ "\u0001\u0000\u0000\u0000\u036b\u031c\u0001\u0000\u0000\u0000\u036b\u031f"+ "\u0001\u0000\u0000\u0000\u036b\u0322\u0001\u0000\u0000\u0000\u036b\u0325"+ "\u0001\u0000\u0000\u0000\u036b\u0328\u0001\u0000\u0000\u0000\u036b\u032b"+ "\u0001\u0000\u0000\u0000\u036b\u032e\u0001\u0000\u0000\u0000\u036b\u0331"+ "\u0001\u0000\u0000\u0000\u036b\u0334\u0001\u0000\u0000\u0000\u036b\u0337"+ "\u0001\u0000\u0000\u0000\u036b\u033a\u0001\u0000\u0000\u0000\u036b\u0340"+ "\u0001\u0000\u0000\u0000\u036b\u0344\u0001\u0000\u0000\u0000\u036b\u034a"+ "\u0001\u0000\u0000\u0000\u036b\u0354\u0001\u0000\u0000\u0000\u036b\u035a"+ "\u0001\u0000\u0000\u0000\u036b\u0367\u0001\u0000\u0000\u0000\u036b\u0369"+ "\u0001\u0000\u0000\u0000\u036c\u036f\u0001\u0000\u0000\u0000\u036d\u036b"+ "\u0001\u0000\u0000\u0000\u036d\u036e\u0001\u0000\u0000\u0000\u036eY\u0001"+ "\u0000\u0000\u0000\u036f\u036d\u0001\u0000\u0000\u0000\u0370\u0371\u0007"+ "\u000b\u0000\u0000\u0371[\u0001\u0000\u0000\u0000\u0372\u0374\u0005G\u0000"+ "\u0000\u0373\u0375\u0003X,\u0000\u0374\u0373\u0001\u0000\u0000\u0000\u0374"+ "\u0375\u0001\u0000\u0000\u0000\u0375\u037c\u0001\u0000\u0000\u0000\u0376"+ "\u0378\u0005_\u0000\u0000\u0377\u0379\u0003X,\u0000\u0378\u0377\u0001"+ "\u0000\u0000\u0000\u0378\u0379\u0001\u0000\u0000\u0000\u0379\u037b\u0001"+ "\u0000\u0000\u0000\u037a\u0376\u0001\u0000\u0000\u0000\u037b\u037e\u0001"+ "\u0000\u0000\u0000\u037c\u037a\u0001\u0000\u0000\u0000\u037c\u037d\u0001"+ "\u0000\u0000\u0000\u037d\u037f\u0001\u0000\u0000\u0000\u037e\u037c\u0001"+ "\u0000\u0000\u0000\u037f\u0380\u0005H\u0000\u0000\u0380]\u0001\u0000\u0000"+ "\u0000\u0381\u0382\u0005I\u0000\u0000\u0382\u0387\u0003X,\u0000\u0383"+ "\u0384\u0005_\u0000\u0000\u0384\u0386\u0003X,\u0000\u0385\u0383\u0001"+ "\u0000\u0000\u0000\u0386\u0389\u0001\u0000\u0000\u0000\u0387\u0385\u0001"+ "\u0000\u0000\u0000\u0387\u0388\u0001\u0000\u0000\u0000\u0388\u038a\u0001"+ "\u0000\u0000\u0000\u0389\u0387\u0001\u0000\u0000\u0000\u038a\u038b\u0005"+ "J\u0000\u0000\u038b_\u0001\u0000\u0000\u0000\u038c\u038d\u0007\f\u0000"+ "\u0000\u038da\u0001\u0000\u0000\u0000\u038e\u0394\u0003h4\u0000\u038f"+ "\u0394\u0003n7\u0000\u0390\u0394\u0003f3\u0000\u0391\u0394\u0003j5\u0000"+ "\u0392\u0394\u0003l6\u0000\u0393\u038e\u0001\u0000\u0000\u0000\u0393\u038f"+ "\u0001\u0000\u0000\u0000\u0393\u0390\u0001\u0000\u0000\u0000\u0393\u0391"+ "\u0001\u0000\u0000\u0000\u0393\u0392\u0001\u0000\u0000\u0000\u0394c\u0001"+ "\u0000\u0000\u0000\u0395\u0396\u0003n7\u0000\u0396\u0397\u0005-\u0000"+ "\u0000\u0397e\u0001\u0000\u0000\u0000\u0398\u0399\u0007\r\u0000\u0000"+ "\u0399g\u0001\u0000\u0000\u0000\u039a\u039c\u0007\u000e\u0000\u0000\u039b"+ "\u039a\u0001\u0000\u0000\u0000\u039c\u039d\u0001\u0000\u0000\u0000\u039d"+ "\u039b\u0001\u0000\u0000\u0000\u039d\u039e\u0001\u0000\u0000\u0000\u039e"+ "i\u0001\u0000\u0000\u0000\u039f\u03a1\u0005}\u0000\u0000\u03a0\u039f\u0001"+ "\u0000\u0000\u0000\u03a1\u03a2\u0001\u0000\u0000\u0000\u03a2\u03a0\u0001"+ "\u0000\u0000\u0000\u03a2\u03a3\u0001\u0000\u0000\u0000\u03a3k\u0001\u0000"+ "\u0000\u0000\u03a4\u03a6\u0005|\u0000\u0000\u03a5\u03a4\u0001\u0000\u0000"+ "\u0000\u03a6\u03a7\u0001\u0000\u0000\u0000\u03a7\u03a5\u0001\u0000\u0000"+ "\u0000\u03a7\u03a8\u0001\u0000\u0000\u0000\u03a8m\u0001\u0000\u0000\u0000"+ "\u03a9\u03aa\u0007\u000f\u0000\u0000\u03aao\u0001\u0000\u0000\u0000\u03ab"+ "\u03b0\u0005K\u0000\u0000\u03ac\u03af\u0003t:\u0000\u03ad\u03af\u0003"+ "r9\u0000\u03ae\u03ac\u0001\u0000\u0000\u0000\u03ae\u03ad\u0001\u0000\u0000"+ "\u0000\u03af\u03b2\u0001\u0000\u0000\u0000\u03b0\u03ae\u0001\u0000\u0000"+ "\u0000\u03b0\u03b1\u0001\u0000\u0000\u0000\u03b1\u03b3\u0001\u0000\u0000"+ "\u0000\u03b2\u03b0\u0001\u0000\u0000\u0000\u03b3\u03b4\u0005L\u0000\u0000"+ "\u03b4q\u0001\u0000\u0000\u0000\u03b5\u03b6\u0005@\u0000\u0000\u03b6\u03b7"+ "\u0003p8\u0000\u03b7s\u0001\u0000\u0000\u0000\u03b8\u03c6\u0003p8\u0000"+ "\u03b9\u03c6\u0003v;\u0000\u03ba\u03c6\u0003x<\u0000\u03bb\u03c6\u0003"+ "z=\u0000\u03bc\u03c6\u0003|>\u0000\u03bd\u03c6\u0003~?\u0000\u03be\u03c6"+ "\u0003\u0080@\u0000\u03bf\u03c6\u0003\u0082A\u0000\u03c0\u03c6\u0003\u0084"+ "B\u0000\u03c1\u03c6\u0003\u0088D\u0000\u03c2\u03c6\u0003\u008aE\u0000"+ "\u03c3\u03c6\u0003\u008cF\u0000\u03c4\u03c6\u0003\u008eG\u0000\u03c5\u03b8"+ "\u0001\u0000\u0000\u0000\u03c5\u03b9\u0001\u0000\u0000\u0000\u03c5\u03ba"+ "\u0001\u0000\u0000\u0000\u03c5\u03bb\u0001\u0000\u0000\u0000\u03c5\u03bc"+ "\u0001\u0000\u0000\u0000\u03c5\u03bd\u0001\u0000\u0000\u0000\u03c5\u03be"+ "\u0001\u0000\u0000\u0000\u03c5\u03bf\u0001\u0000\u0000\u0000\u03c5\u03c0"+ "\u0001\u0000\u0000\u0000\u03c5\u03c1\u0001\u0000\u0000\u0000\u03c5\u03c2"+ "\u0001\u0000\u0000\u0000\u03c5\u03c3\u0001\u0000\u0000\u0000\u03c5\u03c4"+ "\u0001\u0000\u0000\u0000\u03c6u\u0001\u0000\u0000\u0000\u03c7\u03ca\u0003"+ "\u0096K\u0000\u03c8\u03ca\u0003\u0098L\u0000\u03c9\u03c7\u0001\u0000\u0000"+ "\u0000\u03c9\u03c8\u0001\u0000\u0000\u0000\u03caw\u0001\u0000\u0000\u0000"+ "\u03cb\u03cc\u0005!\u0000\u0000\u03cc\u03cd\u0005G\u0000\u0000\u03cd\u03ce"+ "\u0003X,\u0000\u03ce\u03cf\u0005H\u0000\u0000\u03cf\u03d2\u0003t:\u0000"+ "\u03d0\u03d1\u0005\u0012\u0000\u0000\u03d1\u03d3\u0003t:\u0000\u03d2\u03d0"+ "\u0001\u0000\u0000\u0000\u03d2\u03d3\u0001\u0000\u0000\u0000\u03d3y\u0001"+ "\u0000\u0000\u0000\u03d4\u03d5\u0005\u001c\u0000\u0000\u03d5\u03d8\u0005"+ "G\u0000\u0000\u03d6\u03d9\u0003v;\u0000\u03d7\u03d9\u0005N\u0000\u0000"+ "\u03d8\u03d6\u0001\u0000\u0000\u0000\u03d8\u03d7\u0001\u0000\u0000\u0000"+ "\u03d9\u03dc\u0001\u0000\u0000\u0000\u03da\u03dd\u0003\u0098L\u0000\u03db"+ "\u03dd\u0005N\u0000\u0000\u03dc\u03da\u0001\u0000\u0000\u0000\u03dc\u03db"+ "\u0001\u0000\u0000\u0000\u03dd\u03df\u0001\u0000\u0000\u0000\u03de\u03e0"+ "\u0003X,\u0000\u03df\u03de\u0001\u0000\u0000\u0000\u03df\u03e0\u0001\u0000"+ "\u0000\u0000\u03e0\u03e1\u0001\u0000\u0000\u0000\u03e1\u03e2\u0005H\u0000"+ "\u0000\u03e2\u03e3\u0003t:\u0000\u03e3{\u0001\u0000\u0000\u0000\u03e4"+ "\u03e5\u0005F\u0000\u0000\u03e5\u03e6\u0005G\u0000\u0000\u03e6\u03e7\u0003"+ "X,\u0000\u03e7\u03e8\u0005H\u0000\u0000\u03e8\u03e9\u0003t:\u0000\u03e9"+ "}\u0001\u0000\u0000\u0000\u03ea\u03eb\u0005\u0011\u0000\u0000\u03eb\u03ec"+ "\u0003t:\u0000\u03ec\u03ed\u0005F\u0000\u0000\u03ed\u03ee\u0005G\u0000"+ "\u0000\u03ee\u03ef\u0003X,\u0000\u03ef\u03f0\u0005H\u0000\u0000\u03f0"+ "\u03f1\u0005N\u0000\u0000\u03f1\u007f\u0001\u0000\u0000\u0000\u03f2\u03f3"+ "\u0005\u000e\u0000\u0000\u03f3\u03f4\u0005N\u0000\u0000\u03f4\u0081\u0001"+ "\u0000\u0000\u0000\u03f5\u03f6\u0005\b\u0000\u0000\u03f6\u03f7\u0005N"+ "\u0000\u0000\u03f7\u0083\u0001\u0000\u0000\u0000\u03f8\u03f9\u0005=\u0000"+ "\u0000\u03f9\u03ff\u0003X,\u0000\u03fa\u03fb\u00056\u0000\u0000\u03fb"+ "\u03fc\u0005G\u0000\u0000\u03fc\u03fd\u0003\"\u0011\u0000\u03fd\u03fe"+ "\u0005H\u0000\u0000\u03fe\u0400\u0001\u0000\u0000\u0000\u03ff\u03fa\u0001"+ "\u0000\u0000\u0000\u03ff\u0400\u0001\u0000\u0000\u0000\u0400\u0401\u0001"+ "\u0000\u0000\u0000\u0401\u0403\u0003p8\u0000\u0402\u0404\u0003\u0086C"+ "\u0000\u0403\u0402\u0001\u0000\u0000\u0000\u0404\u0405\u0001\u0000\u0000"+ "\u0000\u0405\u0403\u0001\u0000\u0000\u0000\u0405\u0406\u0001\u0000\u0000"+ "\u0000\u0406\u0085\u0001\u0000\u0000\u0000\u0407\u040f\u0005\u000b\u0000"+ "\u0000\u0408\u040a\u0003`0\u0000\u0409\u0408\u0001\u0000\u0000\u0000\u0409"+ "\u040a\u0001\u0000\u0000\u0000\u040a\u040b\u0001\u0000\u0000\u0000\u040b"+ "\u040c\u0005G\u0000\u0000\u040c\u040d\u0003\"\u0011\u0000\u040d\u040e"+ "\u0005H\u0000\u0000\u040e\u0410\u0001\u0000\u0000\u0000\u040f\u0409\u0001"+ "\u0000\u0000\u0000\u040f\u0410\u0001\u0000\u0000\u0000\u0410\u0411\u0001"+ "\u0000\u0000\u0000\u0411\u0412\u0003p8\u0000\u0412\u0087\u0001\u0000\u0000"+ "\u0000\u0413\u0415\u00055\u0000\u0000\u0414\u0416\u0003X,\u0000\u0415"+ "\u0414\u0001\u0000\u0000\u0000\u0415\u0416\u0001\u0000\u0000\u0000\u0416"+ "\u0417\u0001\u0000\u0000\u0000\u0417\u0418\u0005N\u0000\u0000\u0418\u0089"+ "\u0001\u0000\u0000\u0000\u0419\u041a\u0005\u0013\u0000\u0000\u041a\u041b"+ "\u0003X,\u0000\u041b\u041c\u0003\u001a\r\u0000\u041c\u041d\u0005N\u0000"+ "\u0000\u041d\u008b\u0001\u0000\u0000\u0000\u041e\u041f\u00057\u0000\u0000"+ "\u041f\u0420\u0003X,\u0000\u0420\u0421\u0003\u001a\r\u0000\u0421\u0422"+ "\u0005N\u0000\u0000\u0422\u008d\u0001\u0000\u0000\u0000\u0423\u0425\u0005"+ "\u0006\u0000\u0000\u0424\u0426\u0005\u0086\u0000\u0000\u0425\u0424\u0001"+ "\u0000\u0000\u0000\u0425\u0426\u0001\u0000\u0000\u0000\u0426\u0428\u0001"+ "\u0000\u0000\u0000\u0427\u0429\u0003\u0090H\u0000\u0428\u0427\u0001\u0000"+ "\u0000\u0000\u0428\u0429\u0001\u0000\u0000\u0000\u0429\u042a\u0001\u0000"+ "\u0000\u0000\u042a\u042e\u0005\u0087\u0000\u0000\u042b\u042d\u0003\u009e"+ "O\u0000\u042c\u042b\u0001\u0000\u0000\u0000\u042d\u0430\u0001\u0000\u0000"+ "\u0000\u042e\u042c\u0001\u0000\u0000\u0000\u042e\u042f\u0001\u0000\u0000"+ "\u0000\u042f\u0431\u0001\u0000\u0000\u0000\u0430\u042e\u0001\u0000\u0000"+ "\u0000\u0431\u0432\u0005\u009e\u0000\u0000\u0432\u008f\u0001\u0000\u0000"+ "\u0000\u0433\u0434\u0005\u0089\u0000\u0000\u0434\u0439\u0005\u0088\u0000"+ "\u0000\u0435\u0436\u0005\u008b\u0000\u0000\u0436\u0438\u0005\u0088\u0000"+ "\u0000\u0437\u0435\u0001\u0000\u0000\u0000\u0438\u043b\u0001\u0000\u0000"+ "\u0000\u0439\u0437\u0001\u0000\u0000\u0000\u0439\u043a\u0001\u0000\u0000"+ "\u0000\u043a\u043c\u0001\u0000\u0000\u0000\u043b\u0439\u0001\u0000\u0000"+ "\u0000\u043c\u043d\u0005\u008a\u0000\u0000\u043d\u0091\u0001\u0000\u0000"+ "\u0000\u043e\u0443\u0003T*\u0000\u043f\u0440\u0005_\u0000\u0000\u0440"+ "\u0442\u0003T*\u0000\u0441\u043f\u0001\u0000\u0000\u0000\u0442\u0445\u0001"+ "\u0000\u0000\u0000\u0443\u0441\u0001\u0000\u0000\u0000\u0443\u0444\u0001"+ "\u0000\u0000\u0000\u0444\u0093\u0001\u0000\u0000\u0000\u0445\u0443\u0001"+ "\u0000\u0000\u0000\u0446\u044a\u0005G\u0000\u0000\u0447\u0449\u0005_\u0000"+ "\u0000\u0448\u0447\u0001\u0000\u0000\u0000\u0449\u044c\u0001\u0000\u0000"+ "\u0000\u044a\u0448\u0001\u0000\u0000\u0000\u044a\u044b\u0001\u0000\u0000"+ "\u0000\u044b\u044d\u0001\u0000\u0000\u0000\u044c\u044a\u0001\u0000\u0000"+ "\u0000\u044d\u044e\u0003T*\u0000\u044e\u0455\u0001\u0000\u0000\u0000\u044f"+ "\u0451\u0005_\u0000\u0000\u0450\u0452\u0003T*\u0000\u0451\u0450\u0001"+ "\u0000\u0000\u0000\u0451\u0452\u0001\u0000\u0000\u0000\u0452\u0454\u0001"+ "\u0000\u0000\u0000\u0453\u044f\u0001\u0000\u0000\u0000\u0454\u0457\u0001"+ "\u0000\u0000\u0000\u0455\u0453\u0001\u0000\u0000\u0000\u0455\u0456\u0001"+ "\u0000\u0000\u0000\u0456\u0458\u0001\u0000\u0000\u0000\u0457\u0455\u0001"+ "\u0000\u0000\u0000\u0458\u0459\u0005H\u0000\u0000\u0459\u0095\u0001\u0000"+ "\u0000\u0000\u045a\u045d\u0003T*\u0000\u045b\u045c\u0005S\u0000\u0000"+ "\u045c\u045e\u0003X,\u0000\u045d\u045b\u0001\u0000\u0000\u0000\u045d\u045e"+ "\u0001\u0000\u0000\u0000\u045e\u0464\u0001\u0000\u0000\u0000\u045f\u0460"+ "\u0003\u0094J\u0000\u0460\u0461\u0005S\u0000\u0000\u0461\u0462\u0003X"+ ",\u0000\u0462\u0464\u0001\u0000\u0000\u0000\u0463\u045a\u0001\u0000\u0000"+ "\u0000\u0463\u045f\u0001\u0000\u0000\u0000\u0464\u0465\u0001\u0000\u0000"+ "\u0000\u0465\u0466\u0005N\u0000\u0000\u0466\u0097\u0001\u0000\u0000\u0000"+ "\u0467\u0468\u0003X,\u0000\u0468\u0469\u0005N\u0000\u0000\u0469\u0099"+ "\u0001\u0000\u0000\u0000\u046a\u046b\u0005)\u0000\u0000\u046b\u046c\u0005"+ "G\u0000\u0000\u046c\u046e\u0003\u009cN\u0000\u046d\u046f\u0003`0\u0000"+ "\u046e\u046d\u0001\u0000\u0000\u0000\u046e\u046f\u0001\u0000\u0000\u0000"+ "\u046f\u0470\u0001\u0000\u0000\u0000\u0470\u0471\u0005Q\u0000\u0000\u0471"+ "\u0473\u0003N\'\u0000\u0472\u0474\u0003`0\u0000\u0473\u0472\u0001\u0000"+ "\u0000\u0000\u0473\u0474\u0001\u0000\u0000\u0000\u0474\u0475\u0001\u0000"+ "\u0000\u0000\u0475\u0476\u0005H\u0000\u0000\u0476\u009b\u0001\u0000\u0000"+ "\u0000\u0477\u047a\u0003P(\u0000\u0478\u047a\u0003\u001c\u000e\u0000\u0479"+ "\u0477\u0001\u0000\u0000\u0000\u0479\u0478\u0001\u0000\u0000\u0000\u047a"+ "\u009d\u0001\u0000\u0000\u0000\u047b\u0487\u0003\u00a0P\u0000\u047c\u0487"+ "\u0003\u00a2Q\u0000\u047d\u0487\u0003\u00a4R\u0000\u047e\u0487\u0003\u00b2"+ "Y\u0000\u047f\u0487\u0003\u00a6S\u0000\u0480\u0487\u0003\u00a8T\u0000"+ "\u0481\u0487\u0003\u00acV\u0000\u0482\u0487\u0005\u0097\u0000\u0000\u0483"+ "\u0487\u0005\u008f\u0000\u0000\u0484\u0487\u0005\u0091\u0000\u0000\u0485"+ "\u0487\u0003\u00aeW\u0000\u0486\u047b\u0001\u0000\u0000\u0000\u0486\u047c"+ "\u0001\u0000\u0000\u0000\u0486\u047d\u0001\u0000\u0000\u0000\u0486\u047e"+ "\u0001\u0000\u0000\u0000\u0486\u047f\u0001\u0000\u0000\u0000\u0486\u0480"+ "\u0001\u0000\u0000\u0000\u0486\u0481\u0001\u0000\u0000\u0000\u0486\u0482"+ "\u0001\u0000\u0000\u0000\u0486\u0483\u0001\u0000\u0000\u0000\u0486\u0484"+ "\u0001\u0000\u0000\u0000\u0486\u0485\u0001\u0000\u0000\u0000\u0487\u009f"+ "\u0001\u0000\u0000\u0000\u0488\u048c\u0005\u009d\u0000\u0000\u0489\u048b"+ "\u0003\u009eO\u0000\u048a\u0489\u0001\u0000\u0000\u0000\u048b\u048e\u0001"+ "\u0000\u0000\u0000\u048c\u048a\u0001\u0000\u0000\u0000\u048c\u048d\u0001"+ "\u0000\u0000\u0000\u048d\u048f\u0001\u0000\u0000\u0000\u048e\u048c\u0001"+ "\u0000\u0000\u0000\u048f\u0490\u0005\u009e\u0000\u0000\u0490\u00a1\u0001"+ "\u0000\u0000\u0000\u0491\u0492\u0005\u0098\u0000\u0000\u0492\u0495\u0005"+ "\u00a5\u0000\u0000\u0493\u0494\u0005\u00a1\u0000\u0000\u0494\u0496\u0003"+ "\u00b8\\\u0000\u0495\u0493\u0001\u0000\u0000\u0000\u0495\u0496\u0001\u0000"+ "\u0000\u0000\u0496\u04a5\u0001\u0000\u0000\u0000\u0497\u0498\u0005\u0098"+ "\u0000\u0000\u0498\u049d\u0005\u00a5\u0000\u0000\u0499\u049a\u0005\u00a3"+ "\u0000\u0000\u049a\u049c\u0005\u00a5\u0000\u0000\u049b\u0499\u0001\u0000"+ "\u0000\u0000\u049c\u049f\u0001\u0000\u0000\u0000\u049d\u049b\u0001\u0000"+ "\u0000\u0000\u049d\u049e\u0001\u0000\u0000\u0000\u049e\u04a2\u0001\u0000"+ "\u0000\u0000\u049f\u049d\u0001\u0000\u0000\u0000\u04a0\u04a1\u0005\u00a1"+ "\u0000\u0000\u04a1\u04a3\u0003\u00b2Y\u0000\u04a2\u04a0\u0001\u0000\u0000"+ "\u0000\u04a2\u04a3\u0001\u0000\u0000\u0000\u04a3\u04a5\u0001\u0000\u0000"+ "\u0000\u04a4\u0491\u0001\u0000\u0000\u0000\u04a4\u0497\u0001\u0000\u0000"+ "\u0000\u04a5\u00a3\u0001\u0000\u0000\u0000\u04a6\u04a7\u0003\u00b0X\u0000"+ "\u04a7\u04a8\u0005\u00a1\u0000\u0000\u04a8\u04a9\u0003\u00b8\\\u0000\u04a9"+ "\u04b5\u0001\u0000\u0000\u0000\u04aa\u04ad\u0003\u00b0X\u0000\u04ab\u04ac"+ "\u0005\u00a3\u0000\u0000\u04ac\u04ae\u0003\u00b0X\u0000\u04ad\u04ab\u0001"+ "\u0000\u0000\u0000\u04ae\u04af\u0001\u0000\u0000\u0000\u04af\u04ad\u0001"+ "\u0000\u0000\u0000\u04af\u04b0\u0001\u0000\u0000\u0000\u04b0\u04b1\u0001"+ "\u0000\u0000\u0000\u04b1\u04b2\u0005\u00a1\u0000\u0000\u04b2\u04b3\u0003"+ "\u00b2Y\u0000\u04b3\u04b5\u0001\u0000\u0000\u0000\u04b4\u04a6\u0001\u0000"+ "\u0000\u0000\u04b4\u04aa\u0001\u0000\u0000\u0000\u04b5\u00a5\u0001\u0000"+ "\u0000\u0000\u04b6\u04b7\u0005\u0096\u0000\u0000\u04b7\u04b8\u0003\u00b8"+ "\\\u0000\u04b8\u04b9\u0003\u00a0P\u0000\u04b9\u00a7\u0001\u0000\u0000"+ "\u0000\u04ba\u04bb\u0005\u0094\u0000\u0000\u04bb\u04bc\u0003\u00a0P\u0000"+ "\u04bc\u04bd\u0003\u00b8\\\u0000\u04bd\u04be\u0003\u00a0P\u0000\u04be"+ "\u04bf\u0003\u00a0P\u0000\u04bf\u00a9\u0001\u0000\u0000\u0000\u04c0\u04c1"+ "\u0005\u0090\u0000\u0000\u04c1\u04c2\u0003\u00b6[\u0000\u04c2\u04c3\u0003"+ "\u00a0P\u0000\u04c3\u00ab\u0001\u0000\u0000\u0000\u04c4\u04c5\u0005\u0099"+ "\u0000\u0000\u04c5\u04d1\u0003\u00b8\\\u0000\u04c6\u04c8\u0003\u00aaU"+ "\u0000\u04c7\u04c6\u0001\u0000\u0000\u0000\u04c8\u04c9\u0001\u0000\u0000"+ "\u0000\u04c9\u04c7\u0001\u0000\u0000\u0000\u04c9\u04ca\u0001\u0000\u0000"+ "\u0000\u04ca\u04cd\u0001\u0000\u0000\u0000\u04cb\u04cc\u0005\u0092\u0000"+ "\u0000\u04cc\u04ce\u0003\u00a0P\u0000\u04cd\u04cb\u0001\u0000\u0000\u0000"+ "\u04cd\u04ce\u0001\u0000\u0000\u0000\u04ce\u04d2\u0001\u0000\u0000\u0000"+ "\u04cf\u04d0\u0005\u0092\u0000\u0000\u04d0\u04d2\u0003\u00a0P\u0000\u04d1"+ "\u04c7\u0001\u0000\u0000\u0000\u04d1\u04cf\u0001\u0000\u0000\u0000\u04d2"+ "\u00ad\u0001\u0000\u0000\u0000\u04d3\u04d4\u0005\u0095\u0000\u0000\u04d4"+ "\u04d5\u0005\u00a5\u0000\u0000\u04d5\u04de\u0005\u009f\u0000\u0000\u04d6"+ "\u04db\u0005\u00a5\u0000\u0000\u04d7\u04d8\u0005\u00a3\u0000\u0000\u04d8"+ "\u04da\u0005\u00a5\u0000\u0000\u04d9\u04d7\u0001\u0000\u0000\u0000\u04da"+ "\u04dd\u0001\u0000\u0000\u0000\u04db\u04d9\u0001\u0000\u0000\u0000\u04db"+ "\u04dc\u0001\u0000\u0000\u0000\u04dc\u04df\u0001\u0000\u0000\u0000\u04dd"+ "\u04db\u0001\u0000\u0000\u0000\u04de\u04d6\u0001\u0000\u0000\u0000\u04de"+ "\u04df\u0001\u0000\u0000\u0000\u04df\u04e0\u0001\u0000\u0000\u0000\u04e0"+ "\u04ea\u0005\u00a0\u0000\u0000\u04e1\u04e2\u0005\u00a4\u0000\u0000\u04e2"+ "\u04e7\u0005\u00a5\u0000\u0000\u04e3\u04e4\u0005\u00a3\u0000\u0000\u04e4"+ "\u04e6\u0005\u00a5\u0000\u0000\u04e5\u04e3\u0001\u0000\u0000\u0000\u04e6"+ "\u04e9\u0001\u0000\u0000\u0000\u04e7\u04e5\u0001\u0000\u0000\u0000\u04e7"+ "\u04e8\u0001\u0000\u0000\u0000\u04e8\u04eb\u0001\u0000\u0000\u0000\u04e9"+ "\u04e7\u0001\u0000\u0000\u0000\u04ea\u04e1\u0001\u0000\u0000\u0000\u04ea"+ "\u04eb\u0001\u0000\u0000\u0000\u04eb\u04ec\u0001\u0000\u0000\u0000\u04ec"+ "\u04ed\u0003\u00a0P\u0000\u04ed\u00af\u0001\u0000\u0000\u0000\u04ee\u04f3"+ "\u0005\u00a5\u0000\u0000\u04ef\u04f0\u0005\u00a2\u0000\u0000\u04f0\u04f2"+ "\u0007\u0010\u0000\u0000\u04f1\u04ef\u0001\u0000\u0000\u0000\u04f2\u04f5"+ "\u0001\u0000\u0000\u0000\u04f3\u04f1\u0001\u0000\u0000\u0000\u04f3\u04f4"+ "\u0001\u0000\u0000\u0000\u04f4\u00b1\u0001\u0000\u0000\u0000\u04f5\u04f3"+ "\u0001\u0000\u0000\u0000\u04f6\u04f7\u0007\u0010\u0000\u0000\u04f7\u0500"+ "\u0005\u009f\u0000\u0000\u04f8\u04fd\u0003\u00b8\\\u0000\u04f9\u04fa\u0005"+ "\u00a3\u0000\u0000\u04fa\u04fc\u0003\u00b8\\\u0000\u04fb\u04f9\u0001\u0000"+ "\u0000\u0000\u04fc\u04ff\u0001\u0000\u0000\u0000\u04fd\u04fb\u0001\u0000"+ "\u0000\u0000\u04fd\u04fe\u0001\u0000\u0000\u0000\u04fe\u0501\u0001\u0000"+ "\u0000\u0000\u04ff\u04fd\u0001\u0000\u0000\u0000\u0500\u04f8\u0001\u0000"+ "\u0000\u0000\u0500\u0501\u0001\u0000\u0000\u0000\u0501\u0502\u0001\u0000"+ "\u0000\u0000\u0502\u0503\u0005\u00a0\u0000\u0000\u0503\u00b3\u0001\u0000"+ "\u0000\u0000\u0504\u0505\u0007\u0011\u0000\u0000\u0505\u00b5\u0001\u0000"+ "\u0000\u0000\u0506\u050c\u0005\u00a7\u0000\u0000\u0507\u050c\u0005\u00a8"+ "\u0000\u0000\u0508\u050c\u0005\u00a6\u0000\u0000\u0509\u050c\u0003\u00b4"+ "Z\u0000\u050a\u050c\u0005\u00a9\u0000\u0000\u050b\u0506\u0001\u0000\u0000"+ "\u0000\u050b\u0507\u0001\u0000\u0000\u0000\u050b\u0508\u0001\u0000\u0000"+ "\u0000\u050b\u0509\u0001\u0000\u0000\u0000\u050b\u050a\u0001\u0000\u0000"+ "\u0000\u050c\u00b7\u0001\u0000\u0000\u0000\u050d\u0511\u0003\u00b0X\u0000"+ "\u050e\u0511\u0003\u00b2Y\u0000\u050f\u0511\u0003\u00b6[\u0000\u0510\u050d"+ "\u0001\u0000\u0000\u0000\u0510\u050e\u0001\u0000\u0000\u0000\u0510\u050f"+ "\u0001\u0000\u0000\u0000\u0511\u00b9\u0001\u0000\u0000\u0000\u008d\u00c7"+ "\u00c9\u00d2\u00da\u00e6\u00ed\u00f7\u00fd\u0102\u0108\u0110\u0116\u0121"+ "\u012c\u0131\u013f\u014b\u014e\u0156\u0159\u015c\u0165\u016a\u0173\u0178"+ "\u017b\u0180\u018d\u018f\u019d\u01a2\u01a8\u01ac\u01bf\u01c1\u01c9\u01cd"+ "\u01d3\u01d6\u01df\u01e1\u01e6\u01ed\u01ff\u0201\u020b\u020f\u0222\u0224"+ "\u0229\u0231\u0241\u0260\u0262\u0268\u0275\u0278\u0282\u0285\u0289\u028f"+ "\u0299\u029c\u02ab\u02b0\u02b5\u02b8\u02bf\u02c6\u02cb\u02d0\u02df\u02e4"+ "\u02ef\u02f1\u02f9\u02fd\u0315\u0317\u0347\u034d\u0351\u0358\u0361\u0364"+ "\u036b\u036d\u0374\u0378\u037c\u0387\u0393\u039d\u03a2\u03a7\u03ae\u03b0"+ "\u03c5\u03c9\u03d2\u03d8\u03dc\u03df\u03ff\u0405\u0409\u040f\u0415\u0425"+ "\u0428\u042e\u0439\u0443\u044a\u0451\u0455\u045d\u0463\u046e\u0473\u0479"+ "\u0486\u048c\u0495\u049d\u04a2\u04a4\u04af\u04b4\u04c9\u04cd\u04d1\u04db"+ "\u04de\u04e7\u04ea\u04f3\u04fd\u0500\u050b\u0510"; 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); } } }